@c3-oss/prosa 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,4 +1,6 @@
 import { createRequire as __prosaCreateRequire } from 'module'; const require = __prosaCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/core/bundle.ts
 import { constants as fsConstants } from "fs";
@@ -10,15 +12,22 @@ import path from "path";
 import Database from "better-sqlite3";
 function openDb(path15) {
   const db = new Database(path15);
+  db.pragma("page_size = 16384");
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   db.pragma("synchronous = NORMAL");
   db.pragma("busy_timeout = 5000");
+  db.pragma("cache_size = -262144");
+  db.pragma("mmap_size = 268435456");
+  db.pragma("temp_store = MEMORY");
+  db.pragma("wal_autocheckpoint = 20000");
   return db;
 }
+__name(openDb, "openDb");
 function closeDb(db) {
   db.close();
 }
+__name(closeDb, "closeDb");
 var stmtCache = /* @__PURE__ */ new WeakMap();
 function prepare(db, sql) {
   let cache = stmtCache.get(db);
@@ -33,10 +42,12 @@ function prepare(db, sql) {
   }
   return stmt;
 }
+__name(prepare, "prepare");
 function transactional(db, fn) {
   const wrapped = db.transaction(fn);
   return wrapped();
 }
+__name(transactional, "transactional");
 
 // src/core/schema/sql/001_init.ts
 var SQL_001_INIT = String.raw`
@@ -683,10 +694,26 @@ ALTER TABLE search_index_status ADD COLUMN schema_fingerprint TEXT;
 
 // src/core/schema/migrate.ts
 var MIGRATIONS = [
-  { version: 1, name: "init", sql: SQL_001_INIT },
-  { version: 2, name: "search_index_status", sql: SQL_002_SEARCH_INDEX_STATUS },
-  { version: 3, name: "analytics_views", sql: SQL_003_ANALYTICS_VIEWS },
-  { version: 4, name: "tantivy_checkpoint", sql: SQL_004_TANTIVY_CHECKPOINT }
+  {
+    version: 1,
+    name: "init",
+    sql: SQL_001_INIT
+  },
+  {
+    version: 2,
+    name: "search_index_status",
+    sql: SQL_002_SEARCH_INDEX_STATUS
+  },
+  {
+    version: 3,
+    name: "analytics_views",
+    sql: SQL_003_ANALYTICS_VIEWS
+  },
+  {
+    version: 4,
+    name: "tantivy_checkpoint",
+    sql: SQL_004_TANTIVY_CHECKPOINT
+  }
 ];
 function runMigrations(db) {
   db.exec(`
@@ -696,35 +723,31 @@ function runMigrations(db) {
       applied_at TEXT NOT NULL
     );
   `);
-  const applied = new Set(
-    db.prepare(`SELECT version FROM _prosa_migrations`).all().map((row) => row.version)
-  );
+  const applied = new Set(db.prepare(`SELECT version FROM _prosa_migrations`).all().map((row) => row.version));
   const newlyApplied = [];
   for (const migration of MIGRATIONS) {
     if (applied.has(migration.version)) continue;
     const tx = db.transaction(() => {
       db.exec(migration.sql);
-      db.prepare(`INSERT INTO _prosa_migrations(version, name, applied_at) VALUES (?, ?, ?)`).run(
-        migration.version,
-        migration.name,
-        (/* @__PURE__ */ new Date()).toISOString()
-      );
+      db.prepare(`INSERT INTO _prosa_migrations(version, name, applied_at) VALUES (?, ?, ?)`).run(migration.version, migration.name, (/* @__PURE__ */ new Date()).toISOString());
     });
     tx();
     newlyApplied.push(migration.version);
   }
-  return { applied: newlyApplied };
+  return {
+    applied: newlyApplied
+  };
 }
+__name(runMigrations, "runMigrations");
 function currentSchemaVersion(db) {
   try {
-    const row = db.prepare(
-      `SELECT MAX(version) AS version FROM _prosa_migrations`
-    ).get();
+    const row = db.prepare(`SELECT MAX(version) AS version FROM _prosa_migrations`).get();
     return row?.version ?? 0;
   } catch {
     return 0;
   }
 }
+__name(currentSchemaVersion, "currentSchemaVersion");
 
 // src/core/version.ts
 var PROSA_PARSER_VERSION = "0.1.0";
@@ -736,6 +759,7 @@ function defaultBundlePath() {
   if (env && env.length > 0) return path.resolve(env);
   return path.join(os.homedir(), ".prosa");
 }
+__name(defaultBundlePath, "defaultBundlePath");
 function bundlePaths(rootPath) {
   return {
     db: path.join(rootPath, "prosa.sqlite"),
@@ -749,6 +773,7 @@ function bundlePaths(rootPath) {
     lock: path.join(rootPath, "prosa.lock")
   };
 }
+__name(bundlePaths, "bundlePaths");
 async function exists(p) {
   try {
     await access(p, fsConstants.F_OK);
@@ -757,21 +782,34 @@ async function exists(p) {
     return false;
   }
 }
+__name(exists, "exists");
 async function initBundle(rootPath) {
   const resolved = path.resolve(rootPath);
   const paths = bundlePaths(resolved);
-  await mkdir(resolved, { recursive: true });
+  await mkdir(resolved, {
+    recursive: true
+  });
   if (await exists(paths.manifest)) {
-    throw new Error(
-      `bundle already exists at ${resolved} (found manifest.json) \u2014 use openBundle instead`
-    );
+    throw new Error(`bundle already exists at ${resolved} (found manifest.json) \u2014 use openBundle instead`);
   }
-  await mkdir(paths.objects, { recursive: true });
-  await mkdir(paths.rawSources, { recursive: true });
-  await mkdir(paths.search, { recursive: true });
-  await mkdir(paths.tantivy, { recursive: true });
-  await mkdir(paths.exports, { recursive: true });
-  await mkdir(paths.parquet, { recursive: true });
+  await mkdir(paths.objects, {
+    recursive: true
+  });
+  await mkdir(paths.rawSources, {
+    recursive: true
+  });
+  await mkdir(paths.search, {
+    recursive: true
+  });
+  await mkdir(paths.tantivy, {
+    recursive: true
+  });
+  await mkdir(paths.exports, {
+    recursive: true
+  });
+  await mkdir(paths.parquet, {
+    recursive: true
+  });
   const manifest = {
     version: 1,
     parser_version: PROSA_PARSER_VERSION,
@@ -784,8 +822,14 @@ async function initBundle(rootPath) {
 `, "utf8");
   const db = openDb(paths.db);
   runMigrations(db);
-  return { path: resolved, db, manifest, paths };
+  return {
+    path: resolved,
+    db,
+    manifest,
+    paths
+  };
 }
+__name(initBundle, "initBundle");
 async function openBundle(rootPath) {
   const resolved = path.resolve(rootPath);
   const paths = bundlePaths(resolved);
@@ -794,13 +838,15 @@ async function openBundle(rootPath) {
     throw new Error(`bundle path not found or not a directory: ${resolved}`);
   }
   if (!await exists(paths.manifest)) {
-    throw new Error(
-      `no manifest.json in ${resolved} \u2014 initialize first with \`prosa init --store ${resolved}\``
-    );
+    throw new Error(`no manifest.json in ${resolved} \u2014 initialize first with \`prosa init --store ${resolved}\``);
   }
   const manifest = JSON.parse(await readFile(paths.manifest, "utf8"));
-  await mkdir(paths.search, { recursive: true });
-  await mkdir(paths.tantivy, { recursive: true });
+  await mkdir(paths.search, {
+    recursive: true
+  });
+  await mkdir(paths.tantivy, {
+    recursive: true
+  });
   const db = openDb(paths.db);
   runMigrations(db);
   const currentVersion = currentSchemaVersion(db);
@@ -808,13 +854,27 @@ async function openBundle(rootPath) {
     closeDb(db);
     throw new Error(`schema version mismatch (db=${currentVersion}, code=${PROSA_SCHEMA_VERSION})`);
   }
+  let manifestDirty = false;
   if (manifest.parser_version !== PROSA_PARSER_VERSION) {
     manifest.parser_version = PROSA_PARSER_VERSION;
+    manifestDirty = true;
+  }
+  if (manifest.schema_version !== currentVersion) {
+    manifest.schema_version = currentVersion;
+    manifestDirty = true;
+  }
+  if (manifestDirty) {
     await writeFile(paths.manifest, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   }
-  return { path: resolved, db, manifest, paths };
+  return {
+    path: resolved,
+    db,
+    manifest,
+    paths
+  };
 }
+__name(openBundle, "openBundle");
 async function openOrInitBundle(rootPath) {
   const resolved = path.resolve(rootPath);
   const paths = bundlePaths(resolved);
@@ -827,9 +887,11 @@ async function openOrInitBundle(rootPath) {
   }
   return await openBundle(resolved);
 }
+__name(openOrInitBundle, "openOrInitBundle");
 function closeBundle(bundle) {
   closeDb(bundle.db);
 }
+__name(closeBundle, "closeBundle");
 
 // src/core/cas/index.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
@@ -841,15 +903,25 @@ var COMPRESS_THRESHOLD_BYTES = 256;
 var ZSTD_LEVEL = 3;
 function compressBytes(input) {
   if (input.byteLength < COMPRESS_THRESHOLD_BYTES) {
-    return { bytes: Buffer.from(input), compression: "none" };
+    return {
+      bytes: Buffer.from(input),
+      compression: "none"
+    };
   }
-  const out = zstdCompress(Buffer.from(input), { compressionLevel: ZSTD_LEVEL });
-  return { bytes: out, compression: "zstd" };
+  const out = zstdCompress(Buffer.from(input), {
+    compressionLevel: ZSTD_LEVEL
+  });
+  return {
+    bytes: out,
+    compression: "zstd"
+  };
 }
+__name(compressBytes, "compressBytes");
 function decompressBytes(input, compression) {
   if (compression === "none") return input;
   return zstdDecompress(input);
 }
+__name(decompressBytes, "decompressBytes");
 
 // src/core/cas/hash.ts
 import { createHash } from "crypto";
@@ -858,60 +930,52 @@ import { bytesToHex } from "@noble/hashes/utils";
 function blake3Hex(bytes) {
   return bytesToHex(blake3(bytes));
 }
+__name(blake3Hex, "blake3Hex");
 function sha256Hex(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
 }
+__name(sha256Hex, "sha256Hex");
 function objectIdFromHash(hashHex) {
   return `blake3:${hashHex}`;
 }
+__name(objectIdFromHash, "objectIdFromHash");
 function objectStoragePath(hashHex, compression) {
   const ext = compression === "zstd" ? ".zst" : ".bin";
   const a = hashHex.slice(0, 2);
   const b = hashHex.slice(2, 4);
   return `objects/blake3/${a}/${b}/${hashHex}${ext}`;
 }
+__name(objectStoragePath, "objectStoragePath");
 
 // src/core/cas/index.ts
 var ensuredDirs = /* @__PURE__ */ new Set();
 async function ensureDir(absoluteDir) {
   if (ensuredDirs.has(absoluteDir)) return;
-  await mkdir2(absoluteDir, { recursive: true });
+  await mkdir2(absoluteDir, {
+    recursive: true
+  });
   ensuredDirs.add(absoluteDir);
 }
+__name(ensureDir, "ensureDir");
 async function putBytes(bundle, bytes, options = {}) {
   const hash = blake3Hex(bytes);
   const objectId = objectIdFromHash(hash);
-  const existing = prepare(
-    bundle.db,
-    `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
+  const existing = prepare(bundle.db, `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
             compression, mime_type, encoding, storage_path, created_at
-       FROM objects WHERE object_id = ?`
-  ).get(objectId);
+       FROM objects WHERE object_id = ?`).get(objectId);
   if (existing) return objectId;
   const { bytes: stored, compression } = compressBytes(bytes);
   const storagePath = objectStoragePath(hash, compression);
   const absolutePath = path2.join(bundle.path, storagePath);
   await ensureDir(path2.dirname(absolutePath));
   await writeFile2(absolutePath, stored);
-  prepare(
-    bundle.db,
-    `INSERT INTO objects (
+  prepare(bundle.db, `INSERT INTO objects (
        object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
        compression, mime_type, encoding, storage_path, created_at
-     ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    objectId,
-    hash,
-    bytes.byteLength,
-    compression === "zstd" ? stored.byteLength : null,
-    compression,
-    options.mimeType ?? null,
-    options.encoding ?? null,
-    storagePath,
-    (/* @__PURE__ */ new Date()).toISOString()
-  );
+     ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`).run(objectId, hash, bytes.byteLength, compression === "zstd" ? stored.byteLength : null, compression, options.mimeType ?? null, options.encoding ?? null, storagePath, (/* @__PURE__ */ new Date()).toISOString());
   return objectId;
 }
+__name(putBytes, "putBytes");
 async function putText(bundle, text, options = {}) {
   const buf = Buffer.from(text, "utf8");
   return putBytes(bundle, buf, {
@@ -919,6 +983,7 @@ async function putText(bundle, text, options = {}) {
     encoding: "utf-8"
   });
 }
+__name(putText, "putText");
 async function putJson(bundle, value) {
   const text = JSON.stringify(value);
   return putBytes(bundle, Buffer.from(text, "utf8"), {
@@ -926,38 +991,40 @@ async function putJson(bundle, value) {
     encoding: "utf-8"
   });
 }
+__name(putJson, "putJson");
 async function getBytes(bundle, objectId) {
-  const meta = prepare(
-    bundle.db,
-    `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
+  const meta = prepare(bundle.db, `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
             compression, mime_type, encoding, storage_path, created_at
-       FROM objects WHERE object_id = ?`
-  ).get(objectId);
+       FROM objects WHERE object_id = ?`).get(objectId);
   if (!meta) {
     throw new Error(`object not found: ${objectId}`);
   }
   const buf = await readFile2(path2.join(bundle.path, meta.storage_path));
   return decompressBytes(buf, meta.compression);
 }
+__name(getBytes, "getBytes");
 async function getText(bundle, objectId) {
   const buf = await getBytes(bundle, objectId);
   return buf.toString("utf8");
 }
+__name(getText, "getText");
 async function getJson(bundle, objectId) {
   const text = await getText(bundle, objectId);
   return JSON.parse(text);
 }
+__name(getJson, "getJson");
 function getObjectMeta(bundle, objectId) {
-  return prepare(
-    bundle.db,
-    `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
+  return prepare(bundle.db, `SELECT object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
               compression, mime_type, encoding, storage_path, created_at
-         FROM objects WHERE object_id = ?`
-  ).get(objectId) ?? null;
+         FROM objects WHERE object_id = ?`).get(objectId) ?? null;
 }
+__name(getObjectMeta, "getObjectMeta");
 function createPendingObjects() {
-  return { byId: /* @__PURE__ */ new Map() };
+  return {
+    byId: /* @__PURE__ */ new Map()
+  };
 }
+__name(createPendingObjects, "createPendingObjects");
 function stageBytes(pending, bytes, options = {}) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
   const hash = blake3Hex(buf);
@@ -973,21 +1040,26 @@ function stageBytes(pending, bytes, options = {}) {
   }
   return objectId;
 }
+__name(stageBytes, "stageBytes");
 function stageText(pending, text, options = {}) {
   return stageBytes(pending, Buffer.from(text, "utf8"), {
     mimeType: options.mimeType ?? "text/plain; charset=utf-8",
     encoding: "utf-8"
   });
 }
+__name(stageText, "stageText");
 function stageJson(pending, value) {
   return stageBytes(pending, Buffer.from(JSON.stringify(value), "utf8"), {
     mimeType: "application/json",
     encoding: "utf-8"
   });
 }
+__name(stageJson, "stageJson");
 async function flushPendingObjects(bundle, pending) {
   if (pending.byId.size === 0) return;
-  const ids = [...pending.byId.keys()];
+  const ids = [
+    ...pending.byId.keys()
+  ];
   const existingIds = queryExistingObjectIds(bundle, ids);
   const toWrite = [];
   for (const obj of pending.byId.values()) {
@@ -1005,28 +1077,16 @@ async function flushPendingObjects(bundle, pending) {
   if (toWrite.length > 0) {
     await writeFilesParallel(toWrite);
   }
-  const insertObject = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO objects (
+  const insertObject = prepare(bundle.db, `INSERT OR IGNORE INTO objects (
        object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
        compression, mime_type, encoding, storage_path, created_at
-     ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const p of toWrite) {
-    insertObject.run(
-      p.staged.objectId,
-      p.staged.hash,
-      p.staged.bytes.byteLength,
-      p.compression === "zstd" ? p.compressedBytes.byteLength : null,
-      p.compression,
-      p.staged.mimeType,
-      p.staged.encoding,
-      p.storagePath,
-      now
-    );
+    insertObject.run(p.staged.objectId, p.staged.hash, p.staged.bytes.byteLength, p.compression === "zstd" ? p.compressedBytes.byteLength : null, p.compression, p.staged.mimeType, p.staged.encoding, p.storagePath, now);
   }
 }
+__name(flushPendingObjects, "flushPendingObjects");
 function queryExistingObjectIds(bundle, ids) {
   const found = /* @__PURE__ */ new Set();
   if (ids.length === 0) return found;
@@ -1034,75 +1094,141 @@ function queryExistingObjectIds(bundle, ids) {
   for (let start = 0; start < ids.length; start += CHUNK) {
     const slice = ids.slice(start, start + CHUNK);
     const placeholders = slice.map(() => "?").join(",");
-    const rows = bundle.db.prepare(
-      `SELECT object_id FROM objects WHERE object_id IN (${placeholders})`
-    ).all(...slice);
+    const rows = bundle.db.prepare(`SELECT object_id FROM objects WHERE object_id IN (${placeholders})`).all(...slice);
     for (const row of rows) found.add(row.object_id);
   }
   return found;
 }
+__name(queryExistingObjectIds, "queryExistingObjectIds");
 var FS_WRITE_CONCURRENCY = 16;
 async function writeFilesParallel(tasks) {
   let cursor = 0;
   const workers = [];
   const limit2 = Math.min(FS_WRITE_CONCURRENCY, tasks.length);
   for (let w = 0; w < limit2; w++) {
-    workers.push(
-      (async () => {
-        while (true) {
-          const i = cursor++;
-          if (i >= tasks.length) return;
-          const task = tasks[i];
-          await ensureDir(path2.dirname(task.absolutePath));
-          await writeFile2(task.absolutePath, task.compressedBytes);
-        }
-      })()
-    );
+    workers.push((async () => {
+      while (true) {
+        const i = cursor++;
+        if (i >= tasks.length) return;
+        const task = tasks[i];
+        await ensureDir(path2.dirname(task.absolutePath));
+        await writeFile2(task.absolutePath, task.compressedBytes);
+      }
+    })());
   }
   await Promise.all(workers);
 }
+__name(writeFilesParallel, "writeFilesParallel");
 
 // src/core/domain/ids.ts
 var ID_PREFIX_BYTES = 16;
 function tupleId(parts) {
   return sha256Hex(parts.join("\0")).slice(0, ID_PREFIX_BYTES * 2);
 }
+__name(tupleId, "tupleId");
 function sourceFileId(sourceTool, absolutePath, contentHash) {
-  return tupleId(["source_file", sourceTool, absolutePath, contentHash]);
+  return tupleId([
+    "source_file",
+    sourceTool,
+    absolutePath,
+    contentHash
+  ]);
 }
+__name(sourceFileId, "sourceFileId");
 function rawRecordId(sourceFileId2, ordinal, rawObjectId) {
-  return tupleId(["raw_record", sourceFileId2, String(ordinal ?? -1), rawObjectId]);
+  return tupleId([
+    "raw_record",
+    sourceFileId2,
+    String(ordinal ?? -1),
+    rawObjectId
+  ]);
 }
+__name(rawRecordId, "rawRecordId");
 function sessionId(sourceTool, sourceSessionId) {
-  return tupleId(["session", sourceTool, sourceSessionId]);
+  return tupleId([
+    "session",
+    sourceTool,
+    sourceSessionId
+  ]);
 }
+__name(sessionId, "sessionId");
 function turnId(sessionId2, ordinal, sourceTurnId) {
-  return tupleId(["turn", sessionId2, String(ordinal), sourceTurnId ?? ""]);
+  return tupleId([
+    "turn",
+    sessionId2,
+    String(ordinal),
+    sourceTurnId ?? ""
+  ]);
 }
+__name(turnId, "turnId");
 function eventId(sessionId2, ordinal, kind) {
-  return tupleId(["event", sessionId2, String(ordinal), kind]);
+  return tupleId([
+    "event",
+    sessionId2,
+    String(ordinal),
+    kind
+  ]);
 }
+__name(eventId, "eventId");
 function messageId(sessionId2, ordinal, sourceMsgId) {
-  return tupleId(["message", sessionId2, String(ordinal), sourceMsgId ?? ""]);
+  return tupleId([
+    "message",
+    sessionId2,
+    String(ordinal),
+    sourceMsgId ?? ""
+  ]);
 }
+__name(messageId, "messageId");
 function blockId(messageOrEventId, ordinal) {
-  return tupleId(["block", messageOrEventId, String(ordinal)]);
+  return tupleId([
+    "block",
+    messageOrEventId,
+    String(ordinal)
+  ]);
 }
+__name(blockId, "blockId");
 function toolCallId(sessionId2, sourceCallId) {
-  return tupleId(["tool_call", sessionId2, sourceCallId]);
+  return tupleId([
+    "tool_call",
+    sessionId2,
+    sourceCallId
+  ]);
 }
+__name(toolCallId, "toolCallId");
 function toolResultId(sessionId2, sourceCallId) {
-  return tupleId(["tool_result", sessionId2, sourceCallId]);
+  return tupleId([
+    "tool_result",
+    sessionId2,
+    sourceCallId
+  ]);
 }
+__name(toolResultId, "toolResultId");
 function artifactId(sessionId2, sourceTool, key) {
-  return tupleId(["artifact", sessionId2 ?? "", sourceTool, key]);
+  return tupleId([
+    "artifact",
+    sessionId2 ?? "",
+    sourceTool,
+    key
+  ]);
 }
+__name(artifactId, "artifactId");
 function projectId(sourceTool, sourceProjectId) {
-  return tupleId(["project", sourceTool, sourceProjectId]);
+  return tupleId([
+    "project",
+    sourceTool,
+    sourceProjectId
+  ]);
 }
+__name(projectId, "projectId");
 function importBatchId(sourceTool, startedAtIso) {
-  return tupleId(["import_batch", sourceTool, startedAtIso, String(Math.random())]);
+  return tupleId([
+    "import_batch",
+    sourceTool,
+    startedAtIso,
+    String(Math.random())
+  ]);
 }
+__name(importBatchId, "importBatchId");
 
 // src/core/ingest/batch.ts
 function emptyCounts() {
@@ -1123,15 +1249,13 @@ function emptyCounts() {
     errors: 0
   };
 }
+__name(emptyCounts, "emptyCounts");
 function startBatch(bundle, sourceTool, paths) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const id = importBatchId(sourceTool ?? "all", startedAt);
-  prepare(
-    bundle.db,
-    `INSERT INTO import_batches (
+  prepare(bundle.db, `INSERT INTO import_batches (
        batch_id, parser_version, source_tool, paths, started_at, status
-     ) VALUES (?, ?, ?, ?, ?, 'running')`
-  ).run(id, PROSA_PARSER_VERSION, sourceTool, JSON.stringify(paths), startedAt);
+     ) VALUES (?, ?, ?, ?, ?, 'running')`).run(id, PROSA_PARSER_VERSION, sourceTool, JSON.stringify(paths), startedAt);
   return {
     batch_id: id,
     source_tool: sourceTool,
@@ -1140,35 +1264,24 @@ function startBatch(bundle, sourceTool, paths) {
     started_at: startedAt
   };
 }
+__name(startBatch, "startBatch");
 function finishBatch(bundle, batch, counts, status) {
-  prepare(
-    bundle.db,
-    `UPDATE import_batches
+  prepare(bundle.db, `UPDATE import_batches
         SET finished_at = ?, status = ?, counts_json = ?
-      WHERE batch_id = ?`
-  ).run((/* @__PURE__ */ new Date()).toISOString(), status, JSON.stringify(counts), batch.batch_id);
+      WHERE batch_id = ?`).run((/* @__PURE__ */ new Date()).toISOString(), status, JSON.stringify(counts), batch.batch_id);
 }
+__name(finishBatch, "finishBatch");
 async function recordError(bundle, batchId, args) {
   let payloadObjectId = null;
   if (args.payload !== void 0) {
     payloadObjectId = await putJson(bundle, args.payload);
   }
-  prepare(
-    bundle.db,
-    `INSERT INTO import_errors (
+  prepare(bundle.db, `INSERT INTO import_errors (
        batch_id, source_file_id, raw_record_id, kind, message,
        payload_object_id, occurred_at
-     ) VALUES (?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    batchId,
-    args.sourceFileId ?? null,
-    args.rawRecordId ?? null,
-    args.kind,
-    args.message,
-    payloadObjectId,
-    (/* @__PURE__ */ new Date()).toISOString()
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(batchId, args.sourceFileId ?? null, args.rawRecordId ?? null, args.kind, args.message, payloadObjectId, (/* @__PURE__ */ new Date()).toISOString());
 }
+__name(recordError, "recordError");
 
 // src/core/ingest/idempotency.ts
 import { access as access2, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "fs/promises";
@@ -1177,14 +1290,11 @@ async function registerSourceFile(bundle, args) {
   const st = await stat2(args.absolutePath);
   const size = st.size;
   const mtime = st.mtime.toISOString();
-  const cheap = prepare(
-    bundle.db,
-    `SELECT source_file_id, source_tool, path, file_kind, size_bytes, mtime,
+  const cheap = prepare(bundle.db, `SELECT source_file_id, source_tool, path, file_kind, size_bytes, mtime,
             content_hash, object_id, discovered_at, workspace_hint
        FROM source_files
       WHERE source_tool = ? AND path = ? AND size_bytes = ? AND mtime = ?
-      LIMIT 1`
-  ).get(args.sourceTool, args.absolutePath, size, mtime);
+      LIMIT 1`).get(args.sourceTool, args.absolutePath, size, mtime);
   if (cheap) {
     return {
       row: await ensureSourceFilePreserved(bundle, cheap, args.absolutePath),
@@ -1193,14 +1303,11 @@ async function registerSourceFile(bundle, args) {
   }
   const buf = await readFile3(args.absolutePath);
   const contentHash = sha256Hex(buf);
-  const exact = prepare(
-    bundle.db,
-    `SELECT source_file_id, source_tool, path, file_kind, size_bytes, mtime,
+  const exact = prepare(bundle.db, `SELECT source_file_id, source_tool, path, file_kind, size_bytes, mtime,
             content_hash, object_id, discovered_at, workspace_hint
        FROM source_files
       WHERE source_tool = ? AND path = ? AND content_hash = ?
-      LIMIT 1`
-  ).get(args.sourceTool, args.absolutePath, contentHash);
+      LIMIT 1`).get(args.sourceTool, args.absolutePath, contentHash);
   if (exact) {
     return {
       row: await ensureSourceFilePreserved(bundle, exact, args.absolutePath, buf),
@@ -1221,36 +1328,27 @@ async function registerSourceFile(bundle, args) {
     discovered_at: (/* @__PURE__ */ new Date()).toISOString(),
     workspace_hint: args.workspaceHint ?? null
   };
-  prepare(
-    bundle.db,
-    `INSERT INTO source_files (
+  prepare(bundle.db, `INSERT INTO source_files (
        source_file_id, source_tool, path, file_kind, size_bytes, mtime,
        content_hash, object_id, discovered_at, workspace_hint
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    row.source_file_id,
-    row.source_tool,
-    row.path,
-    row.file_kind,
-    row.size_bytes,
-    row.mtime,
-    row.content_hash,
-    row.object_id,
-    row.discovered_at,
-    row.workspace_hint
-  );
-  return { row, alreadyKnown: false };
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.source_file_id, row.source_tool, row.path, row.file_kind, row.size_bytes, row.mtime, row.content_hash, row.object_id, row.discovered_at, row.workspace_hint);
+  return {
+    row,
+    alreadyKnown: false
+  };
 }
+__name(registerSourceFile, "registerSourceFile");
 async function ensureSourceFilePreserved(bundle, row, absolutePath, bytes) {
   if (row.object_id) return row;
   const sourceBytes = bytes ?? await readFile3(absolutePath);
   const objectId = await preserveRawSourceBytes(bundle, sourceBytes);
-  prepare(
-    bundle.db,
-    `UPDATE source_files SET object_id = ? WHERE source_file_id = ?`
-  ).run(objectId, row.source_file_id);
-  return { ...row, object_id: objectId };
+  prepare(bundle.db, `UPDATE source_files SET object_id = ? WHERE source_file_id = ?`).run(objectId, row.source_file_id);
+  return {
+    ...row,
+    object_id: objectId
+  };
 }
+__name(ensureSourceFilePreserved, "ensureSourceFilePreserved");
 async function preserveRawSourceBytes(bundle, bytes) {
   const hash = blake3Hex(bytes);
   const objectId = objectIdFromHash(hash);
@@ -1261,35 +1359,21 @@ async function preserveRawSourceBytes(bundle, bytes) {
   if (!await fileExists(absolutePath)) {
     await writeFile3(absolutePath, stored);
   }
-  const existing = prepare(
-    bundle.db,
-    `SELECT object_id FROM objects WHERE object_id = ?`
-  ).get(objectId);
+  const existing = prepare(bundle.db, `SELECT object_id FROM objects WHERE object_id = ?`).get(objectId);
   if (!existing) {
-    prepare(
-      bundle.db,
-      `INSERT INTO objects (
+    prepare(bundle.db, `INSERT INTO objects (
          object_id, hash_alg, hash, size_bytes, compressed_size_bytes,
          compression, mime_type, encoding, storage_path, created_at
-       ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      objectId,
-      hash,
-      bytes.byteLength,
-      compression === "zstd" ? stored.byteLength : null,
-      compression,
-      "application/octet-stream",
-      null,
-      storagePath,
-      (/* @__PURE__ */ new Date()).toISOString()
-    );
+       ) VALUES (?, 'blake3', ?, ?, ?, ?, ?, ?, ?, ?)`).run(objectId, hash, bytes.byteLength, compression === "zstd" ? stored.byteLength : null, compression, "application/octet-stream", null, storagePath, (/* @__PURE__ */ new Date()).toISOString());
   }
   return objectId;
 }
+__name(preserveRawSourceBytes, "preserveRawSourceBytes");
 function rawSourceStoragePath(hashHex, compression) {
   const ext = compression === "zstd" ? ".zst" : ".bin";
   return `raw/sources/${hashHex}${ext}`;
 }
+__name(rawSourceStoragePath, "rawSourceStoragePath");
 async function fileExists(filePath) {
   try {
     await access2(filePath);
@@ -1298,11 +1382,13 @@ async function fileExists(filePath) {
     return false;
   }
 }
+__name(fileExists, "fileExists");
 
 // src/core/limits.ts
 function clampLimit(value, opts) {
   return Math.max(opts.min ?? 1, Math.min(opts.max, value ?? opts.fallback));
 }
+__name(clampLimit, "clampLimit");
 
 // src/services/sessions.ts
 function sessionFilterWhere(filters) {
@@ -1325,9 +1411,13 @@ function sessionFilterWhere(filters) {
     params
   };
 }
+__name(sessionFilterWhere, "sessionFilterWhere");
 function listSessions(bundle, filters = {}) {
   const { where, params } = sessionFilterWhere(filters);
-  const limit2 = clampLimit(filters.limit, { max: 1e3, fallback: 50 });
+  const limit2 = clampLimit(filters.limit, {
+    max: 1e3,
+    fallback: 50
+  });
   const sql = `
     SELECT s.session_id,
            s.source_tool,
@@ -1352,33 +1442,30 @@ function listSessions(bundle, filters = {}) {
   `;
   return bundle.db.prepare(sql).all(...params);
 }
+__name(listSessions, "listSessions");
 function countSessions(bundle, filters = {}) {
   const { where, params } = sessionFilterWhere(filters);
-  const row = bundle.db.prepare(
-    `
+  const row = bundle.db.prepare(`
         SELECT count(*) AS count
           FROM sessions s
           ${where}
-      `
-  ).get(...params);
+      `).get(...params);
   return row?.count ?? 0;
 }
+__name(countSessions, "countSessions");
 function getSession(bundle, sessionId2) {
   const rows = listSessions(bundle);
-  const row = bundle.db.prepare(
-    `SELECT s.session_id, s.source_tool, s.source_session_id, s.parent_session_id,
+  const row = bundle.db.prepare(`SELECT s.session_id, s.source_tool, s.source_session_id, s.parent_session_id,
               s.is_subagent, s.title, s.start_ts, s.end_ts, s.cwd_initial,
               s.git_branch_initial, s.model_first, s.model_last, s.status,
               s.timeline_confidence,
               (SELECT count(*) FROM messages m WHERE m.session_id = s.session_id) AS message_count,
               (SELECT count(*) FROM tool_calls tc WHERE tc.session_id = s.session_id) AS tool_call_count
          FROM sessions s
-        WHERE s.session_id = ?`
-  ).get(sessionId2);
+        WHERE s.session_id = ?`).get(sessionId2);
   void rows;
   if (!row) return null;
-  const events = bundle.db.prepare(
-    `SELECT e.ordinal,
+  const events = bundle.db.prepare(`SELECT e.ordinal,
               e.timestamp,
               e.event_type,
               e.source_type,
@@ -1394,17 +1481,20 @@ function getSession(bundle, sessionId2) {
          LEFT JOIN tool_calls tc ON tc.event_id = e.event_id
          LEFT JOIN tool_results tr ON tr.event_id = e.event_id
         WHERE e.session_id = ?
-        ORDER BY e.ordinal`
-  ).all(sessionId2);
-  return { session: row, events };
+        ORDER BY e.ordinal`).all(sessionId2);
+  return {
+    session: row,
+    events
+  };
 }
+__name(getSession, "getSession");
 
 // src/services/search.ts
 import { existsSync as existsSync2 } from "fs";
 import { createRequire } from "module";
 
 // src/core/errors.ts
-var getErrorMessage = (err) => err instanceof Error ? err.message : String(err);
+var getErrorMessage = /* @__PURE__ */ __name((err) => err instanceof Error ? err.message : String(err), "getErrorMessage");
 
 // src/services/indexing.ts
 import { createHash as createHash2 } from "crypto";
@@ -1436,6 +1526,7 @@ END;
 function enableFts5Triggers(bundle) {
   bundle.db.exec(FTS5_TRIGGER_SQL);
 }
+__name(enableFts5Triggers, "enableFts5Triggers");
 function disableFts5Triggers(bundle) {
   bundle.db.exec(`
     DROP TRIGGER IF EXISTS search_docs_ai;
@@ -1443,22 +1534,21 @@ function disableFts5Triggers(bundle) {
     DROP TRIGGER IF EXISTS search_docs_au;
   `);
 }
+__name(disableFts5Triggers, "disableFts5Triggers");
 function getSearchIndexStatuses(bundle) {
   ensureSearchIndexStatusRows(bundle);
-  return bundle.db.prepare(
-    `SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
+  return bundle.db.prepare(`SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
          FROM search_index_status
-        ORDER BY engine`
-  ).all();
+        ORDER BY engine`).all();
 }
+__name(getSearchIndexStatuses, "getSearchIndexStatuses");
 function getSearchIndexStatus(bundle, engine) {
   ensureSearchIndexStatusRows(bundle);
-  return bundle.db.prepare(
-    `SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
+  return bundle.db.prepare(`SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
            FROM search_index_status
-          WHERE engine = ?`
-  ).get(engine) ?? null;
+          WHERE engine = ?`).get(engine) ?? null;
 }
+__name(getSearchIndexStatus, "getSearchIndexStatus");
 function markIndexesAfterImport(bundle, options) {
   if (!options.changed) return;
   const tantivy = getSearchIndexStatus(bundle, "tantivy");
@@ -1471,6 +1561,7 @@ function markIndexesAfterImport(bundle, options) {
     });
   }
 }
+__name(markIndexesAfterImport, "markIndexesAfterImport");
 function rebuildFts5Index(bundle) {
   ensureSearchIndexStatusRows(bundle);
   updateSearchIndexStatus(bundle, "fts5", {
@@ -1501,38 +1592,80 @@ function rebuildFts5Index(bundle) {
   }
   return getSearchIndexStatus(bundle, "fts5");
 }
+__name(rebuildFts5Index, "rebuildFts5Index");
 var TANTIVY_SCHEMA_FIELDS = [
-  { name: "doc_id", tokenizer: "raw" },
-  { name: "entity_type", tokenizer: "raw" },
-  { name: "entity_id", tokenizer: "raw" },
-  { name: "session_id", tokenizer: "raw" },
-  { name: "project_id", tokenizer: "raw" },
-  { name: "timestamp", tokenizer: "raw" },
-  { name: "role", tokenizer: "raw" },
-  { name: "tool_name", tokenizer: "raw" },
-  { name: "canonical_tool_type", tokenizer: "raw" },
-  { name: "field_kind", tokenizer: "raw" },
+  {
+    name: "doc_id",
+    tokenizer: "raw"
+  },
+  {
+    name: "entity_type",
+    tokenizer: "raw"
+  },
+  {
+    name: "entity_id",
+    tokenizer: "raw"
+  },
+  {
+    name: "session_id",
+    tokenizer: "raw"
+  },
+  {
+    name: "project_id",
+    tokenizer: "raw"
+  },
+  {
+    name: "timestamp",
+    tokenizer: "raw"
+  },
+  {
+    name: "role",
+    tokenizer: "raw"
+  },
+  {
+    name: "tool_name",
+    tokenizer: "raw"
+  },
+  {
+    name: "canonical_tool_type",
+    tokenizer: "raw"
+  },
+  {
+    name: "field_kind",
+    tokenizer: "raw"
+  },
   // The text field uses tantivy's default tokenizer (en_stem in the binding).
-  { name: "text", tokenizer: "default" }
+  {
+    name: "text",
+    tokenizer: "default"
+  }
 ];
 function buildTantivySchema(tantivy) {
   const builder = new tantivy.SchemaBuilder();
   for (const field of TANTIVY_SCHEMA_FIELDS) {
     if (field.tokenizer === "default") {
-      builder.addTextField(field.name, { stored: true });
+      builder.addTextField(field.name, {
+        stored: true
+      });
     } else {
-      builder.addTextField(field.name, { stored: true, tokenizerName: field.tokenizer });
+      builder.addTextField(field.name, {
+        stored: true,
+        tokenizerName: field.tokenizer
+      });
     }
   }
   return builder.build();
 }
-function computeSchemaFingerprint() {
+__name(buildTantivySchema, "buildTantivySchema");
+function getCurrentTantivySchemaFingerprint() {
   const canonical = TANTIVY_SCHEMA_FIELDS.map((f) => `${f.name}:${f.tokenizer}:stored`).join("|");
   return createHash2("sha256").update(canonical).digest("hex");
 }
-function tantivyIndexLooksValid(dir) {
+__name(getCurrentTantivySchemaFingerprint, "getCurrentTantivySchemaFingerprint");
+function tantivyIndexDirIsValid(dir) {
   return existsSync(path4.join(dir, "meta.json"));
 }
+__name(tantivyIndexDirIsValid, "tantivyIndexDirIsValid");
 function makeTantivyDoc(tantivy, row) {
   const doc = new tantivy.Document();
   doc.addText("doc_id", row.doc_id);
@@ -1548,6 +1681,7 @@ function makeTantivyDoc(tantivy, row) {
   doc.addText("text", row.text);
   return doc;
 }
+__name(makeTantivyDoc, "makeTantivyDoc");
 var SEARCH_DOCS_SELECT = `
   SELECT rowid, doc_id, entity_type, entity_id, session_id, project_id, timestamp,
          role, tool_name, canonical_tool_type, field_kind, text
@@ -1557,8 +1691,8 @@ async function rebuildTantivyIndex(bundle, options = {}) {
   ensureSearchIndexStatusRows(bundle);
   const sourceDocCount = countSearchDocs(bundle);
   const prev = getSearchIndexStatus(bundle, "tantivy");
-  const fingerprint = computeSchemaFingerprint();
-  const indexDirValid = tantivyIndexLooksValid(bundle.paths.tantivy);
+  const fingerprint = getCurrentTantivySchemaFingerprint();
+  const indexDirValid = tantivyIndexDirIsValid(bundle.paths.tantivy);
   const fingerprintMatches = prev?.schema_fingerprint === fingerprint;
   const lastIndexedRowid = typeof prev?.last_indexed_rowid === "number" ? prev.last_indexed_rowid : 0;
   const wantFullRebuild = options.overwrite === true || !indexDirValid || !fingerprintMatches || lastIndexedRowid <= 0;
@@ -1573,8 +1707,13 @@ async function rebuildTantivyIndex(bundle, options = {}) {
     const schema = buildTantivySchema(tantivy);
     let index;
     if (wantFullRebuild) {
-      await rm(bundle.paths.tantivy, { recursive: true, force: true });
-      await mkdir3(bundle.paths.tantivy, { recursive: true });
+      await rm(bundle.paths.tantivy, {
+        recursive: true,
+        force: true
+      });
+      await mkdir3(bundle.paths.tantivy, {
+        recursive: true
+      });
       index = new tantivy.Index(schema, bundle.paths.tantivy, false);
     } else {
       index = tantivy.Index.open(bundle.paths.tantivy);
@@ -1595,25 +1734,17 @@ async function rebuildTantivyIndex(bundle, options = {}) {
     index.reload();
     writer.waitMergingThreads();
     const indexedDocCount = wantFullRebuild ? addedDocCount : countTantivyDocsBest(prev, addedDocCount);
-    await writeFile4(
-      path4.join(bundle.paths.tantivy, "prosa-index.json"),
-      `${JSON.stringify(
-        {
-          engine: "tantivy",
-          source: "search_docs",
-          built_at: (/* @__PURE__ */ new Date()).toISOString(),
-          mode: wantFullRebuild ? "full" : "incremental",
-          source_doc_count: sourceDocCount,
-          indexed_doc_count: indexedDocCount,
-          last_indexed_rowid: maxRowid,
-          schema_fingerprint: fingerprint
-        },
-        null,
-        2
-      )}
-`,
-      "utf8"
-    );
+    await writeFile4(path4.join(bundle.paths.tantivy, "prosa-index.json"), `${JSON.stringify({
+      engine: "tantivy",
+      source: "search_docs",
+      built_at: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: wantFullRebuild ? "full" : "incremental",
+      source_doc_count: sourceDocCount,
+      indexed_doc_count: indexedDocCount,
+      last_indexed_rowid: maxRowid,
+      schema_fingerprint: fingerprint
+    }, null, 2)}
+`, "utf8");
     updateSearchIndexStatus(bundle, "tantivy", {
       status: "ready",
       sourceDocCount,
@@ -1633,24 +1764,24 @@ async function rebuildTantivyIndex(bundle, options = {}) {
   }
   return getSearchIndexStatus(bundle, "tantivy");
 }
+__name(rebuildTantivyIndex, "rebuildTantivyIndex");
 function countTantivyDocsBest(prev, added) {
   if (prev && typeof prev.indexed_doc_count === "number") {
     return prev.indexed_doc_count + added;
   }
   return added;
 }
+__name(countTantivyDocsBest, "countTantivyDocsBest");
 function ensureSearchIndexStatusRows(bundle) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const stmt = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO search_index_status (
+  const stmt = prepare(bundle.db, `INSERT OR IGNORE INTO search_index_status (
        engine, status, source_doc_count, indexed_doc_count, updated_at,
        error_message, last_indexed_rowid, schema_fingerprint
-     ) VALUES (?, ?, 0, 0, ?, NULL, NULL, NULL)`
-  );
+     ) VALUES (?, ?, 0, 0, ?, NULL, NULL, NULL)`);
   stmt.run("fts5", "ready", now);
   stmt.run("tantivy", "missing", now);
 }
+__name(ensureSearchIndexStatusRows, "ensureSearchIndexStatusRows");
 function updateSearchIndexStatus(bundle, engine, values) {
   ensureSearchIndexStatusRows(bundle);
   const setClauses = [
@@ -1676,28 +1807,32 @@ function updateSearchIndexStatus(bundle, engine, values) {
     params.push(values.schemaFingerprint);
   }
   params.push(engine);
-  prepare(
-    bundle.db,
-    `UPDATE search_index_status SET ${setClauses.join(", ")} WHERE engine = ?`
-  ).run(...params);
+  prepare(bundle.db, `UPDATE search_index_status SET ${setClauses.join(", ")} WHERE engine = ?`).run(...params);
 }
+__name(updateSearchIndexStatus, "updateSearchIndexStatus");
 function countSearchDocs(bundle) {
   return bundle.db.prepare(`SELECT count(*) AS n FROM search_docs`).get()?.n ?? 0;
 }
+__name(countSearchDocs, "countSearchDocs");
 function countFts5Docs(bundle) {
   return bundle.db.prepare(`SELECT count(*) AS n FROM search_docs_fts`).get()?.n ?? 0;
 }
+__name(countFts5Docs, "countFts5Docs");
 
 // src/services/search.ts
 var require2 = createRequire(import.meta.url);
 function escapeFtsQuery(q) {
   return q.split(/\s+/).filter((t) => t.length > 0).map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
 }
+__name(escapeFtsQuery, "escapeFtsQuery");
 function searchFullText(bundle, options) {
   if (options.engine === "tantivy") {
     return searchTantivy(bundle, options);
   }
-  const limit2 = clampLimit(options.limit, { max: 500, fallback: 50 });
+  const limit2 = clampLimit(options.limit, {
+    max: 500,
+    fallback: 50
+  });
   const sql = `
     SELECT d.doc_id,
            d.entity_type,
@@ -1718,24 +1853,36 @@ function searchFullText(bundle, options) {
   if (!ftsQuery) return [];
   return bundle.db.prepare(sql).all(ftsQuery);
 }
+__name(searchFullText, "searchFullText");
 function searchTantivy(bundle, options) {
   if (!existsSync2(bundle.paths.tantivy)) {
     throw new Error("tantivy index not found; run `prosa index tantivy` first");
   }
   const status = getSearchIndexStatus(bundle, "tantivy");
   if (status?.status !== "ready") {
-    throw new Error(
-      `tantivy index is ${status?.status ?? "missing"}; run \`prosa index tantivy\` first`
-    );
+    throw new Error(`tantivy index is ${status?.status ?? "missing"}; run \`prosa index tantivy\` first`);
   }
-  const limit2 = clampLimit(options.limit, { max: 500, fallback: 50 });
+  const limit2 = clampLimit(options.limit, {
+    max: 500,
+    fallback: 50
+  });
   const queryText = options.query.trim();
   if (!queryText) return [];
   const tantivy = requireTantivy();
   const index = tantivy.Index.open(bundle.paths.tantivy);
   const searcher = index.searcher();
-  const [query] = options.raw ? [index.parseQuery(queryText, ["text"])] : index.parseQueryLenient(queryText, ["text"], void 0, {
-    text: [true, 2, true]
+  const [query] = options.raw ? [
+    index.parseQuery(queryText, [
+      "text"
+    ])
+  ] : index.parseQueryLenient(queryText, [
+    "text"
+  ], void 0, {
+    text: [
+      true,
+      2,
+      true
+    ]
   });
   const result = searcher.search(query, limit2, true);
   const snippets = tantivy.SnippetGenerator.create(searcher, query, index.schema, "text");
@@ -1758,6 +1905,7 @@ function searchTantivy(bundle, options) {
     };
   });
 }
+__name(searchTantivy, "searchTantivy");
 function requireTantivy() {
   try {
     return require2("@oxdev03/node-tantivy-binding");
@@ -1765,6 +1913,7 @@ function requireTantivy() {
     throw new Error(`tantivy engine is unavailable: ${getErrorMessage(error)}`);
   }
 }
+__name(requireTantivy, "requireTantivy");
 function getStoredText(doc, field) {
   const value = doc.getFirst(field);
   if (typeof value === "string") return value;
@@ -1772,9 +1921,11 @@ function getStoredText(doc, field) {
   if (value == null) return "";
   return String(value);
 }
+__name(getStoredText, "getStoredText");
 function nullIfEmpty(value) {
   return value.length > 0 ? value : null;
 }
+__name(nullIfEmpty, "nullIfEmpty");
 function highlightSnippet(fragment, ranges) {
   if (ranges.length === 0) return fragment;
   let out = "";
@@ -1787,6 +1938,7 @@ function highlightSnippet(fragment, ranges) {
   out += fragment.slice(cursor);
   return out;
 }
+__name(highlightSnippet, "highlightSnippet");
 
 // src/services/compile.ts
 import os2 from "os";
@@ -1807,6 +1959,7 @@ async function* discoverClaudeFiles(root) {
     yield* walkProject(projectRoot, project.name);
   }
 }
+__name(discoverClaudeFiles, "discoverClaudeFiles");
 async function* walkProject(projectRoot, projectSlug) {
   const entries = await readdirSafe(projectRoot);
   for (const entry of entries) {
@@ -1829,9 +1982,7 @@ async function* walkProject(projectRoot, projectSlug) {
         if (!sub.name.startsWith("agent-")) continue;
         const agentId = sub.name.slice("agent-".length, -".jsonl".length);
         const metaCandidate = path5.join(subagentsDir, `agent-${agentId}.meta.json`);
-        const metaExists = subagentEntries.some(
-          (e) => e.isFile() && e.name === `agent-${agentId}.meta.json`
-        );
+        const metaExists = subagentEntries.some((e) => e.isFile() && e.name === `agent-${agentId}.meta.json`);
         yield {
           filePath: path5.join(subagentsDir, sub.name),
           projectSlug,
@@ -1844,62 +1995,80 @@ async function* walkProject(projectRoot, projectSlug) {
     }
   }
 }
+__name(walkProject, "walkProject");
 async function readdirSafe(dir) {
   try {
-    return await readdir(dir, { withFileTypes: true });
+    return await readdir(dir, {
+      withFileTypes: true
+    });
   } catch {
     return [];
   }
 }
+__name(readdirSafe, "readdirSafe");
 
 // src/importers/claude/index.ts
 var PREVIEW_MAX = 4e3;
 async function compileClaude(bundle, root, options = {}) {
   const logger = options.logger;
-  const batch = startBatch(bundle, "claude", [root]);
+  const batch = startBatch(bundle, "claude", [
+    root
+  ]);
   const counts = emptyCounts();
-  logger?.info({ batch_id: batch.batch_id, root }, "claude batch started");
+  logger?.info({
+    batch_id: batch.batch_id,
+    root
+  }, "claude batch started");
   try {
     for await (const file of discoverClaudeFiles(root)) {
       counts.source_files_seen++;
-      logger?.debug(
-        {
-          path: file.filePath,
-          project_slug: file.projectSlug,
-          is_subagent: file.isSubagent
-        },
-        "claude source file discovered"
-      );
+      logger?.debug({
+        path: file.filePath,
+        project_slug: file.projectSlug,
+        is_subagent: file.isSubagent
+      }, "claude source file discovered");
       try {
         const fc = await compileClaudeFile(bundle, batch, file, logger);
         addCounts(counts, fc);
       } catch (error) {
         counts.errors++;
-        logger?.warn(
-          {
-            err: error,
-            path: file.filePath
-          },
-          "claude source file failed"
-        );
+        logger?.warn({
+          err: error,
+          path: file.filePath
+        }, "claude source file failed");
         await recordError(bundle, batch.batch_id, {
           kind: "claude_file_failed",
           message: getErrorMessage(error),
-          payload: { path: file.filePath }
+          payload: {
+            path: file.filePath
+          }
         });
       }
     }
     linkSubagentParents(bundle);
-    logger?.debug({ batch_id: batch.batch_id }, "claude subagent parent links refreshed");
+    logger?.debug({
+      batch_id: batch.batch_id
+    }, "claude subagent parent links refreshed");
     finishBatch(bundle, batch, counts, "completed");
-    logger?.info({ batch_id: batch.batch_id, counts }, "claude batch completed");
+    logger?.info({
+      batch_id: batch.batch_id,
+      counts
+    }, "claude batch completed");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
-    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "claude batch failed");
+    logger?.error({
+      err: error,
+      batch_id: batch.batch_id,
+      counts
+    }, "claude batch failed");
     throw error;
   }
-  return { batch, counts };
+  return {
+    batch,
+    counts
+  };
 }
+__name(compileClaude, "compileClaude");
 function linkSubagentParents(bundle) {
   bundle.db.exec(`
     UPDATE sessions
@@ -1917,6 +2086,7 @@ function linkSubagentParents(bundle) {
        AND source_tool = 'claude'
   `);
 }
+__name(linkSubagentParents, "linkSubagentParents");
 function emptyFileCounts() {
   return {
     source_files_imported: 0,
@@ -1934,6 +2104,7 @@ function emptyFileCounts() {
     errors: 0
   };
 }
+__name(emptyFileCounts, "emptyFileCounts");
 function addCounts(target, source) {
   target.source_files_imported += source.source_files_imported;
   target.source_files_skipped += source.source_files_skipped;
@@ -1949,6 +2120,7 @@ function addCounts(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
+__name(addCounts, "addCounts");
 async function compileClaudeFile(bundle, batch, file, logger) {
   const counts = emptyFileCounts();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
@@ -1959,17 +2131,17 @@ async function compileClaudeFile(bundle, batch, file, logger) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
-    logger?.debug(
-      { path: file.filePath, source_file_id: sourceFile.source_file_id },
-      "claude source file skipped"
-    );
+    logger?.debug({
+      path: file.filePath,
+      source_file_id: sourceFile.source_file_id
+    }, "claude source file skipped");
     return counts;
   }
   counts.source_files_imported = 1;
-  logger?.debug(
-    { path: file.filePath, source_file_id: sourceFile.source_file_id },
-    "claude source file registered"
-  );
+  logger?.debug({
+    path: file.filePath,
+    source_file_id: sourceFile.source_file_id
+  }, "claude source file registered");
   const text = await readFile4(file.filePath, "utf8");
   const rawLines = text.split("\n");
   const lines = rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
@@ -2059,11 +2231,7 @@ async function compileClaudeFile(bundle, batch, file, logger) {
       const msgRole = type === "user" ? "user" : "assistant";
       const role = inferRoleFromContent(parsed, msgRole);
       const msgOrdinal = messageOrdinal++;
-      const messageId2 = messageId(
-        sessionId2,
-        msgOrdinal,
-        parsed.message?.id ?? parsed.uuid ?? null
-      );
+      const messageId2 = messageId(sessionId2, msgOrdinal, parsed.message?.id ?? parsed.uuid ?? null);
       const eventId2 = eventId(sessionId2, ordinal, "message");
       pending.events.push({
         event_id: eventId2,
@@ -2119,17 +2287,7 @@ async function compileClaudeFile(bundle, batch, file, logger) {
         for (let bi = 0; bi < content.length; bi++) {
           const block = content[bi];
           if (!block) continue;
-          await processContentBlock(
-            bundle,
-            sessionId2,
-            messageId2,
-            eventId2,
-            bi,
-            block,
-            ts,
-            rawRecordId2,
-            pending
-          );
+          await processContentBlock(bundle, sessionId2, messageId2, eventId2, bi, block, ts, rawRecordId2, pending);
         }
       }
       continue;
@@ -2198,11 +2356,7 @@ async function compileClaudeFile(bundle, batch, file, logger) {
         confidence: "high"
       });
       pending.artifacts.push({
-        artifact_id: artifactId(
-          sessionId2,
-          "claude",
-          `snapshot:${parsed.snapshot?.messageId ?? ordinal}`
-        ),
+        artifact_id: artifactId(sessionId2, "claude", `snapshot:${parsed.snapshot?.messageId ?? ordinal}`),
         kind: "snapshot",
         path: null,
         logical_path: null,
@@ -2253,7 +2407,10 @@ async function compileClaudeFile(bundle, batch, file, logger) {
   buildSearchDocs(pending);
   await flushPendingObjects(bundle, pending.objects);
   transactional(bundle.db, () => {
-    flushPending(bundle, pending, { modelFirst, modelLast });
+    flushPending(bundle, pending, {
+      modelFirst,
+      modelLast
+    });
   });
   counts.raw_records = pending.rawRecords.length;
   counts.sessions = pending.session ? 1 : 0;
@@ -2264,12 +2421,14 @@ async function compileClaudeFile(bundle, batch, file, logger) {
   counts.tool_results = pending.toolResults.length;
   counts.artifacts = pending.artifacts.length;
   counts.edges = pending.edges.length;
-  logger?.debug(
-    { path: file.filePath, source_file_id: sourceFile.source_file_id, counts },
-    "claude source file imported"
-  );
+  logger?.debug({
+    path: file.filePath,
+    source_file_id: sourceFile.source_file_id,
+    counts
+  }, "claude source file imported");
   return counts;
 }
+__name(compileClaudeFile, "compileClaudeFile");
 function createSessionFromFirstRecord(file, parsed, meta, ts, rawRecordId2) {
   const sourceSid = parsed.sessionId;
   const composite = file.isSubagent && file.agentId ? `${sourceSid}:${file.agentId}` : sourceSid;
@@ -2288,6 +2447,7 @@ function createSessionFromFirstRecord(file, parsed, meta, ts, rawRecordId2) {
     parent_session_id_pending: null
   };
 }
+__name(createSessionFromFirstRecord, "createSessionFromFirstRecord");
 async function readMeta(metaPath) {
   try {
     const text = await readFile4(metaPath, "utf8");
@@ -2296,15 +2456,15 @@ async function readMeta(metaPath) {
     return null;
   }
 }
+__name(readMeta, "readMeta");
 function inferRoleFromContent(parsed, fallback) {
   if (fallback !== "user") return "assistant";
   const c = parsed.message?.content;
   if (!Array.isArray(c) || c.length === 0) return "user";
-  const allToolResult = c.every(
-    (b) => b && typeof b === "object" && b.type === "tool_result"
-  );
+  const allToolResult = c.every((b) => b && typeof b === "object" && b.type === "tool_result");
   return allToolResult ? "tool" : "user";
 }
+__name(inferRoleFromContent, "inferRoleFromContent");
 async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blockOrdinal, block, ts, rawRecordId2, pending) {
   const blkId = blockId(messageId2, blockOrdinal);
   if (block.type === "text") {
@@ -2447,6 +2607,7 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
     raw_record_id: rawRecordId2
   });
 }
+__name(processContentBlock, "processContentBlock");
 function canonicalToolType(toolName) {
   const lower = toolName.toLowerCase();
   if (lower.startsWith("mcp__")) return "mcp";
@@ -2463,6 +2624,7 @@ function canonicalToolType(toolName) {
   if (lower === "applypatch" || lower === "apply_patch") return "patch";
   return "other";
 }
+__name(canonicalToolType, "canonicalToolType");
 function inferCommandFromArgs(toolName, args) {
   if (!args || typeof args !== "object") return null;
   const obj = args;
@@ -2470,6 +2632,7 @@ function inferCommandFromArgs(toolName, args) {
   if (toolName.toLowerCase() === "bash" && typeof obj.cmd === "string") return obj.cmd;
   return null;
 }
+__name(inferCommandFromArgs, "inferCommandFromArgs");
 function inferPathFromArgs(args) {
   if (!args || typeof args !== "object") return null;
   const obj = args;
@@ -2478,6 +2641,7 @@ function inferPathFromArgs(args) {
   if (typeof obj.absolute_path === "string") return obj.absolute_path;
   return null;
 }
+__name(inferPathFromArgs, "inferPathFromArgs");
 function stringifyOrNull(value) {
   if (value == null) return null;
   if (typeof value === "string") return value;
@@ -2487,6 +2651,7 @@ function stringifyOrNull(value) {
     return null;
   }
 }
+__name(stringifyOrNull, "stringifyOrNull");
 function buildSearchDocs(pending) {
   const sessionId2 = pending.session?.session_id ?? null;
   if (!sessionId2) return;
@@ -2494,8 +2659,7 @@ function buildSearchDocs(pending) {
   for (const b of pending.blocks) {
     if (!b.message_id) continue;
     if (!b.text_inline) continue;
-    if (b.block_type !== "text" && b.block_type !== "thinking" && b.block_type !== "tool_result")
-      continue;
+    if (b.block_type !== "text" && b.block_type !== "thinking" && b.block_type !== "tool_result") continue;
     const list = blocksByMsg.get(b.message_id) ?? [];
     list.push(b);
     blocksByMsg.set(b.message_id, list);
@@ -2559,240 +2723,88 @@ function buildSearchDocs(pending) {
     });
   }
 }
+__name(buildSearchDocs, "buildSearchDocs");
 function flushPending(bundle, pending, meta) {
   if (!pending.session) return;
-  const insertRaw = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO raw_records (
+  const insertRaw = prepare(bundle.db, `INSERT OR IGNORE INTO raw_records (
        raw_record_id, source_file_id, source_tool, record_kind, ordinal,
        line_no, json_pointer, native_id, raw_object_id, decoded_json_object_id,
        parser_status, confidence, import_batch_id
-     ) VALUES (?, ?, 'claude', 'jsonl_line', ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, 'claude', 'jsonl_line', ?, ?, NULL, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.rawRecords) {
-    insertRaw.run(
-      r.raw_record_id,
-      r.source_file_id,
-      r.ordinal,
-      r.line_no,
-      r.native_id,
-      r.raw_object_id,
-      r.decoded_json_object_id,
-      r.parser_status,
-      r.confidence,
-      r.import_batch_id
-    );
+    insertRaw.run(r.raw_record_id, r.source_file_id, r.ordinal, r.line_no, r.native_id, r.raw_object_id, r.decoded_json_object_id, r.parser_status, r.confidence, r.import_batch_id);
   }
-  prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO sessions (
+  prepare(bundle.db, `INSERT OR REPLACE INTO sessions (
        session_id, source_tool, source_session_id, project_id, parent_session_id,
        is_subagent, agent_role, agent_nickname, title, summary,
        start_ts, end_ts, cwd_initial, git_branch_initial,
        model_first, model_last, status, timeline_confidence, raw_record_id
-     ) VALUES (?, 'claude', ?, NULL, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, 'completed', 'high', ?)`
-  ).run(
-    pending.session.session_id,
-    pending.session.source_session_id,
-    pending.session.is_subagent,
-    pending.session.agent_role,
-    pending.session.agent_nickname,
-    pending.session.title,
-    pending.session.start_ts,
-    pending.session.end_ts,
-    pending.session.cwd_initial,
-    pending.session.git_branch_initial,
-    meta.modelFirst,
-    meta.modelLast,
-    pending.session.raw_record_id
-  );
-  const insertEvent = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO events (
+     ) VALUES (?, 'claude', ?, NULL, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, 'completed', 'high', ?)`).run(pending.session.session_id, pending.session.source_session_id, pending.session.is_subagent, pending.session.agent_role, pending.session.agent_nickname, pending.session.title, pending.session.start_ts, pending.session.end_ts, pending.session.cwd_initial, pending.session.git_branch_initial, meta.modelFirst, meta.modelLast, pending.session.raw_record_id);
+  const insertEvent = prepare(bundle.db, `INSERT OR REPLACE INTO events (
        event_id, session_id, turn_id, source_event_id, event_type, source_type,
        subtype, timestamp, ordinal, actor, payload_object_id, raw_record_id,
        confidence, is_derived
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`);
   for (const e of pending.events) {
-    insertEvent.run(
-      e.event_id,
-      pending.session.session_id,
-      e.source_event_id,
-      e.event_type,
-      e.source_type,
-      e.subtype,
-      e.timestamp,
-      e.ordinal,
-      e.actor,
-      e.payload_object_id,
-      e.raw_record_id,
-      e.confidence
-    );
+    insertEvent.run(e.event_id, pending.session.session_id, e.source_event_id, e.event_type, e.source_type, e.subtype, e.timestamp, e.ordinal, e.actor, e.payload_object_id, e.raw_record_id, e.confidence);
   }
-  const insertMessage = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO messages (
+  const insertMessage = prepare(bundle.db, `INSERT OR REPLACE INTO messages (
        message_id, session_id, turn_id, event_id, source_message_id, role,
        author_name, model, timestamp, ordinal, parent_message_id, request_id,
        status, raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`);
   for (const m of pending.messages) {
-    insertMessage.run(
-      m.message_id,
-      pending.session.session_id,
-      m.event_id,
-      m.source_message_id,
-      m.role,
-      m.model,
-      m.timestamp,
-      m.ordinal,
-      m.raw_record_id
-    );
+    insertMessage.run(m.message_id, pending.session.session_id, m.event_id, m.source_message_id, m.role, m.model, m.timestamp, m.ordinal, m.raw_record_id);
   }
-  const insertBlock = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO content_blocks (
+  const insertBlock = prepare(bundle.db, `INSERT OR REPLACE INTO content_blocks (
        block_id, message_id, event_id, session_id, ordinal, block_type,
        text_object_id, text_inline, mime_type, token_count, is_error,
        is_redacted, visibility, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 0, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 0, ?, ?)`);
   for (const b of pending.blocks) {
-    insertBlock.run(
-      b.block_id,
-      b.message_id,
-      b.event_id,
-      pending.session.session_id,
-      b.ordinal,
-      b.block_type,
-      b.text_object_id,
-      b.text_inline,
-      b.is_error,
-      b.visibility,
-      b.raw_record_id
-    );
+    insertBlock.run(b.block_id, b.message_id, b.event_id, pending.session.session_id, b.ordinal, b.block_type, b.text_object_id, b.text_inline, b.is_error, b.visibility, b.raw_record_id);
   }
-  const insertToolCall = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_calls (
+  const insertToolCall = prepare(bundle.db, `INSERT OR REPLACE INTO tool_calls (
        tool_call_id, session_id, turn_id, message_id, event_id,
        source_call_id, tool_name, canonical_tool_type, args_object_id,
        command, cwd, path, query, timestamp_start, timestamp_end, status,
        raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`);
   for (const c of pending.toolCallsList) {
-    insertToolCall.run(
-      c.tool_call_id,
-      pending.session.session_id,
-      c.message_id,
-      c.event_id,
-      c.source_call_id,
-      c.tool_name,
-      c.canonical_tool_type,
-      c.args_object_id,
-      c.command,
-      c.cwd,
-      c.path,
-      c.query,
-      c.timestamp_start,
-      c.status,
-      c.raw_record_id
-    );
+    insertToolCall.run(c.tool_call_id, pending.session.session_id, c.message_id, c.event_id, c.source_call_id, c.tool_name, c.canonical_tool_type, c.args_object_id, c.command, c.cwd, c.path, c.query, c.timestamp_start, c.status, c.raw_record_id);
   }
-  const insertToolResult = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_results (
+  const insertToolResult = prepare(bundle.db, `INSERT OR REPLACE INTO tool_results (
        tool_result_id, tool_call_id, session_id, message_id, event_id,
        source_call_id, status, is_error, exit_code, duration_ms,
        stdout_object_id, stderr_object_id, output_object_id, preview, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.toolResults) {
-    insertToolResult.run(
-      r.tool_result_id,
-      r.tool_call_id,
-      pending.session.session_id,
-      r.message_id,
-      r.event_id,
-      r.source_call_id,
-      r.status,
-      r.is_error,
-      r.exit_code,
-      r.duration_ms,
-      r.stdout_object_id,
-      r.stderr_object_id,
-      r.output_object_id,
-      r.preview,
-      r.raw_record_id
-    );
+    insertToolResult.run(r.tool_result_id, r.tool_call_id, pending.session.session_id, r.message_id, r.event_id, r.source_call_id, r.status, r.is_error, r.exit_code, r.duration_ms, r.stdout_object_id, r.stderr_object_id, r.output_object_id, r.preview, r.raw_record_id);
   }
-  const insertArtifact = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO artifacts (
+  const insertArtifact = prepare(bundle.db, `INSERT OR REPLACE INTO artifacts (
        artifact_id, session_id, project_id, source_tool, kind, path,
        logical_path, object_id, text_object_id, mime_type, size_bytes,
        created_ts, raw_record_id
-     ) VALUES (?, ?, NULL, 'claude', ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, NULL, 'claude', ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const a of pending.artifacts) {
-    insertArtifact.run(
-      a.artifact_id,
-      pending.session.session_id,
-      a.kind,
-      a.path,
-      a.logical_path,
-      a.object_id,
-      a.text_object_id,
-      a.mime_type,
-      a.size_bytes,
-      a.created_ts,
-      a.raw_record_id
-    );
+    insertArtifact.run(a.artifact_id, pending.session.session_id, a.kind, a.path, a.logical_path, a.object_id, a.text_object_id, a.mime_type, a.size_bytes, a.created_ts, a.raw_record_id);
   }
-  const insertEdge = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO edges (
+  const insertEdge = prepare(bundle.db, `INSERT OR IGNORE INTO edges (
        src_type, src_id, dst_type, dst_id, edge_type, confidence, source,
        raw_record_id, metadata_object_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`);
   for (const e of pending.edges) {
-    insertEdge.run(
-      e.src_type,
-      e.src_id,
-      e.dst_type,
-      e.dst_id,
-      e.edge_type,
-      e.confidence,
-      e.source,
-      e.raw_record_id
-    );
+    insertEdge.run(e.src_type, e.src_id, e.dst_type, e.dst_id, e.edge_type, e.confidence, e.source, e.raw_record_id);
   }
-  const insertSearch = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO search_docs (
+  const insertSearch = prepare(bundle.db, `INSERT OR REPLACE INTO search_docs (
        doc_id, entity_type, entity_id, session_id, project_id, timestamp,
        role, tool_name, canonical_tool_type, field_kind, text
-     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`);
   for (const d of pending.searchDocs) {
-    insertSearch.run(
-      d.doc_id,
-      d.entity_type,
-      d.entity_id,
-      pending.session.session_id,
-      d.timestamp,
-      d.role,
-      d.tool_name,
-      d.canonical_tool_type,
-      d.field_kind,
-      d.text
-    );
+    insertSearch.run(d.doc_id, d.entity_type, d.entity_id, pending.session.session_id, d.timestamp, d.role, d.tool_name, d.canonical_tool_type, d.field_kind, d.text);
   }
 }
+__name(flushPending, "flushPending");
 
 // src/importers/codex/index.ts
 import { readFile as readFile5 } from "fs/promises";
@@ -2804,10 +2816,13 @@ import path7 from "path";
 async function* discoverCodexSessions(root) {
   yield* walk(root);
 }
+__name(discoverCodexSessions, "discoverCodexSessions");
 async function* walk(dir) {
   let entries;
   try {
-    entries = await readdir2(dir, { withFileTypes: true });
+    entries = await readdir2(dir, {
+      withFileTypes: true
+    });
   } catch {
     return;
   }
@@ -2820,48 +2835,108 @@ async function* walk(dir) {
     }
   }
 }
+__name(walk, "walk");
 
 // src/importers/codex/index.ts
 var PREVIEW_MAX2 = 4e3;
+var CODEX_PREPARE_CONCURRENCY = 8;
 async function compileCodex(bundle, root, options = {}) {
   const logger = options.logger;
-  const batch = startBatch(bundle, "codex", [root]);
+  const batch = startBatch(bundle, "codex", [
+    root
+  ]);
   const counts = emptyCounts();
-  logger?.info({ batch_id: batch.batch_id, root }, "codex batch started");
+  logger?.info({
+    batch_id: batch.batch_id,
+    root
+  }, "codex batch started");
   try {
+    const files = [];
     for await (const filePath of discoverCodexSessions(root)) {
-      counts.source_files_seen++;
-      logger?.debug({ path: filePath }, "codex source file discovered");
-      try {
-        const fileCounts = await compileCodexFile(bundle, batch, filePath, logger);
-        addCounts2(counts, fileCounts);
-      } catch (error) {
-        counts.errors++;
-        logger?.warn(
-          {
-            err: error,
-            path: filePath
-          },
-          "codex source file failed"
-        );
-        await recordError(bundle, batch.batch_id, {
-          kind: "codex_file_failed",
-          message: getErrorMessage(error),
-          payload: { path: filePath }
-        });
-      }
+      files.push(filePath);
+      logger?.debug({
+        path: filePath
+      }, "codex source file discovered");
+    }
+    counts.source_files_seen = files.length;
+    for (let i = 0; i < files.length; i += CODEX_PREPARE_CONCURRENCY) {
+      const slice = files.slice(i, i + CODEX_PREPARE_CONCURRENCY);
+      await processCodexBatch(bundle, batch, slice, counts, logger);
     }
     linkSubagentParents2(bundle);
-    logger?.debug({ batch_id: batch.batch_id }, "codex subagent parent links refreshed");
+    logger?.debug({
+      batch_id: batch.batch_id
+    }, "codex subagent parent links refreshed");
     finishBatch(bundle, batch, counts, "completed");
-    logger?.info({ batch_id: batch.batch_id, counts }, "codex batch completed");
+    logger?.info({
+      batch_id: batch.batch_id,
+      counts
+    }, "codex batch completed");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
-    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "codex batch failed");
+    logger?.error({
+      err: error,
+      batch_id: batch.batch_id,
+      counts
+    }, "codex batch failed");
     throw error;
   }
-  return { batch, counts };
+  return {
+    batch,
+    counts
+  };
 }
+__name(compileCodex, "compileCodex");
+async function processCodexBatch(bundle, batch, slice, counts, logger) {
+  const items = await Promise.all(slice.map(async (filePath) => {
+    try {
+      const result = await prepareCodexFile(bundle, batch, filePath, logger);
+      return {
+        filePath,
+        prepared: result.prepared,
+        fileCounts: result.counts,
+        prepareError: null,
+        applyError: null
+      };
+    } catch (err) {
+      return {
+        filePath,
+        prepared: null,
+        fileCounts: emptyFileCounts2(),
+        prepareError: err,
+        applyError: null
+      };
+    }
+  }));
+  for (const item of items) {
+    if (item.prepareError || !item.prepared) continue;
+    try {
+      transactional(bundle.db, () => applyCodexFile(bundle, item.prepared));
+    } catch (err) {
+      item.applyError = err;
+    }
+  }
+  for (const item of items) {
+    const err = item.prepareError ?? item.applyError;
+    if (err) {
+      counts.errors++;
+      logger?.warn({
+        err,
+        path: item.filePath
+      }, "codex source file failed");
+      await recordError(bundle, batch.batch_id, {
+        kind: "codex_file_failed",
+        message: getErrorMessage(err),
+        payload: {
+          path: item.filePath
+        }
+      });
+    } else {
+      addCounts2(counts, item.fileCounts);
+    }
+  }
+}
+__name(processCodexBatch, "processCodexBatch");
 function linkSubagentParents2(bundle) {
   bundle.db.exec(`
     UPDATE sessions
@@ -2878,6 +2953,7 @@ function linkSubagentParents2(bundle) {
        AND is_subagent = 1
   `);
 }
+__name(linkSubagentParents2, "linkSubagentParents");
 function emptyFileCounts2() {
   return {
     source_files_imported: 0,
@@ -2895,6 +2971,7 @@ function emptyFileCounts2() {
     errors: 0
   };
 }
+__name(emptyFileCounts2, "emptyFileCounts");
 function addCounts2(target, source) {
   target.source_files_imported += source.source_files_imported;
   target.source_files_skipped += source.source_files_skipped;
@@ -2910,7 +2987,8 @@ function addCounts2(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
-async function compileCodexFile(bundle, batch, filePath, logger) {
+__name(addCounts2, "addCounts");
+async function prepareCodexFile(bundle, batch, filePath, logger) {
   const counts = emptyFileCounts2();
   const { row: sourceFileRow, alreadyKnown } = await registerSourceFile(bundle, {
     sourceTool: "codex",
@@ -2919,17 +2997,20 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
-    logger?.debug(
-      { path: filePath, source_file_id: sourceFileRow.source_file_id },
-      "codex source file skipped"
-    );
-    return counts;
+    logger?.debug({
+      path: filePath,
+      source_file_id: sourceFileRow.source_file_id
+    }, "codex source file skipped");
+    return {
+      prepared: null,
+      counts
+    };
   }
   counts.source_files_imported = 1;
-  logger?.debug(
-    { path: filePath, source_file_id: sourceFileRow.source_file_id },
-    "codex source file registered"
-  );
+  logger?.debug({
+    path: filePath,
+    source_file_id: sourceFileRow.source_file_id
+  }, "codex source file registered");
   const text = await readFile5(filePath, "utf8");
   const rawLines = text.split("\n");
   const lines = rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
@@ -2941,7 +3022,6 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
     messages: [],
     blocks: [],
     toolCalls: /* @__PURE__ */ new Map(),
-    // by source_call_id
     toolCallsList: [],
     toolResults: [],
     artifacts: [],
@@ -3073,34 +3153,12 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
     const currentTurnId = pending.turns.length > 0 ? pending.turns[pending.turns.length - 1].turn_id : null;
     if (type === "response_item") {
       const ri = payload;
-      handleResponseItem(
-        bundle,
-        sessionId2,
-        currentTurnId,
-        rawRecordId2,
-        ordinal,
-        ts,
-        ri,
-        decodedObjectId,
-        () => messageOrdinal++,
-        modelLast,
-        pending
-      );
+      handleResponseItem(bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, ri, decodedObjectId, () => messageOrdinal++, modelLast, pending);
       continue;
     }
     if (type === "event_msg") {
       const em = payload;
-      await handleEventMsg(
-        bundle,
-        sessionId2,
-        currentTurnId,
-        rawRecordId2,
-        ordinal,
-        ts,
-        em,
-        decodedObjectId,
-        pending
-      );
+      await handleEventMsg(bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, em, decodedObjectId, pending);
       continue;
     }
     if (type === "compacted") {
@@ -3122,19 +3180,10 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
     }
     if (type === "message") {
       const ri = payload;
-      handleResponseItem(
-        bundle,
-        sessionId2,
-        currentTurnId,
-        rawRecordId2,
-        ordinal,
-        ts,
-        { ...ri, type: "message" },
-        decodedObjectId,
-        () => messageOrdinal++,
-        modelLast,
-        pending
-      );
+      handleResponseItem(bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, {
+        ...ri,
+        type: "message"
+      }, decodedObjectId, () => messageOrdinal++, modelLast, pending);
     }
   }
   if (pending.session) {
@@ -3142,14 +3191,6 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
   }
   buildSearchDocs2(pending);
   await flushPendingObjects(bundle, pending.objects);
-  transactional(bundle.db, () => {
-    flushPending2(bundle, pending, {
-      sessionEndTs,
-      modelFirst,
-      modelLast,
-      sourceTool: "codex"
-    });
-  });
   counts.raw_records = pending.rawRecords.length;
   counts.sessions = pending.session ? 1 : 0;
   counts.turns = pending.turns.length;
@@ -3160,12 +3201,34 @@ async function compileCodexFile(bundle, batch, filePath, logger) {
   counts.tool_results = pending.toolResults.length;
   counts.artifacts = pending.artifacts.length;
   counts.edges = pending.edges.length;
-  logger?.debug(
-    { path: filePath, source_file_id: sourceFileRow.source_file_id, counts },
-    "codex source file imported"
-  );
-  return counts;
+  logger?.debug({
+    path: filePath,
+    source_file_id: sourceFileRow.source_file_id,
+    counts
+  }, "codex source file prepared");
+  return {
+    prepared: {
+      filePath,
+      pending,
+      meta: {
+        sessionEndTs,
+        modelFirst,
+        modelLast
+      }
+    },
+    counts
+  };
+}
+__name(prepareCodexFile, "prepareCodexFile");
+function applyCodexFile(bundle, prep) {
+  flushPending2(bundle, prep.pending, {
+    sessionEndTs: prep.meta.sessionEndTs,
+    modelFirst: prep.meta.modelFirst,
+    modelLast: prep.meta.modelLast,
+    sourceTool: "codex"
+  });
 }
+__name(applyCodexFile, "applyCodexFile");
 function handleResponseItem(_bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, ri, payloadObjectId, nextMsgOrdinal, currentModel, pending) {
   const subtype = ri.type ?? null;
   if (subtype === "message") {
@@ -3294,7 +3357,6 @@ function handleResponseItem(_bundle, sessionId2, currentTurnId, rawRecordId2, or
       stdout_object_id: null,
       stderr_object_id: null,
       output_object_id: null,
-      // small previews only at this stage
       preview: outputText.slice(0, PREVIEW_MAX2),
       raw_record_id: rawRecordId2
     });
@@ -3319,16 +3381,18 @@ function handleResponseItem(_bundle, sessionId2, currentTurnId, rawRecordId2, or
     confidence: "high"
   });
 }
+__name(handleResponseItem, "handleResponseItem");
 async function handleEventMsg(bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, em, payloadObjectId, pending) {
   const subtype = em.type ?? "unknown";
   if (subtype === "exec_command_end") {
     const sourceCallId = em.call_id ?? null;
-    const stdoutId = em.stdout ? stageText(pending.objects, em.stdout, { mimeType: "text/plain" }) : null;
-    const stderrId = em.stderr ? stageText(pending.objects, em.stderr, { mimeType: "text/plain" }) : null;
-    const preview = (em.formatted_output ?? em.aggregated_output ?? em.stdout ?? "").slice(
-      0,
-      PREVIEW_MAX2
-    );
+    const stdoutId = em.stdout ? stageText(pending.objects, em.stdout, {
+      mimeType: "text/plain"
+    }) : null;
+    const stderrId = em.stderr ? stageText(pending.objects, em.stderr, {
+      mimeType: "text/plain"
+    }) : null;
+    const preview = (em.formatted_output ?? em.aggregated_output ?? em.stdout ?? "").slice(0, PREVIEW_MAX2);
     const exitCode = typeof em.exit_code === "number" ? em.exit_code : null;
     const isError = exitCode != null && exitCode !== 0 ? 1 : 0;
     const eventId2 = eventId(sessionId2, ordinal, "exec_command_end");
@@ -3472,6 +3536,7 @@ async function handleEventMsg(bundle, sessionId2, currentTurnId, rawRecordId2, o
     confidence: "high"
   });
 }
+__name(handleEventMsg, "handleEventMsg");
 function extractNativeId(env) {
   const p = env.payload;
   if (!p) return null;
@@ -3480,6 +3545,7 @@ function extractNativeId(env) {
   if (typeof p.turn_id === "string") return p.turn_id;
   return null;
 }
+__name(extractNativeId, "extractNativeId");
 function mapMessageRole(role) {
   switch (role) {
     case "user":
@@ -3496,6 +3562,7 @@ function mapMessageRole(role) {
       return "operational";
   }
 }
+__name(mapMessageRole, "mapMessageRole");
 function canonicalToolType2(toolName) {
   const lower = toolName.toLowerCase();
   if (lower.startsWith("mcp__")) return "mcp";
@@ -3511,6 +3578,7 @@ function canonicalToolType2(toolName) {
   if (lower === "agent" || lower === "subagent" || lower === "collab_spawn") return "subagent";
   return "other";
 }
+__name(canonicalToolType2, "canonicalToolType");
 function inferCommandFromArgs2(toolName, args) {
   if (!args || typeof args !== "object") {
     if (typeof args === "string") {
@@ -3530,6 +3598,7 @@ function inferCommandFromArgs2(toolName, args) {
   }
   return null;
 }
+__name(inferCommandFromArgs2, "inferCommandFromArgs");
 function inferPathFromArgs2(args) {
   if (!args || typeof args !== "object") {
     if (typeof args === "string") {
@@ -3548,15 +3617,18 @@ function inferPathFromArgs2(args) {
   if (typeof obj.absolute_path === "string") return obj.absolute_path;
   return null;
 }
+__name(inferPathFromArgs2, "inferPathFromArgs");
 function looksLikeError(text) {
   return /\b(error|exception|failed|stack trace)\b/i.test(text);
 }
+__name(looksLikeError, "looksLikeError");
 function durationMs(d) {
   if (!d || typeof d !== "object") return null;
   const secs = typeof d.secs === "number" ? d.secs : 0;
   const nanos = typeof d.nanos === "number" ? d.nanos : 0;
   return secs * 1e3 + Math.floor(nanos / 1e6);
 }
+__name(durationMs, "durationMs");
 function stringifyOrNull2(value) {
   if (value == null) return null;
   if (typeof value === "string") return value;
@@ -3566,6 +3638,7 @@ function stringifyOrNull2(value) {
     return null;
   }
 }
+__name(stringifyOrNull2, "stringifyOrNull");
 function parseSubagent(source) {
   if (!source || typeof source !== "object") return null;
   const obj = source;
@@ -3582,6 +3655,7 @@ function parseSubagent(source) {
     agent_nickname: typeof tso.agent_nickname === "string" ? tso.agent_nickname : void 0
   };
 }
+__name(parseSubagent, "parseSubagent");
 function buildSearchDocs2(pending) {
   const sessionId2 = pending.session?.session_id ?? null;
   if (!sessionId2) return;
@@ -3593,9 +3667,7 @@ function buildSearchDocs2(pending) {
     blocksByMsg.set(b.message_id, list);
   }
   for (const m of pending.messages) {
-    const text = (blocksByMsg.get(m.message_id) ?? []).filter(
-      (b) => b.text_inline && (b.block_type === "input_text" || b.block_type === "output_text" || b.block_type === "text")
-    ).map((b) => b.text_inline).join("\n");
+    const text = (blocksByMsg.get(m.message_id) ?? []).filter((b) => b.text_inline && (b.block_type === "input_text" || b.block_type === "output_text" || b.block_type === "text")).map((b) => b.text_inline).join("\n");
     if (!text || text.length === 0) continue;
     pending.searchDocs.push({
       doc_id: `msg:${m.message_id}`,
@@ -3653,284 +3725,96 @@ function buildSearchDocs2(pending) {
     }
   }
 }
+__name(buildSearchDocs2, "buildSearchDocs");
 function flushPending2(bundle, pending, meta) {
   if (!pending.session) return;
-  const insertRaw = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO raw_records (
+  const insertRaw = prepare(bundle.db, `INSERT OR IGNORE INTO raw_records (
        raw_record_id, source_file_id, source_tool, record_kind, ordinal,
        line_no, json_pointer, native_id, raw_object_id, decoded_json_object_id,
        parser_status, confidence, import_batch_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.rawRecords) {
-    insertRaw.run(
-      r.raw_record_id,
-      r.source_file_id,
-      r.source_tool,
-      r.record_kind,
-      r.ordinal,
-      r.line_no,
-      r.json_pointer,
-      r.native_id,
-      r.raw_object_id,
-      r.decoded_json_object_id,
-      r.parser_status,
-      r.confidence,
-      r.import_batch_id
-    );
+    insertRaw.run(r.raw_record_id, r.source_file_id, r.source_tool, r.record_kind, r.ordinal, r.line_no, r.json_pointer, r.native_id, r.raw_object_id, r.decoded_json_object_id, r.parser_status, r.confidence, r.import_batch_id);
   }
-  const insertSession = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO sessions (
+  const insertSession = prepare(bundle.db, `INSERT OR REPLACE INTO sessions (
        session_id, source_tool, source_session_id, project_id, parent_session_id,
        is_subagent, agent_role, agent_nickname, title, summary,
        start_ts, end_ts, cwd_initial, git_branch_initial,
        model_first, model_last, status, timeline_confidence, raw_record_id
-     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'high', ?)`
-  );
-  insertSession.run(
-    pending.session.session_id,
-    meta.sourceTool,
-    pending.session.source_session_id,
-    null,
-    pending.session.is_subagent,
-    pending.session.agent_role,
-    pending.session.agent_nickname,
-    pending.session.title,
-    null,
-    pending.session.start_ts,
-    meta.sessionEndTs,
-    pending.session.cwd_initial,
-    pending.session.git_branch_initial,
-    meta.modelFirst,
-    meta.modelLast,
-    "completed",
-    pending.session.raw_record_id
-  );
-  const insertTurn = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO turns (
+     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'high', ?)`);
+  insertSession.run(pending.session.session_id, meta.sourceTool, pending.session.source_session_id, null, pending.session.is_subagent, pending.session.agent_role, pending.session.agent_nickname, pending.session.title, null, pending.session.start_ts, meta.sessionEndTs, pending.session.cwd_initial, pending.session.git_branch_initial, meta.modelFirst, meta.modelLast, "completed", pending.session.raw_record_id);
+  const insertTurn = prepare(bundle.db, `INSERT OR REPLACE INTO turns (
        turn_id, session_id, source_turn_id, ordinal, start_ts, end_ts,
        model, cwd, git_branch, approval_policy, sandbox_policy, effort, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const t of pending.turns) {
-    insertTurn.run(
-      t.turn_id,
-      pending.session.session_id,
-      t.source_turn_id,
-      t.ordinal,
-      t.start_ts,
-      null,
-      t.model,
-      t.cwd,
-      null,
-      t.approval_policy,
-      t.sandbox_policy,
-      t.effort,
-      t.raw_record_id
-    );
+    insertTurn.run(t.turn_id, pending.session.session_id, t.source_turn_id, t.ordinal, t.start_ts, null, t.model, t.cwd, null, t.approval_policy, t.sandbox_policy, t.effort, t.raw_record_id);
   }
-  const insertEvent = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO events (
+  const insertEvent = prepare(bundle.db, `INSERT OR REPLACE INTO events (
        event_id, session_id, turn_id, source_event_id, event_type, source_type,
        subtype, timestamp, ordinal, actor, payload_object_id, raw_record_id,
        confidence, is_derived
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`);
   for (const e of pending.events) {
-    insertEvent.run(
-      e.event_id,
-      pending.session.session_id,
-      e.turn_id,
-      e.source_event_id,
-      e.event_type,
-      e.source_type,
-      e.subtype,
-      e.timestamp,
-      e.ordinal,
-      e.actor,
-      e.payload_object_id,
-      e.raw_record_id,
-      e.confidence
-    );
+    insertEvent.run(e.event_id, pending.session.session_id, e.turn_id, e.source_event_id, e.event_type, e.source_type, e.subtype, e.timestamp, e.ordinal, e.actor, e.payload_object_id, e.raw_record_id, e.confidence);
   }
-  const insertMessage = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO messages (
+  const insertMessage = prepare(bundle.db, `INSERT OR REPLACE INTO messages (
        message_id, session_id, turn_id, event_id, source_message_id, role,
        author_name, model, timestamp, ordinal, parent_message_id, request_id,
        status, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const m of pending.messages) {
-    insertMessage.run(
-      m.message_id,
-      pending.session.session_id,
-      m.turn_id,
-      m.event_id,
-      m.source_message_id,
-      m.role,
-      null,
-      m.model,
-      m.timestamp,
-      m.ordinal,
-      null,
-      null,
-      null,
-      m.raw_record_id
-    );
+    insertMessage.run(m.message_id, pending.session.session_id, m.turn_id, m.event_id, m.source_message_id, m.role, null, m.model, m.timestamp, m.ordinal, null, null, null, m.raw_record_id);
   }
-  const insertBlock = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO content_blocks (
+  const insertBlock = prepare(bundle.db, `INSERT OR REPLACE INTO content_blocks (
        block_id, message_id, event_id, session_id, ordinal, block_type,
        text_object_id, text_inline, mime_type, token_count, is_error,
        is_redacted, visibility, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'default', ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'default', ?)`);
   for (const b of pending.blocks) {
-    insertBlock.run(
-      b.block_id,
-      b.message_id,
-      b.event_id,
-      pending.session.session_id,
-      b.ordinal,
-      b.block_type,
-      b.text_object_id,
-      b.text_inline,
-      null,
-      null,
-      0,
-      0,
-      b.raw_record_id
-    );
+    insertBlock.run(b.block_id, b.message_id, b.event_id, pending.session.session_id, b.ordinal, b.block_type, b.text_object_id, b.text_inline, null, null, 0, 0, b.raw_record_id);
   }
-  const insertToolCall = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_calls (
+  const insertToolCall = prepare(bundle.db, `INSERT OR REPLACE INTO tool_calls (
        tool_call_id, session_id, turn_id, message_id, event_id,
        source_call_id, tool_name, canonical_tool_type, args_object_id,
        command, cwd, path, query, timestamp_start, timestamp_end, status,
        raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const c of pending.toolCallsList) {
-    insertToolCall.run(
-      c.tool_call_id,
-      pending.session.session_id,
-      c.turn_id,
-      c.message_id,
-      c.event_id,
-      c.source_call_id,
-      c.tool_name,
-      c.canonical_tool_type,
-      c.args_object_id,
-      c.command,
-      c.cwd,
-      c.path,
-      c.query,
-      c.timestamp_start,
-      null,
-      c.status,
-      c.raw_record_id
-    );
+    insertToolCall.run(c.tool_call_id, pending.session.session_id, c.turn_id, c.message_id, c.event_id, c.source_call_id, c.tool_name, c.canonical_tool_type, c.args_object_id, c.command, c.cwd, c.path, c.query, c.timestamp_start, null, c.status, c.raw_record_id);
   }
-  const insertToolResult = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_results (
+  const insertToolResult = prepare(bundle.db, `INSERT OR REPLACE INTO tool_results (
        tool_result_id, tool_call_id, session_id, message_id, event_id,
        source_call_id, status, is_error, exit_code, duration_ms,
        stdout_object_id, stderr_object_id, output_object_id, preview, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.toolResults) {
-    insertToolResult.run(
-      r.tool_result_id,
-      r.tool_call_id,
-      pending.session.session_id,
-      r.message_id,
-      r.event_id,
-      r.source_call_id,
-      r.status,
-      r.is_error,
-      r.exit_code,
-      r.duration_ms,
-      r.stdout_object_id,
-      r.stderr_object_id,
-      r.output_object_id,
-      r.preview,
-      r.raw_record_id
-    );
+    insertToolResult.run(r.tool_result_id, r.tool_call_id, pending.session.session_id, r.message_id, r.event_id, r.source_call_id, r.status, r.is_error, r.exit_code, r.duration_ms, r.stdout_object_id, r.stderr_object_id, r.output_object_id, r.preview, r.raw_record_id);
   }
-  const insertArtifact = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO artifacts (
+  const insertArtifact = prepare(bundle.db, `INSERT OR REPLACE INTO artifacts (
        artifact_id, session_id, project_id, source_tool, kind, path,
        logical_path, object_id, text_object_id, mime_type, size_bytes,
        created_ts, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const a of pending.artifacts) {
-    insertArtifact.run(
-      a.artifact_id,
-      pending.session.session_id,
-      null,
-      "codex",
-      a.kind,
-      a.path,
-      a.logical_path,
-      a.object_id,
-      a.text_object_id,
-      a.mime_type,
-      a.size_bytes,
-      a.created_ts,
-      a.raw_record_id
-    );
+    insertArtifact.run(a.artifact_id, pending.session.session_id, null, "codex", a.kind, a.path, a.logical_path, a.object_id, a.text_object_id, a.mime_type, a.size_bytes, a.created_ts, a.raw_record_id);
   }
-  const insertEdge = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO edges (
+  const insertEdge = prepare(bundle.db, `INSERT OR IGNORE INTO edges (
        src_type, src_id, dst_type, dst_id, edge_type, confidence, source,
        raw_record_id, metadata_object_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`);
   for (const e of pending.edges) {
-    insertEdge.run(
-      e.src_type,
-      e.src_id,
-      e.dst_type,
-      e.dst_id,
-      e.edge_type,
-      e.confidence,
-      e.source,
-      e.raw_record_id
-    );
+    insertEdge.run(e.src_type, e.src_id, e.dst_type, e.dst_id, e.edge_type, e.confidence, e.source, e.raw_record_id);
   }
-  const insertSearch = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO search_docs (
+  const insertSearch = prepare(bundle.db, `INSERT OR REPLACE INTO search_docs (
        doc_id, entity_type, entity_id, session_id, project_id, timestamp,
        role, tool_name, canonical_tool_type, field_kind, text
-     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`);
   for (const d of pending.searchDocs) {
-    insertSearch.run(
-      d.doc_id,
-      d.entity_type,
-      d.entity_id,
-      pending.session.session_id,
-      d.timestamp,
-      d.role,
-      d.tool_name,
-      d.canonical_tool_type,
-      d.field_kind,
-      d.text
-    );
+    insertSearch.run(d.doc_id, d.entity_type, d.entity_id, pending.session.session_id, d.timestamp, d.role, d.tool_name, d.canonical_tool_type, d.field_kind, d.text);
   }
 }
+__name(flushPending2, "flushPending");
 
 // src/importers/cursor/index.ts
 import path10 from "path";
@@ -3959,60 +3843,76 @@ async function* discoverCursorStores(root) {
     }
   }
 }
+__name(discoverCursorStores, "discoverCursorStores");
 async function readdirSafe2(dir) {
   try {
-    return await readdir3(dir, { withFileTypes: true });
+    return await readdir3(dir, {
+      withFileTypes: true
+    });
   } catch {
     return [];
   }
 }
+__name(readdirSafe2, "readdirSafe");
 
 // src/importers/cursor/index.ts
 var PREVIEW_MAX3 = 4e3;
 async function compileCursor(bundle, root, options = {}) {
   const logger = options.logger;
-  const batch = startBatch(bundle, "cursor", [root]);
+  const batch = startBatch(bundle, "cursor", [
+    root
+  ]);
   const counts = emptyCounts();
-  logger?.info({ batch_id: batch.batch_id, root }, "cursor batch started");
+  logger?.info({
+    batch_id: batch.batch_id,
+    root
+  }, "cursor batch started");
   try {
     for await (const store of discoverCursorStores(root)) {
       counts.source_files_seen++;
-      logger?.debug(
-        {
-          path: store.filePath,
-          workspace_id: store.workspaceId,
-          agent_id: store.agentId
-        },
-        "cursor store discovered"
-      );
+      logger?.debug({
+        path: store.filePath,
+        workspace_id: store.workspaceId,
+        agent_id: store.agentId
+      }, "cursor store discovered");
       try {
         const fc = await compileCursorStore(bundle, batch, store, logger);
         addCounts3(counts, fc);
       } catch (error) {
         counts.errors++;
-        logger?.warn(
-          {
-            err: error,
-            path: store.filePath
-          },
-          "cursor store failed"
-        );
+        logger?.warn({
+          err: error,
+          path: store.filePath
+        }, "cursor store failed");
         await recordError(bundle, batch.batch_id, {
           kind: "cursor_store_failed",
           message: getErrorMessage(error),
-          payload: { path: store.filePath }
+          payload: {
+            path: store.filePath
+          }
         });
       }
     }
     finishBatch(bundle, batch, counts, "completed");
-    logger?.info({ batch_id: batch.batch_id, counts }, "cursor batch completed");
+    logger?.info({
+      batch_id: batch.batch_id,
+      counts
+    }, "cursor batch completed");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
-    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "cursor batch failed");
+    logger?.error({
+      err: error,
+      batch_id: batch.batch_id,
+      counts
+    }, "cursor batch failed");
     throw error;
   }
-  return { batch, counts };
+  return {
+    batch,
+    counts
+  };
 }
+__name(compileCursor, "compileCursor");
 function emptyFileCounts3() {
   return {
     source_files_imported: 0,
@@ -4029,6 +3929,7 @@ function emptyFileCounts3() {
     errors: 0
   };
 }
+__name(emptyFileCounts3, "emptyFileCounts");
 function addCounts3(target, source) {
   target.source_files_imported += source.source_files_imported;
   target.source_files_skipped += source.source_files_skipped;
@@ -4043,6 +3944,7 @@ function addCounts3(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
+__name(addCounts3, "addCounts");
 async function compileCursorStore(bundle, batch, store, logger) {
   const counts = emptyFileCounts3();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
@@ -4053,18 +3955,21 @@ async function compileCursorStore(bundle, batch, store, logger) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
-    logger?.debug(
-      { path: store.filePath, source_file_id: sourceFile.source_file_id },
-      "cursor store skipped"
-    );
+    logger?.debug({
+      path: store.filePath,
+      source_file_id: sourceFile.source_file_id
+    }, "cursor store skipped");
     return counts;
   }
   counts.source_files_imported = 1;
-  logger?.debug(
-    { path: store.filePath, source_file_id: sourceFile.source_file_id },
-    "cursor store registered"
-  );
-  const cdb = new Database2(store.filePath, { readonly: true, fileMustExist: true });
+  logger?.debug({
+    path: store.filePath,
+    source_file_id: sourceFile.source_file_id
+  }, "cursor store registered");
+  const cdb = new Database2(store.filePath, {
+    readonly: true,
+    fileMustExist: true
+  });
   try {
     const pending = {
       rawRecords: [],
@@ -4151,7 +4056,6 @@ async function compileCursorStore(bundle, batch, store, logger) {
         decoded_json_object_id: parsed != null ? stageJson(pending.objects, parsed) : null,
         parser_status: parsed != null ? "ok" : looksJson ? "failed" : "partial",
         confidence: "low",
-        // timeline order from blob list isn't canonical
         import_batch_id: batch.batch_id,
         record_kind: "sqlite_blob"
       });
@@ -4189,16 +4093,7 @@ async function compileCursorStore(bundle, batch, store, logger) {
         for (let bi = 0; bi < content.length; bi++) {
           const item = content[bi];
           if (!item) continue;
-          await processContentItem(
-            bundle,
-            sessionPk,
-            messageId2,
-            eventId2,
-            bi,
-            item,
-            blobRawId,
-            pending
-          );
+          await processContentItem(bundle, sessionPk, messageId2, eventId2, bi, item, blobRawId, pending);
         }
       }
     }
@@ -4215,18 +4110,21 @@ async function compileCursorStore(bundle, batch, store, logger) {
     counts.tool_calls = pending.toolCallsList.length;
     counts.tool_results = pending.toolResults.length;
     counts.artifacts = pending.artifacts.length;
-    logger?.debug(
-      { path: store.filePath, source_file_id: sourceFile.source_file_id, counts },
-      "cursor store imported"
-    );
+    logger?.debug({
+      path: store.filePath,
+      source_file_id: sourceFile.source_file_id,
+      counts
+    }, "cursor store imported");
     return counts;
   } finally {
     cdb.close();
   }
 }
+__name(compileCursorStore, "compileCursorStore");
 function hexToUtf8(hex) {
   return Buffer.from(hex, "hex").toString("utf8");
 }
+__name(hexToUtf8, "hexToUtf8");
 function mapRole(role) {
   switch (role) {
     case "user":
@@ -4241,6 +4139,7 @@ function mapRole(role) {
       return "operational";
   }
 }
+__name(mapRole, "mapRole");
 async function pushTextBlock(bundle, pending, messageId2, ordinal, blockType, text, rawRecordId2, visibility = "default") {
   if (!text) return;
   const overflow = text.length > PREVIEW_MAX3 ? stageText(pending.objects, text) : null;
@@ -4257,6 +4156,7 @@ async function pushTextBlock(bundle, pending, messageId2, ordinal, blockType, te
     raw_record_id: rawRecordId2
   });
 }
+__name(pushTextBlock, "pushTextBlock");
 async function processContentItem(bundle, sessionId2, messageId2, eventId2, ordinal, item, rawRecordId2, pending) {
   const t = item.type;
   if (t === "text") {
@@ -4264,16 +4164,7 @@ async function processContentItem(bundle, sessionId2, messageId2, eventId2, ordi
     return;
   }
   if (t === "reasoning") {
-    await pushTextBlock(
-      bundle,
-      pending,
-      messageId2,
-      ordinal,
-      "thinking",
-      item.text ?? "",
-      rawRecordId2,
-      "hidden_by_default"
-    );
+    await pushTextBlock(bundle, pending, messageId2, ordinal, "thinking", item.text ?? "", rawRecordId2, "hidden_by_default");
     return;
   }
   if (t === "redacted-reasoning") {
@@ -4374,11 +4265,13 @@ async function processContentItem(bundle, sessionId2, messageId2, eventId2, ordi
     raw_record_id: rawRecordId2
   });
 }
+__name(processContentItem, "processContentItem");
 function readIsError(item) {
   const exp = item.experimental_content;
   if (exp && typeof exp.isError === "boolean") return exp.isError;
   return false;
 }
+__name(readIsError, "readIsError");
 function canonicalToolType3(toolName) {
   const lower = toolName.toLowerCase();
   if (lower.startsWith("mcp__")) return "mcp";
@@ -4395,6 +4288,7 @@ function canonicalToolType3(toolName) {
   if (lower === "applypatch" || lower === "apply_patch") return "patch";
   return "other";
 }
+__name(canonicalToolType3, "canonicalToolType");
 function stringifyOrNull3(value) {
   if (value == null) return null;
   if (typeof value === "string") return value;
@@ -4404,6 +4298,7 @@ function stringifyOrNull3(value) {
     return null;
   }
 }
+__name(stringifyOrNull3, "stringifyOrNull");
 function buildSearchDocs3(pending) {
   const sessionId2 = pending.session?.session_id ?? null;
   if (!sessionId2) return;
@@ -4460,193 +4355,74 @@ function buildSearchDocs3(pending) {
     }
   }
 }
+__name(buildSearchDocs3, "buildSearchDocs");
 function flushPending3(bundle, pending) {
   if (!pending.session) return;
-  const insertRaw = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO raw_records (
+  const insertRaw = prepare(bundle.db, `INSERT OR IGNORE INTO raw_records (
        raw_record_id, source_file_id, source_tool, record_kind, ordinal,
        line_no, json_pointer, native_id, raw_object_id, decoded_json_object_id,
        parser_status, confidence, import_batch_id
-     ) VALUES (?, ?, 'cursor', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, 'cursor', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.rawRecords) {
-    insertRaw.run(
-      r.raw_record_id,
-      r.source_file_id,
-      r.record_kind,
-      r.ordinal,
-      r.line_no,
-      r.json_pointer,
-      r.native_id,
-      r.raw_object_id,
-      r.decoded_json_object_id,
-      r.parser_status,
-      r.confidence,
-      r.import_batch_id
-    );
+    insertRaw.run(r.raw_record_id, r.source_file_id, r.record_kind, r.ordinal, r.line_no, r.json_pointer, r.native_id, r.raw_object_id, r.decoded_json_object_id, r.parser_status, r.confidence, r.import_batch_id);
   }
-  prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO sessions (
+  prepare(bundle.db, `INSERT OR REPLACE INTO sessions (
        session_id, source_tool, source_session_id, project_id, parent_session_id,
        is_subagent, agent_role, agent_nickname, title, summary,
        start_ts, end_ts, cwd_initial, git_branch_initial,
        model_first, model_last, status, timeline_confidence, raw_record_id
-     ) VALUES (?, 'cursor', ?, NULL, NULL, 0, ?, ?, ?, NULL, ?, NULL, NULL, NULL, ?, ?, NULL, 'low', ?)`
-  ).run(
-    pending.session.session_id,
-    pending.session.source_session_id,
-    pending.session.agent_role,
-    pending.session.agent_nickname,
-    pending.session.title,
-    pending.session.start_ts,
-    pending.session.model,
-    pending.session.model,
-    pending.session.raw_record_id
-  );
-  const insertEvent = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO events (
+     ) VALUES (?, 'cursor', ?, NULL, NULL, 0, ?, ?, ?, NULL, ?, NULL, NULL, NULL, ?, ?, NULL, 'low', ?)`).run(pending.session.session_id, pending.session.source_session_id, pending.session.agent_role, pending.session.agent_nickname, pending.session.title, pending.session.start_ts, pending.session.model, pending.session.model, pending.session.raw_record_id);
+  const insertEvent = prepare(bundle.db, `INSERT OR REPLACE INTO events (
        event_id, session_id, turn_id, source_event_id, event_type, source_type,
        subtype, timestamp, ordinal, actor, payload_object_id, raw_record_id,
        confidence, is_derived
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`);
   for (const e of pending.events) {
-    insertEvent.run(
-      e.event_id,
-      pending.session.session_id,
-      e.source_event_id,
-      e.event_type,
-      e.source_type,
-      e.subtype,
-      e.timestamp,
-      e.ordinal,
-      e.actor,
-      e.payload_object_id,
-      e.raw_record_id,
-      e.confidence
-    );
+    insertEvent.run(e.event_id, pending.session.session_id, e.source_event_id, e.event_type, e.source_type, e.subtype, e.timestamp, e.ordinal, e.actor, e.payload_object_id, e.raw_record_id, e.confidence);
   }
-  const insertMsg = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO messages (
+  const insertMsg = prepare(bundle.db, `INSERT OR REPLACE INTO messages (
        message_id, session_id, turn_id, event_id, source_message_id, role,
        author_name, model, timestamp, ordinal, parent_message_id, request_id,
        status, raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`);
   for (const m of pending.messages) {
-    insertMsg.run(
-      m.message_id,
-      pending.session.session_id,
-      m.event_id,
-      m.source_message_id,
-      m.role,
-      m.model,
-      m.timestamp,
-      m.ordinal,
-      m.raw_record_id
-    );
+    insertMsg.run(m.message_id, pending.session.session_id, m.event_id, m.source_message_id, m.role, m.model, m.timestamp, m.ordinal, m.raw_record_id);
   }
-  const insertBlock = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO content_blocks (
+  const insertBlock = prepare(bundle.db, `INSERT OR REPLACE INTO content_blocks (
        block_id, message_id, event_id, session_id, ordinal, block_type,
        text_object_id, text_inline, mime_type, token_count, is_error,
        is_redacted, visibility, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 0, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 0, ?, ?)`);
   for (const b of pending.blocks) {
-    insertBlock.run(
-      b.block_id,
-      b.message_id,
-      b.event_id,
-      pending.session.session_id,
-      b.ordinal,
-      b.block_type,
-      b.text_object_id,
-      b.text_inline,
-      b.is_error,
-      b.visibility,
-      b.raw_record_id
-    );
+    insertBlock.run(b.block_id, b.message_id, b.event_id, pending.session.session_id, b.ordinal, b.block_type, b.text_object_id, b.text_inline, b.is_error, b.visibility, b.raw_record_id);
   }
-  const insertCall = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_calls (
+  const insertCall = prepare(bundle.db, `INSERT OR REPLACE INTO tool_calls (
        tool_call_id, session_id, turn_id, message_id, event_id,
        source_call_id, tool_name, canonical_tool_type, args_object_id,
        command, cwd, path, query, timestamp_start, timestamp_end, status,
        raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`);
   for (const c of pending.toolCallsList) {
-    insertCall.run(
-      c.tool_call_id,
-      pending.session.session_id,
-      c.message_id,
-      c.event_id,
-      c.source_call_id,
-      c.tool_name,
-      c.canonical_tool_type,
-      c.args_object_id,
-      c.command,
-      c.cwd,
-      c.path,
-      c.query,
-      c.timestamp_start,
-      c.status,
-      c.raw_record_id
-    );
+    insertCall.run(c.tool_call_id, pending.session.session_id, c.message_id, c.event_id, c.source_call_id, c.tool_name, c.canonical_tool_type, c.args_object_id, c.command, c.cwd, c.path, c.query, c.timestamp_start, c.status, c.raw_record_id);
   }
-  const insertResult = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_results (
+  const insertResult = prepare(bundle.db, `INSERT OR REPLACE INTO tool_results (
        tool_result_id, tool_call_id, session_id, message_id, event_id,
        source_call_id, status, is_error, exit_code, duration_ms,
        stdout_object_id, stderr_object_id, output_object_id, preview, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, ?, ?, ?)`);
   for (const r of pending.toolResults) {
-    insertResult.run(
-      r.tool_result_id,
-      r.tool_call_id,
-      pending.session.session_id,
-      r.message_id,
-      r.event_id,
-      r.source_call_id,
-      r.status,
-      r.is_error,
-      r.output_object_id,
-      r.preview,
-      r.raw_record_id
-    );
+    insertResult.run(r.tool_result_id, r.tool_call_id, pending.session.session_id, r.message_id, r.event_id, r.source_call_id, r.status, r.is_error, r.output_object_id, r.preview, r.raw_record_id);
   }
-  const insertSearch = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO search_docs (
+  const insertSearch = prepare(bundle.db, `INSERT OR REPLACE INTO search_docs (
        doc_id, entity_type, entity_id, session_id, project_id, timestamp,
        role, tool_name, canonical_tool_type, field_kind, text
-     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`);
   for (const d of pending.searchDocs) {
-    insertSearch.run(
-      d.doc_id,
-      d.entity_type,
-      d.entity_id,
-      pending.session.session_id,
-      d.timestamp,
-      d.role,
-      d.tool_name,
-      d.canonical_tool_type,
-      d.field_kind,
-      d.text
-    );
+    insertSearch.run(d.doc_id, d.entity_type, d.entity_id, pending.session.session_id, d.timestamp, d.role, d.tool_name, d.canonical_tool_type, d.field_kind, d.text);
   }
   void artifactId;
 }
+__name(flushPending3, "flushPending");
 
 // src/importers/gemini/index.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -4674,6 +4450,7 @@ async function* discoverGeminiChats(root) {
     }
   }
 }
+__name(discoverGeminiChats, "discoverGeminiChats");
 async function readProjectRoot(dir) {
   try {
     const text = await readFile6(path11.join(dir, ".project_root"), "utf8");
@@ -4682,60 +4459,76 @@ async function readProjectRoot(dir) {
     return null;
   }
 }
+__name(readProjectRoot, "readProjectRoot");
 async function readdirSafe3(dir) {
   try {
-    return await readdir4(dir, { withFileTypes: true });
+    return await readdir4(dir, {
+      withFileTypes: true
+    });
   } catch {
     return [];
   }
 }
+__name(readdirSafe3, "readdirSafe");
 
 // src/importers/gemini/index.ts
 var PREVIEW_MAX4 = 4e3;
 async function compileGemini(bundle, root, options = {}) {
   const logger = options.logger;
-  const batch = startBatch(bundle, "gemini", [root]);
+  const batch = startBatch(bundle, "gemini", [
+    root
+  ]);
   const counts = emptyCounts();
-  logger?.info({ batch_id: batch.batch_id, root }, "gemini batch started");
+  logger?.info({
+    batch_id: batch.batch_id,
+    root
+  }, "gemini batch started");
   try {
     for await (const file of discoverGeminiChats(root)) {
       counts.source_files_seen++;
-      logger?.debug(
-        {
-          path: file.filePath,
-          project_dir: file.projectDir,
-          project_root: file.projectRoot
-        },
-        "gemini source file discovered"
-      );
+      logger?.debug({
+        path: file.filePath,
+        project_dir: file.projectDir,
+        project_root: file.projectRoot
+      }, "gemini source file discovered");
       try {
         const fc = await compileGeminiFile(bundle, batch, file, logger);
         addCounts4(counts, fc);
       } catch (error) {
         counts.errors++;
-        logger?.warn(
-          {
-            err: error,
-            path: file.filePath
-          },
-          "gemini source file failed"
-        );
+        logger?.warn({
+          err: error,
+          path: file.filePath
+        }, "gemini source file failed");
         await recordError(bundle, batch.batch_id, {
           kind: "gemini_file_failed",
           message: getErrorMessage(error),
-          payload: { path: file.filePath }
+          payload: {
+            path: file.filePath
+          }
         });
       }
     }
     finishBatch(bundle, batch, counts, "completed");
-    logger?.info({ batch_id: batch.batch_id, counts }, "gemini batch completed");
+    logger?.info({
+      batch_id: batch.batch_id,
+      counts
+    }, "gemini batch completed");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
-    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "gemini batch failed");
+    logger?.error({
+      err: error,
+      batch_id: batch.batch_id,
+      counts
+    }, "gemini batch failed");
     throw error;
   }
-  return { batch, counts };
+  return {
+    batch,
+    counts
+  };
 }
+__name(compileGemini, "compileGemini");
 function emptyFileCounts4() {
   return {
     source_files_imported: 0,
@@ -4752,6 +4545,7 @@ function emptyFileCounts4() {
     errors: 0
   };
 }
+__name(emptyFileCounts4, "emptyFileCounts");
 function addCounts4(target, source) {
   target.source_files_imported += source.source_files_imported;
   target.source_files_skipped += source.source_files_skipped;
@@ -4766,6 +4560,7 @@ function addCounts4(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
+__name(addCounts4, "addCounts");
 async function compileGeminiFile(bundle, batch, file, logger) {
   const counts = emptyFileCounts4();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
@@ -4776,17 +4571,17 @@ async function compileGeminiFile(bundle, batch, file, logger) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
-    logger?.debug(
-      { path: file.filePath, source_file_id: sourceFile.source_file_id },
-      "gemini source file skipped"
-    );
+    logger?.debug({
+      path: file.filePath,
+      source_file_id: sourceFile.source_file_id
+    }, "gemini source file skipped");
     return counts;
   }
   counts.source_files_imported = 1;
-  logger?.debug(
-    { path: file.filePath, source_file_id: sourceFile.source_file_id },
-    "gemini source file registered"
-  );
+  logger?.debug({
+    path: file.filePath,
+    source_file_id: sourceFile.source_file_id
+  }, "gemini source file registered");
   const text = await readFile7(file.filePath, "utf8");
   const parsed = JSON.parse(text);
   const objects = createPendingObjects();
@@ -4847,15 +4642,7 @@ async function compileGeminiFile(bundle, batch, file, logger) {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
     if (!msg) continue;
-    await processMessage(
-      bundle,
-      sessionPk,
-      sourceFile.source_file_id,
-      i,
-      msg,
-      batch.batch_id,
-      pending
-    );
+    await processMessage(bundle, sessionPk, sourceFile.source_file_id, i, msg, batch.batch_id, pending);
   }
   buildSearchDocs4(pending);
   await flushPendingObjects(bundle, pending.objects);
@@ -4870,12 +4657,14 @@ async function compileGeminiFile(bundle, batch, file, logger) {
   counts.tool_calls = pending.toolCallsList.length;
   counts.tool_results = pending.toolResults.length;
   counts.artifacts = pending.artifacts.length;
-  logger?.debug(
-    { path: file.filePath, source_file_id: sourceFile.source_file_id, counts },
-    "gemini source file imported"
-  );
+  logger?.debug({
+    path: file.filePath,
+    source_file_id: sourceFile.source_file_id,
+    counts
+  }, "gemini source file imported");
   return counts;
 }
+__name(compileGeminiFile, "compileGeminiFile");
 async function processMessage(bundle, sessionId2, sourceFileId2, index, msg, batchId, pending) {
   const ordinal = index + 1;
   const ts = msg.timestamp ?? null;
@@ -4943,17 +4732,11 @@ ${JSON.stringify(msg)}`);
     for (let i = 0; i < thoughts.length; i++) {
       const th = thoughts[i];
       if (!th) continue;
-      const text = [th.subject, th.description].filter(Boolean).join("\n\n");
-      await pushTextBlock2(
-        bundle,
-        pending,
-        messageId2,
-        100 + i,
-        "thinking",
-        text,
-        rawRecordId2,
-        "hidden_by_default"
-      );
+      const text = [
+        th.subject,
+        th.description
+      ].filter(Boolean).join("\n\n");
+      await pushTextBlock2(bundle, pending, messageId2, 100 + i, "thinking", text, rawRecordId2, "hidden_by_default");
     }
     const toolCalls = Array.isArray(msg.toolCalls) ? msg.toolCalls : [];
     for (let i = 0; i < toolCalls.length; i++) {
@@ -4994,6 +4777,7 @@ ${JSON.stringify(msg)}`);
     confidence: "high"
   });
 }
+__name(processMessage, "processMessage");
 async function pushTextBlock2(bundle, pending, messageId2, blockOrdinal, blockType, text, rawRecordId2, visibility = "default") {
   if (!text) return;
   const overflowId = text.length > PREVIEW_MAX4 ? stageText(pending.objects, text) : null;
@@ -5009,6 +4793,7 @@ async function pushTextBlock2(bundle, pending, messageId2, blockOrdinal, blockTy
     raw_record_id: rawRecordId2
   });
 }
+__name(pushTextBlock2, "pushTextBlock");
 async function processToolCall(bundle, sessionId2, messageId2, eventId2, index, tc, rawRecordId2, pending) {
   const sourceCallId = tc.id ?? `${messageId2}:${index}`;
   const toolName = tc.name ?? "unknown";
@@ -5049,7 +4834,9 @@ async function processToolCall(bundle, sessionId2, messageId2, eventId2, index,
     const rd = tc.resultDisplay;
     if (rd.fileDiff || rd.filePath) {
       const diffText = rd.fileDiff ?? "";
-      const diffId = diffText ? stageText(pending.objects, diffText, { mimeType: "text/x-diff" }) : null;
+      const diffId = diffText ? stageText(pending.objects, diffText, {
+        mimeType: "text/x-diff"
+      }) : null;
       pending.artifacts.push({
         artifact_id: artifactId(sessionId2, "gemini", `${toolCallId2}:diff`),
         kind: "diff",
@@ -5065,6 +4852,7 @@ async function processToolCall(bundle, sessionId2, messageId2, eventId2, index,
     }
   }
 }
+__name(processToolCall, "processToolCall");
 function renderToolResultText(result) {
   if (!Array.isArray(result)) return "";
   const parts = [];
@@ -5075,14 +4863,13 @@ function renderToolResultText(result) {
     }
     if (r.functionResponse?.response) {
       const rr = r.functionResponse.response;
-      if (rr.error != null)
-        parts.push(typeof rr.error === "string" ? rr.error : JSON.stringify(rr.error));
-      else if (rr.output != null)
-        parts.push(typeof rr.output === "string" ? rr.output : JSON.stringify(rr.output));
+      if (rr.error != null) parts.push(typeof rr.error === "string" ? rr.error : JSON.stringify(rr.error));
+      else if (rr.output != null) parts.push(typeof rr.output === "string" ? rr.output : JSON.stringify(rr.output));
     }
   }
   return parts.join("\n");
 }
+__name(renderToolResultText, "renderToolResultText");
 function canonicalToolType4(toolName) {
   switch (toolName) {
     case "run_shell_command":
@@ -5110,6 +4897,7 @@ function canonicalToolType4(toolName) {
       return toolName.startsWith("mcp__") ? "mcp" : "other";
   }
 }
+__name(canonicalToolType4, "canonicalToolType");
 function buildSearchDocs4(pending) {
   const sessionId2 = pending.session?.session_id ?? null;
   if (!sessionId2) return;
@@ -5179,230 +4967,87 @@ function buildSearchDocs4(pending) {
     });
   }
 }
+__name(buildSearchDocs4, "buildSearchDocs");
 function flushPending4(bundle, pending) {
   if (!pending.session) return;
-  const insertRaw = prepare(
-    bundle.db,
-    `INSERT OR IGNORE INTO raw_records (
+  const insertRaw = prepare(bundle.db, `INSERT OR IGNORE INTO raw_records (
        raw_record_id, source_file_id, source_tool, record_kind, ordinal,
        line_no, json_pointer, native_id, raw_object_id, decoded_json_object_id,
        parser_status, confidence, import_batch_id
-     ) VALUES (?, ?, 'gemini', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, 'gemini', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const r of pending.rawRecords) {
-    insertRaw.run(
-      r.raw_record_id,
-      r.source_file_id,
-      r.record_kind,
-      r.ordinal,
-      r.line_no,
-      r.json_pointer,
-      r.native_id,
-      r.raw_object_id,
-      r.decoded_json_object_id,
-      r.parser_status,
-      r.confidence,
-      r.import_batch_id
-    );
+    insertRaw.run(r.raw_record_id, r.source_file_id, r.record_kind, r.ordinal, r.line_no, r.json_pointer, r.native_id, r.raw_object_id, r.decoded_json_object_id, r.parser_status, r.confidence, r.import_batch_id);
   }
   if (pending.project) {
-    prepare(
-      bundle.db,
-      `INSERT OR IGNORE INTO projects (
+    prepare(bundle.db, `INSERT OR IGNORE INTO projects (
          project_id, canonical_path, path_hash, source_tool, source_project_id,
          display_name, created_at
-       ) VALUES (?, ?, ?, 'gemini', ?, NULL, ?)`
-    ).run(
-      pending.project.project_id,
-      pending.project.canonical_path,
-      pending.project.canonical_path ? sha256Hex(pending.project.canonical_path).slice(0, 32) : null,
-      pending.project.source_project_id,
-      (/* @__PURE__ */ new Date()).toISOString()
-    );
+       ) VALUES (?, ?, ?, 'gemini', ?, NULL, ?)`).run(pending.project.project_id, pending.project.canonical_path, pending.project.canonical_path ? sha256Hex(pending.project.canonical_path).slice(0, 32) : null, pending.project.source_project_id, (/* @__PURE__ */ new Date()).toISOString());
   }
-  prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO sessions (
+  prepare(bundle.db, `INSERT OR REPLACE INTO sessions (
        session_id, source_tool, source_session_id, project_id, parent_session_id,
        is_subagent, agent_role, agent_nickname, title, summary,
        start_ts, end_ts, cwd_initial, git_branch_initial,
        model_first, model_last, status, timeline_confidence, raw_record_id
-     ) VALUES (?, 'gemini', ?, ?, NULL, 0, NULL, NULL, ?, NULL, ?, ?, ?, NULL, NULL, NULL, 'completed', 'high', ?)`
-  ).run(
-    pending.session.session_id,
-    pending.session.source_session_id,
-    pending.project?.project_id ?? null,
-    pending.session.title,
-    pending.session.start_ts,
-    pending.session.end_ts,
-    pending.session.cwd_initial,
-    pending.session.raw_record_id
-  );
-  const insertEvent = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO events (
+     ) VALUES (?, 'gemini', ?, ?, NULL, 0, NULL, NULL, ?, NULL, ?, ?, ?, NULL, NULL, NULL, 'completed', 'high', ?)`).run(pending.session.session_id, pending.session.source_session_id, pending.project?.project_id ?? null, pending.session.title, pending.session.start_ts, pending.session.end_ts, pending.session.cwd_initial, pending.session.raw_record_id);
+  const insertEvent = prepare(bundle.db, `INSERT OR REPLACE INTO events (
        event_id, session_id, turn_id, source_event_id, event_type, source_type,
        subtype, timestamp, ordinal, actor, payload_object_id, raw_record_id,
        confidence, is_derived
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)`);
   for (const e of pending.events) {
-    insertEvent.run(
-      e.event_id,
-      pending.session.session_id,
-      e.source_event_id,
-      e.event_type,
-      e.source_type,
-      e.subtype,
-      e.timestamp,
-      e.ordinal,
-      e.actor,
-      e.payload_object_id,
-      e.raw_record_id,
-      e.confidence
-    );
+    insertEvent.run(e.event_id, pending.session.session_id, e.source_event_id, e.event_type, e.source_type, e.subtype, e.timestamp, e.ordinal, e.actor, e.payload_object_id, e.raw_record_id, e.confidence);
   }
-  const insertMsg = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO messages (
+  const insertMsg = prepare(bundle.db, `INSERT OR REPLACE INTO messages (
        message_id, session_id, turn_id, event_id, source_message_id, role,
        author_name, model, timestamp, ordinal, parent_message_id, request_id,
        status, raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`);
   for (const m of pending.messages) {
-    insertMsg.run(
-      m.message_id,
-      pending.session.session_id,
-      m.event_id,
-      m.source_message_id,
-      m.role,
-      m.model,
-      m.timestamp,
-      m.ordinal,
-      m.raw_record_id
-    );
+    insertMsg.run(m.message_id, pending.session.session_id, m.event_id, m.source_message_id, m.role, m.model, m.timestamp, m.ordinal, m.raw_record_id);
   }
-  const insertBlock = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO content_blocks (
+  const insertBlock = prepare(bundle.db, `INSERT OR REPLACE INTO content_blocks (
        block_id, message_id, event_id, session_id, ordinal, block_type,
        text_object_id, text_inline, mime_type, token_count, is_error,
        is_redacted, visibility, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, 0, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, 0, ?, ?)`);
   for (const b of pending.blocks) {
-    insertBlock.run(
-      b.block_id,
-      b.message_id,
-      b.event_id,
-      pending.session.session_id,
-      b.ordinal,
-      b.block_type,
-      b.text_object_id,
-      b.text_inline,
-      b.visibility,
-      b.raw_record_id
-    );
+    insertBlock.run(b.block_id, b.message_id, b.event_id, pending.session.session_id, b.ordinal, b.block_type, b.text_object_id, b.text_inline, b.visibility, b.raw_record_id);
   }
-  const insertCall = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_calls (
+  const insertCall = prepare(bundle.db, `INSERT OR REPLACE INTO tool_calls (
        tool_call_id, session_id, turn_id, message_id, event_id,
        source_call_id, tool_name, canonical_tool_type, args_object_id,
        command, cwd, path, query, timestamp_start, timestamp_end, status,
        raw_record_id
-     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
-  );
+     ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`);
   for (const c of pending.toolCallsList) {
-    insertCall.run(
-      c.tool_call_id,
-      pending.session.session_id,
-      c.message_id,
-      c.event_id,
-      c.source_call_id,
-      c.tool_name,
-      c.canonical_tool_type,
-      c.args_object_id,
-      c.command,
-      c.cwd,
-      c.path,
-      c.query,
-      c.timestamp_start,
-      c.status,
-      c.raw_record_id
-    );
+    insertCall.run(c.tool_call_id, pending.session.session_id, c.message_id, c.event_id, c.source_call_id, c.tool_name, c.canonical_tool_type, c.args_object_id, c.command, c.cwd, c.path, c.query, c.timestamp_start, c.status, c.raw_record_id);
   }
-  const insertResult = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO tool_results (
+  const insertResult = prepare(bundle.db, `INSERT OR REPLACE INTO tool_results (
        tool_result_id, tool_call_id, session_id, message_id, event_id,
        source_call_id, status, is_error, exit_code, duration_ms,
        stdout_object_id, stderr_object_id, output_object_id, preview, raw_record_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, ?, ?, ?)`);
   for (const r of pending.toolResults) {
-    insertResult.run(
-      r.tool_result_id,
-      r.tool_call_id,
-      pending.session.session_id,
-      r.message_id,
-      r.event_id,
-      r.source_call_id,
-      r.status,
-      r.is_error,
-      r.output_object_id,
-      r.preview,
-      r.raw_record_id
-    );
+    insertResult.run(r.tool_result_id, r.tool_call_id, pending.session.session_id, r.message_id, r.event_id, r.source_call_id, r.status, r.is_error, r.output_object_id, r.preview, r.raw_record_id);
   }
-  const insertArtifact = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO artifacts (
+  const insertArtifact = prepare(bundle.db, `INSERT OR REPLACE INTO artifacts (
        artifact_id, session_id, project_id, source_tool, kind, path,
        logical_path, object_id, text_object_id, mime_type, size_bytes,
        created_ts, raw_record_id
-     ) VALUES (?, ?, ?, 'gemini', ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, 'gemini', ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const a of pending.artifacts) {
-    insertArtifact.run(
-      a.artifact_id,
-      pending.session.session_id,
-      pending.project?.project_id ?? null,
-      a.kind,
-      a.path,
-      a.logical_path,
-      a.object_id,
-      a.text_object_id,
-      a.mime_type,
-      a.size_bytes,
-      a.created_ts,
-      a.raw_record_id
-    );
+    insertArtifact.run(a.artifact_id, pending.session.session_id, pending.project?.project_id ?? null, a.kind, a.path, a.logical_path, a.object_id, a.text_object_id, a.mime_type, a.size_bytes, a.created_ts, a.raw_record_id);
   }
-  const insertSearch = prepare(
-    bundle.db,
-    `INSERT OR REPLACE INTO search_docs (
+  const insertSearch = prepare(bundle.db, `INSERT OR REPLACE INTO search_docs (
        doc_id, entity_type, entity_id, session_id, project_id, timestamp,
        role, tool_name, canonical_tool_type, field_kind, text
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
   for (const d of pending.searchDocs) {
-    insertSearch.run(
-      d.doc_id,
-      d.entity_type,
-      d.entity_id,
-      pending.session.session_id,
-      pending.project?.project_id ?? null,
-      d.timestamp,
-      d.role,
-      d.tool_name,
-      d.canonical_tool_type,
-      d.field_kind,
-      d.text
-    );
+    insertSearch.run(d.doc_id, d.entity_type, d.entity_id, pending.session.session_id, pending.project?.project_id ?? null, d.timestamp, d.role, d.tool_name, d.canonical_tool_type, d.field_kind, d.text);
   }
 }
+__name(flushPending4, "flushPending");
 
 // src/services/export/parquet.ts
 import { mkdir as mkdir4, rm as rm2, writeFile as writeFile5 } from "fs/promises";
@@ -5437,21 +5082,27 @@ var ANALYTICS_VIEWS = [
 async function exportBundleParquet(options) {
   const snapshot = await openBundleSnapshot(options.bundlePath);
   const outDir = path13.resolve(options.outDir ?? snapshot.defaultOutDir);
-  await mkdir4(outDir, { recursive: true });
-  const files = Object.fromEntries(
-    PARQUET_TABLES.map((table) => [table, path13.join(outDir, `${table}.parquet`)])
-  );
+  await mkdir4(outDir, {
+    recursive: true
+  });
+  const files = Object.fromEntries(PARQUET_TABLES.map((table) => [
+    table,
+    path13.join(outDir, `${table}.parquet`)
+  ]));
   const manifestPath = path13.join(outDir, "manifest.json");
-  for (const file of [...Object.values(files), manifestPath]) {
-    await rm2(file, { force: true });
+  for (const file of [
+    ...Object.values(files),
+    manifestPath
+  ]) {
+    await rm2(file, {
+      force: true
+    });
   }
   const connection = await createDuckDbConnection();
   try {
     await attachSqlite(connection, snapshot.dbPath);
     for (const table of PARQUET_TABLES) {
-      await connection.run(
-        `COPY (SELECT * FROM prosa.${quoteIdentifier(table)}) TO ${sqlString(files[table])} (FORMAT parquet, COMPRESSION zstd, COMPRESSION_LEVEL 1, ROW_GROUP_SIZE 100000)`
-      );
+      await connection.run(`COPY (SELECT * FROM prosa.${quoteIdentifier(table)}) TO ${sqlString(files[table])} (FORMAT parquet, COMPRESSION zstd, COMPRESSION_LEVEL 1, ROW_GROUP_SIZE 100000)`);
     }
   } finally {
     connection.closeSync();
@@ -5461,30 +5112,30 @@ async function exportBundleParquet(options) {
     source_db: snapshot.dbPath,
     schema_version: snapshot.schemaVersion,
     parser_version: snapshot.parserVersion,
-    tables: Object.fromEntries(
-      PARQUET_TABLES.map((table) => [
-        table,
-        {
-          file: path13.basename(files[table]),
-          rows: snapshot.counts[table]
-        }
-      ])
-    )
+    tables: Object.fromEntries(PARQUET_TABLES.map((table) => [
+      table,
+      {
+        file: path13.basename(files[table]),
+        rows: snapshot.counts[table]
+      }
+    ]))
   };
   await writeFile5(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  return { outDir, manifestPath, files, counts: snapshot.counts };
+  return {
+    outDir,
+    manifestPath,
+    files,
+    counts: snapshot.counts
+  };
 }
+__name(exportBundleParquet, "exportBundleParquet");
 async function queryDuckDbParquet(options) {
   const parquetDir = path13.resolve(options.parquetDir);
   const connection = await createDuckDbConnection();
   try {
     for (const table of PARQUET_TABLES) {
-      await connection.run(
-        `CREATE OR REPLACE VIEW ${quoteIdentifier(table)} AS SELECT * FROM read_parquet(${sqlString(
-          path13.join(parquetDir, `${table}.parquet`)
-        )})`
-      );
+      await connection.run(`CREATE OR REPLACE VIEW ${quoteIdentifier(table)} AS SELECT * FROM read_parquet(${sqlString(path13.join(parquetDir, `${table}.parquet`))})`);
     }
     await createAnalyticsViews(connection);
     const reader = await connection.runAndReadAll(options.sql);
@@ -5494,29 +5145,28 @@ async function queryDuckDbParquet(options) {
     };
   } catch (error) {
     if (isMissingParquetError(error)) {
-      throw new Error(
-        `Parquet export not found in ${parquetDir}; run \`prosa export parquet --store <path>\` first`
-      );
+      throw new Error(`Parquet export not found in ${parquetDir}; run \`prosa export parquet --store <path>\` first`);
     }
     throw error;
   } finally {
     connection.closeSync();
   }
 }
+__name(queryDuckDbParquet, "queryDuckDbParquet");
 async function createDuckDbConnection() {
   return DuckDBConnection.create();
 }
+__name(createDuckDbConnection, "createDuckDbConnection");
 async function attachSqlite(connection, dbPath) {
   try {
     await connection.run("INSTALL sqlite");
     await connection.run("LOAD sqlite");
     await connection.run(`ATTACH ${sqlString(dbPath)} AS prosa (TYPE sqlite)`);
   } catch (error) {
-    throw new Error(
-      `DuckDB could not attach prosa.sqlite via the sqlite extension: ${getErrorMessage(error)}`
-    );
+    throw new Error(`DuckDB could not attach prosa.sqlite via the sqlite extension: ${getErrorMessage(error)}`);
   }
 }
+__name(attachSqlite, "attachSqlite");
 async function createAnalyticsViews(connection) {
   await connection.run(`
     CREATE OR REPLACE VIEW session_facts AS
@@ -5796,15 +5446,17 @@ async function createAnalyticsViews(connection) {
      GROUP BY s.source_tool, s.project_id, p.display_name, s.cwd_initial, p.canonical_path
   `);
 }
+__name(createAnalyticsViews, "createAnalyticsViews");
 async function openBundleSnapshot(bundlePath) {
   const bundle = await openBundle(bundlePath);
   try {
-    const counts = Object.fromEntries(
-      PARQUET_TABLES.map((table) => {
-        const row = bundle.db.prepare(`SELECT count(*) AS n FROM ${quoteIdentifier(table)}`).get();
-        return [table, row?.n ?? 0];
-      })
-    );
+    const counts = Object.fromEntries(PARQUET_TABLES.map((table) => {
+      const row = bundle.db.prepare(`SELECT count(*) AS n FROM ${quoteIdentifier(table)}`).get();
+      return [
+        table,
+        row?.n ?? 0
+      ];
+    }));
     return {
       dbPath: bundle.paths.db,
       schemaVersion: bundle.manifest.schema_version,
@@ -5816,16 +5468,20 @@ async function openBundleSnapshot(bundlePath) {
     closeBundle(bundle);
   }
 }
+__name(openBundleSnapshot, "openBundleSnapshot");
 function quoteIdentifier(value) {
   return `"${value.replace(/"/g, '""')}"`;
 }
+__name(quoteIdentifier, "quoteIdentifier");
 function sqlString(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
+__name(sqlString, "sqlString");
 function isMissingParquetError(error) {
   const message = getErrorMessage(error);
   return /No files found|does not exist|not found/i.test(message) && /\.parquet/i.test(message);
 }
+__name(isMissingParquetError, "isMissingParquetError");
 
 // src/services/compile.ts
 var COMPILE_PROVIDERS = [
@@ -5833,28 +5489,28 @@ var COMPILE_PROVIDERS = [
     name: "codex",
     description: "Import Codex CLI session histories into the bundle.",
     pathHelp: "root of Codex CLI sessions",
-    defaultSessionsPath: () => path14.join(os2.homedir(), ".codex", "sessions"),
+    defaultSessionsPath: /* @__PURE__ */ __name(() => path14.join(os2.homedir(), ".codex", "sessions"), "defaultSessionsPath"),
     compile: compileCodex
   },
   {
     name: "claude",
     description: "Import Claude Code project histories into the bundle.",
     pathHelp: "root of Claude Code projects",
-    defaultSessionsPath: () => path14.join(os2.homedir(), ".claude", "projects"),
+    defaultSessionsPath: /* @__PURE__ */ __name(() => path14.join(os2.homedir(), ".claude", "projects"), "defaultSessionsPath"),
     compile: compileClaude
   },
   {
     name: "gemini",
     description: "Import Gemini CLI session histories into the bundle.",
     pathHelp: "root of Gemini CLI tmp dir",
-    defaultSessionsPath: () => path14.join(os2.homedir(), ".gemini", "tmp"),
+    defaultSessionsPath: /* @__PURE__ */ __name(() => path14.join(os2.homedir(), ".gemini", "tmp"), "defaultSessionsPath"),
     compile: compileGemini
   },
   {
     name: "cursor",
     description: "Import Cursor agent stores into the bundle.",
     pathHelp: "root of Cursor agent stores",
-    defaultSessionsPath: () => path14.join(os2.homedir(), ".cursor", "chats"),
+    defaultSessionsPath: /* @__PURE__ */ __name(() => path14.join(os2.homedir(), ".cursor", "chats"), "defaultSessionsPath"),
     compile: compileCursor
   }
 ];
@@ -5865,11 +5521,13 @@ function getCompileProvider(source) {
   }
   return provider;
 }
+__name(getCompileProvider, "getCompileProvider");
 function resolveCompilePath(p) {
   if (p === "~") return os2.homedir();
   if (p.startsWith("~/")) return path14.join(os2.homedir(), p.slice(2));
   return path14.resolve(p);
 }
+__name(resolveCompilePath, "resolveCompilePath");
 async function runCompileImports(options) {
   const { bundle, providers, logger } = options;
   const overwrite = options.overwrite === true;
@@ -5879,6 +5537,13 @@ async function runCompileImports(options) {
   let tantivyError = null;
   let fts5Error = null;
   try {
+    const sweep = bundle.db.prepare(`UPDATE import_batches SET status = 'failed', finished_at = datetime('now')
+         WHERE finished_at IS NULL`).run();
+    if (sweep.changes > 0) {
+      logger?.warn({
+        batches_reaped: sweep.changes
+      }, "reaped unfinished import_batches from a prior crash");
+    }
     logger?.info("disabling FTS5 triggers for bulk rebuild");
     disableFts5Triggers(bundle);
     for (const provider of providers) {
@@ -5888,15 +5553,14 @@ async function runCompileImports(options) {
         source_path: sourcePath
       });
       providerLogger?.info("starting compile");
-      const r = await provider.compile(bundle, sourcePath, { logger: providerLogger });
+      const r = await provider.compile(bundle, sourcePath, {
+        logger: providerLogger
+      });
       importedAny ||= r.counts.source_files_imported > 0;
-      providerLogger?.info(
-        {
-          batch_id: r.batch.batch_id,
-          counts: r.counts
-        },
-        "compile finished"
-      );
+      providerLogger?.info({
+        batch_id: r.batch.batch_id,
+        counts: r.counts
+      }, "compile finished");
       const summary = {
         source: provider.name,
         sourcePath,
@@ -5909,26 +5573,38 @@ async function runCompileImports(options) {
     }
     const shouldRebuildIndexes = importedAny || overwrite;
     if (shouldRebuildIndexes) {
-      logger?.info(
-        { changed: importedAny, overwrite },
-        importedAny ? "marking indexes" : "overwrite forces rebuild despite no new imports"
-      );
-      markIndexesAfterImport(bundle, { changed: true });
+      logger?.info({
+        changed: importedAny,
+        overwrite
+      }, importedAny ? "marking indexes" : "overwrite forces rebuild despite no new imports");
+      markIndexesAfterImport(bundle, {
+        changed: true
+      });
       try {
         logger?.info("rebuilding fts5 index");
         rebuildFts5Index(bundle);
       } catch (error) {
         fts5Error = getErrorMessage(error);
-        logger?.error({ err: error }, "fts5 rebuild failed; SQLite data is intact");
+        logger?.error({
+          err: error
+        }, "fts5 rebuild failed; SQLite data is intact");
       }
       try {
-        logger?.info({ overwrite }, "rebuilding tantivy index");
-        const status = await rebuildTantivyIndex(bundle, { overwrite });
-        tantivy = { indexedDocCount: status.indexed_doc_count };
+        logger?.info({
+          overwrite
+        }, "rebuilding tantivy index");
+        const status = await rebuildTantivyIndex(bundle, {
+          overwrite
+        });
+        tantivy = {
+          indexedDocCount: status.indexed_doc_count
+        };
         options.onTantivyComplete?.(tantivy);
       } catch (error) {
         tantivyError = getErrorMessage(error);
-        logger?.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
+        logger?.error({
+          err: error
+        }, "tantivy rebuild failed; SQLite data is intact");
       }
     }
   } finally {
@@ -5942,10 +5618,15 @@ async function runCompileImports(options) {
     fts5Error
   };
 }
+__name(runCompileImports, "runCompileImports");
 async function exportCompileParquet(options) {
   const storePath = resolveCompilePath(options.storePath);
-  options.logger?.info({ store_path: storePath }, "exporting parquet");
-  const result = await exportBundleParquet({ bundlePath: storePath });
+  options.logger?.info({
+    store_path: storePath
+  }, "exporting parquet");
+  const result = await exportBundleParquet({
+    bundlePath: storePath
+  });
   return {
     outDir: result.outDir,
     manifestPath: result.manifestPath,
@@ -5954,22 +5635,34 @@ async function exportCompileParquet(options) {
     counts: result.counts
   };
 }
+__name(exportCompileParquet, "exportCompileParquet");
 
 // src/services/analytics.ts
-var ANALYTICS_REPORTS = ["sessions", "tools", "errors", "models", "projects"];
+var ANALYTICS_REPORTS = [
+  "sessions",
+  "tools",
+  "errors",
+  "models",
+  "projects"
+];
 async function runAnalyticsReport(options) {
   return queryDuckDbParquet({
     parquetDir: options.parquetDir,
     sql: buildAnalyticsSql(options.report, options.filters ?? {}, "duckdb")
   });
 }
+__name(runAnalyticsReport, "runAnalyticsReport");
 function runAnalyticsReportFromBundle(options) {
   const sql = buildAnalyticsSql(options.report, options.filters ?? {}, "sqlite");
   const stmt = options.bundle.db.prepare(sql);
   const rows = stmt.all();
   const columns = stmt.columns().map((column) => column.name);
-  return { columns, rows };
+  return {
+    columns,
+    rows
+  };
 }
+__name(runAnalyticsReportFromBundle, "runAnalyticsReportFromBundle");
 function buildAnalyticsSql(report, filters, dialect) {
   switch (report) {
     case "sessions":
@@ -5984,6 +5677,7 @@ function buildAnalyticsSql(report, filters, dialect) {
       return buildProjectsSql(filters, dialect);
   }
 }
+__name(buildAnalyticsSql, "buildAnalyticsSql");
 function buildSessionsSql(filters, dialect) {
   const where = buildWhere([
     sourceFilter(filters),
@@ -6003,6 +5697,7 @@ function buildSessionsSql(filters, dialect) {
      LIMIT ${limit(filters)}
   `;
 }
+__name(buildSessionsSql, "buildSessionsSql");
 function buildToolsSql(filters, dialect) {
   const where = buildWhere([
     sourceFilter(filters),
@@ -6025,6 +5720,7 @@ function buildToolsSql(filters, dialect) {
      LIMIT ${limit(filters)}
   `;
 }
+__name(buildToolsSql, "buildToolsSql");
 function buildErrorsSql(filters, dialect) {
   const where = buildWhere([
     sourceFilter(filters),
@@ -6042,6 +5738,7 @@ function buildErrorsSql(filters, dialect) {
      LIMIT ${limit(filters)}
   `;
 }
+__name(buildErrorsSql, "buildErrorsSql");
 function buildModelsSql(filters, dialect) {
   const where = buildWhere([
     sourceFilter(filters),
@@ -6058,6 +5755,7 @@ function buildModelsSql(filters, dialect) {
      LIMIT ${limit(filters)}
   `;
 }
+__name(buildModelsSql, "buildModelsSql");
 function buildProjectsSql(filters, dialect) {
   const where = buildWhere([
     sourceFilter(filters),
@@ -6074,17 +5772,18 @@ function buildProjectsSql(filters, dialect) {
      LIMIT ${limit(filters)}
   `;
 }
+__name(buildProjectsSql, "buildProjectsSql");
 function sourceFilter(filters) {
   return filters.source ? `source_tool = ${sqlString2(filters.source)}` : null;
 }
+__name(sourceFilter, "sourceFilter");
 function timeFilter(column, filters) {
   const filtersSql = [];
-  if (filters.since)
-    filtersSql.push(`(${column} IS NULL OR ${column} >= ${sqlString2(filters.since)})`);
-  if (filters.until)
-    filtersSql.push(`(${column} IS NULL OR ${column} < ${sqlString2(filters.until)})`);
+  if (filters.since) filtersSql.push(`(${column} IS NULL OR ${column} >= ${sqlString2(filters.since)})`);
+  if (filters.until) filtersSql.push(`(${column} IS NULL OR ${column} < ${sqlString2(filters.until)})`);
   return filtersSql.length ? filtersSql.join(" AND ") : null;
 }
+__name(timeFilter, "timeFilter");
 function rangeOverlapFilter(firstColumn, lastColumn, filters) {
   const filtersSql = [];
   if (filters.since) {
@@ -6095,6 +5794,7 @@ function rangeOverlapFilter(firstColumn, lastColumn, filters) {
   }
   return filtersSql.length ? filtersSql.join(" AND ") : null;
 }
+__name(rangeOverlapFilter, "rangeOverlapFilter");
 function projectFilter(filters, dialect) {
   if (!filters.project) return null;
   const exact = sqlString2(filters.project);
@@ -6102,20 +5802,28 @@ function projectFilter(filters, dialect) {
   const op = dialect === "duckdb" ? "ILIKE" : "LIKE";
   return `(project_id = ${exact} OR project_name ${op} ${like} ESCAPE '\\' OR project_path ${op} ${like} ESCAPE '\\')`;
 }
+__name(projectFilter, "projectFilter");
 function buildWhere(filters) {
   const active = filters.filter((filter) => Boolean(filter));
   return active.length ? `WHERE ${active.join(" AND ")}` : "";
 }
+__name(buildWhere, "buildWhere");
 function limit(filters) {
   const value = Number.isFinite(filters.limit) ? filters.limit : void 0;
-  return clampLimit(value, { max: 500, fallback: 50 });
+  return clampLimit(value, {
+    max: 500,
+    fallback: 50
+  });
 }
+__name(limit, "limit");
 function sqlString2(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
+__name(sqlString2, "sqlString");
 function escapeLike(value) {
   return value.replace(/[\\%_]/g, (match) => `\\${match}`);
 }
+__name(escapeLike, "escapeLike");
 
 // src/services/tool_calls.ts
 function listToolCalls(bundle, filters = {}) {
@@ -6150,7 +5858,10 @@ function listToolCalls(bundle, filters = {}) {
     params.push(filters.untilIso);
   }
   const where = conds.length ? `WHERE ${conds.join(" AND ")}` : "";
-  const limit2 = clampLimit(filters.limit, { max: 500, fallback: 100 });
+  const limit2 = clampLimit(filters.limit, {
+    max: 500,
+    fallback: 100
+  });
   const toolCallSql = `
     SELECT 'tool_call' AS entity_type,
            tc.session_id,
@@ -6199,33 +5910,26 @@ function listToolCalls(bundle, filters = {}) {
   `;
   return bundle.db.prepare(sql).all(...params, `%${filters.pathSubstring}%`);
 }
+__name(listToolCalls, "listToolCalls");
 
 // src/services/export/markdown.ts
 async function exportSessionMarkdown(bundle, sessionId2) {
-  const session = bundle.db.prepare(
-    `SELECT session_id, source_tool, source_session_id, title, start_ts, end_ts,
+  const session = bundle.db.prepare(`SELECT session_id, source_tool, source_session_id, title, start_ts, end_ts,
               cwd_initial, git_branch_initial, model_first, model_last, timeline_confidence
-         FROM sessions WHERE session_id = ?`
-  ).get(sessionId2);
+         FROM sessions WHERE session_id = ?`).get(sessionId2);
   if (!session) {
     throw new Error(`session not found: ${sessionId2}`);
   }
-  const messages = bundle.db.prepare(
-    `SELECT message_id, role, timestamp, ordinal, model
-         FROM messages WHERE session_id = ? ORDER BY ordinal`
-  ).all(sessionId2);
-  const blocks = bundle.db.prepare(
-    `SELECT message_id, block_type, text_object_id, text_inline, ordinal
-         FROM content_blocks WHERE session_id = ? ORDER BY ordinal`
-  ).all(sessionId2);
-  const toolCalls = bundle.db.prepare(
-    `SELECT tc.tool_call_id, tc.message_id, tc.tool_name, tc.command, tc.path,
+  const messages = bundle.db.prepare(`SELECT message_id, role, timestamp, ordinal, model
+         FROM messages WHERE session_id = ? ORDER BY ordinal`).all(sessionId2);
+  const blocks = bundle.db.prepare(`SELECT message_id, block_type, text_object_id, text_inline, ordinal
+         FROM content_blocks WHERE session_id = ? ORDER BY ordinal`).all(sessionId2);
+  const toolCalls = bundle.db.prepare(`SELECT tc.tool_call_id, tc.message_id, tc.tool_name, tc.command, tc.path,
               tc.status, tc.timestamp_start,
               tr.is_error, tr.preview
          FROM tool_calls tc
          LEFT JOIN tool_results tr ON tr.tool_call_id = tc.tool_call_id
-        WHERE tc.session_id = ? ORDER BY tc.timestamp_start, tc.tool_call_id`
-  ).all(sessionId2);
+        WHERE tc.session_id = ? ORDER BY tc.timestamp_start, tc.tool_call_id`).all(sessionId2);
   const blocksByMessage = /* @__PURE__ */ new Map();
   for (const b of blocks) {
     if (!b.message_id) continue;
@@ -6251,9 +5955,7 @@ async function exportSessionMarkdown(bundle, sessionId2) {
   if (session.cwd_initial) lines.push(`- **cwd**: \`${session.cwd_initial}\``);
   if (session.git_branch_initial) lines.push(`- **git branch**: ${session.git_branch_initial}`);
   if (session.model_first || session.model_last) {
-    lines.push(
-      `- **models**: ${session.model_first ?? "?"} \u2192 ${session.model_last ?? session.model_first ?? "?"}`
-    );
+    lines.push(`- **models**: ${session.model_first ?? "?"} \u2192 ${session.model_last ?? session.model_first ?? "?"}`);
   }
   lines.push(`- **timeline confidence**: ${session.timeline_confidence}`);
   lines.push("");
@@ -6282,6 +5984,7 @@ async function exportSessionMarkdown(bundle, sessionId2) {
   return `${lines.join("\n")}
 `;
 }
+__name(exportSessionMarkdown, "exportSessionMarkdown");
 async function renderBlockText(bundle, block) {
   if (block.text_inline) return block.text_inline;
   if (block.text_object_id) {
@@ -6293,6 +5996,7 @@ async function renderBlockText(bundle, block) {
   }
   return null;
 }
+__name(renderBlockText, "renderBlockText");
 function renderToolCall(c) {
   const status = c.status ? ` \xB7 ${c.status}` : "";
   const errFlag = c.is_error === 1 ? " \xB7 ERROR" : "";
@@ -6309,6 +6013,7 @@ function renderToolCall(c) {
   }
   return lines.join("\n");
 }
+__name(renderToolCall, "renderToolCall");
 export {
   ANALYTICS_REPORTS,
   ANALYTICS_VIEWS,