@c3-oss/prosa 0.1.1 → 0.3.0

package/dist/bin/prosa.js

@@ -98,16 +98,27 @@ var init_hash = __esm({
 // src/core/cas/index.ts
 var cas_exports = {};
 __export(cas_exports, {
+  createPendingObjects: () => createPendingObjects,
+  ensureDir: () => ensureDir,
+  flushPendingObjects: () => flushPendingObjects,
   getBytes: () => getBytes,
   getJson: () => getJson,
   getObjectMeta: () => getObjectMeta,
   getText: () => getText,
   putBytes: () => putBytes,
   putJson: () => putJson,
-  putText: () => putText
+  putText: () => putText,
+  stageBytes: () => stageBytes,
+  stageJson: () => stageJson,
+  stageText: () => stageText
 });
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
+async function ensureDir(absoluteDir) {
+  if (ensuredDirs.has(absoluteDir)) return;
+  await mkdir2(absoluteDir, { recursive: true });
+  ensuredDirs.add(absoluteDir);
+}
 async function putBytes(bundle, bytes, options = {}) {
   const hash = blake3Hex(bytes);
   const objectId = objectIdFromHash(hash);
@@ -121,7 +132,7 @@ async function putBytes(bundle, bytes, options = {}) {
   const { bytes: stored, compression } = compressBytes(bytes);
   const storagePath = objectStoragePath(hash, compression);
   const absolutePath = path2.join(bundle.path, storagePath);
-  await mkdir2(path2.dirname(absolutePath), { recursive: true });
+  await ensureDir(path2.dirname(absolutePath));
   await writeFile2(absolutePath, stored);
   prepare(
     bundle.db,
@@ -185,18 +196,126 @@ function getObjectMeta(bundle, objectId) {
          FROM objects WHERE object_id = ?`
   ).get(objectId) ?? null;
 }
+function createPendingObjects() {
+  return { byId: /* @__PURE__ */ new Map() };
+}
+function stageBytes(pending, bytes, options = {}) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+  const hash = blake3Hex(buf);
+  const objectId = objectIdFromHash(hash);
+  if (!pending.byId.has(objectId)) {
+    pending.byId.set(objectId, {
+      objectId,
+      hash,
+      bytes: buf,
+      mimeType: options.mimeType ?? null,
+      encoding: options.encoding ?? null
+    });
+  }
+  return objectId;
+}
+function stageText(pending, text, options = {}) {
+  return stageBytes(pending, Buffer.from(text, "utf8"), {
+    mimeType: options.mimeType ?? "text/plain; charset=utf-8",
+    encoding: "utf-8"
+  });
+}
+function stageJson(pending, value) {
+  return stageBytes(pending, Buffer.from(JSON.stringify(value), "utf8"), {
+    mimeType: "application/json",
+    encoding: "utf-8"
+  });
+}
+async function flushPendingObjects(bundle, pending) {
+  if (pending.byId.size === 0) return;
+  const ids = [...pending.byId.keys()];
+  const existingIds = queryExistingObjectIds(bundle, ids);
+  const toWrite = [];
+  for (const obj of pending.byId.values()) {
+    if (existingIds.has(obj.objectId)) continue;
+    const { bytes: compressedBytes, compression } = compressBytes(obj.bytes);
+    const storagePath = objectStoragePath(obj.hash, compression);
+    toWrite.push({
+      staged: obj,
+      compression,
+      compressedBytes,
+      storagePath,
+      absolutePath: path2.join(bundle.path, storagePath)
+    });
+  }
+  if (toWrite.length > 0) {
+    await writeFilesParallel(toWrite);
+  }
+  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', ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  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
+    );
+  }
+}
+function queryExistingObjectIds(bundle, ids) {
+  const found = /* @__PURE__ */ new Set();
+  if (ids.length === 0) return found;
+  const CHUNK = 500;
+  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);
+    for (const row of rows) found.add(row.object_id);
+  }
+  return found;
+}
+async function writeFilesParallel(tasks) {
+  let cursor = 0;
+  const workers = [];
+  const limit = Math.min(FS_WRITE_CONCURRENCY, tasks.length);
+  for (let w = 0; w < limit; 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);
+        }
+      })()
+    );
+  }
+  await Promise.all(workers);
+}
+var ensuredDirs, FS_WRITE_CONCURRENCY;
 var init_cas = __esm({
   "src/core/cas/index.ts"() {
     "use strict";
     init_db();
     init_compress();
     init_hash();
+    ensuredDirs = /* @__PURE__ */ new Set();
+    FS_WRITE_CONCURRENCY = 16;
   }
 });
 
 // src/services/indexing.ts
-import { mkdir as mkdir4, rm, writeFile as writeFile4 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir4, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import path13 from "path";
 function enableFts5Triggers(bundle) {
   bundle.db.exec(FTS5_TRIGGER_SQL);
 }
@@ -291,7 +410,7 @@ async function rebuildTantivyIndex(bundle) {
   try {
     const tantivy = await import("@oxdev03/node-tantivy-binding");
     const schema = new tantivy.SchemaBuilder().addTextField("doc_id", { stored: true, tokenizerName: "raw" }).addTextField("entity_type", { stored: true, tokenizerName: "raw" }).addTextField("entity_id", { stored: true, tokenizerName: "raw" }).addTextField("session_id", { stored: true, tokenizerName: "raw" }).addTextField("project_id", { stored: true, tokenizerName: "raw" }).addTextField("timestamp", { stored: true, tokenizerName: "raw" }).addTextField("role", { stored: true, tokenizerName: "raw" }).addTextField("tool_name", { stored: true, tokenizerName: "raw" }).addTextField("canonical_tool_type", { stored: true, tokenizerName: "raw" }).addTextField("field_kind", { stored: true, tokenizerName: "raw" }).addTextField("text", { stored: true }).build();
-    await rm(bundle.paths.tantivy, { recursive: true, force: true });
+    await rm2(bundle.paths.tantivy, { recursive: true, force: true });
     await mkdir4(bundle.paths.tantivy, { recursive: true });
     const index = new tantivy.Index(schema, bundle.paths.tantivy, false);
     const writer = index.writer(5e7, 1);
@@ -320,8 +439,8 @@ async function rebuildTantivyIndex(bundle) {
     }
     writer.commit();
     index.reload();
-    await writeFile4(
-      path12.join(bundle.paths.tantivy, "prosa-index.json"),
+    await writeFile5(
+      path13.join(bundle.paths.tantivy, "prosa-index.json"),
       `${JSON.stringify(
         {
           engine: "tantivy",
@@ -1001,7 +1120,6 @@ var PROSA_PARSER_VERSION = "0.1.0";
 var PROSA_SCHEMA_VERSION = 2;
 
 // src/cli/commands/compile.ts
-import path13 from "path";
 import { Command } from "commander";
 
 // src/core/bundle.ts
@@ -1507,6 +1625,10 @@ function closeBundle(bundle) {
   closeDb(bundle.db);
 }
 
+// src/services/compile.ts
+import os2 from "os";
+import path14 from "path";
+
 // src/importers/claude/index.ts
 init_cas();
 init_db();
@@ -1627,8 +1749,9 @@ async function recordError(bundle, batchId, args) {
 // src/core/ingest/idempotency.ts
 init_compress();
 init_hash();
+init_cas();
 init_db();
-import { access as access2, mkdir as mkdir3, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { access as access2, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import path3 from "path";
 async function registerSourceFile(bundle, args) {
   const st = await stat2(args.absolutePath);
@@ -1714,7 +1837,7 @@ async function preserveRawSourceBytes(bundle, bytes) {
   const { bytes: stored, compression } = compressBytes(bytes);
   const storagePath = rawSourceStoragePath(hash, compression);
   const absolutePath = path3.join(bundle.path, storagePath);
-  await mkdir3(path3.dirname(absolutePath), { recursive: true });
+  await ensureDir(path3.dirname(absolutePath));
   if (!await fileExists(absolutePath)) {
     await writeFile3(absolutePath, stored);
   }
@@ -1814,17 +1937,34 @@ async function readdirSafe(dir) {
 
 // src/importers/claude/index.ts
 var PREVIEW_MAX = 4e3;
-async function compileClaude(bundle, root) {
+async function compileClaude(bundle, root, options = {}) {
+  const logger = options.logger;
   const batch = startBatch(bundle, "claude", [root]);
   const counts = emptyCounts();
+  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"
+      );
       try {
-        const fc = await compileClaudeFile(bundle, batch, file);
+        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"
+        );
         await recordError(bundle, batch.batch_id, {
           kind: "claude_file_failed",
           message: error instanceof Error ? error.message : String(error),
@@ -1833,9 +1973,12 @@ async function compileClaude(bundle, root) {
       }
     }
     linkSubagentParents(bundle);
+    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");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
+    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "claude batch failed");
     throw error;
   }
   return { batch, counts };
@@ -1889,7 +2032,7 @@ function addCounts(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
-async function compileClaudeFile(bundle, batch, file) {
+async function compileClaudeFile(bundle, batch, file, logger) {
   const counts = emptyFileCounts();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
     sourceTool: "claude",
@@ -1899,9 +2042,17 @@ async function compileClaudeFile(bundle, batch, file) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
+    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"
+  );
   const text = await readFile4(file.filePath, "utf8");
   const rawLines = text.split("\n");
   const lines = rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
@@ -1918,7 +2069,8 @@ async function compileClaudeFile(bundle, batch, file) {
     artifacts: [],
     edges: [],
     searchDocs: [],
-    uuidToMessageId: /* @__PURE__ */ new Map()
+    uuidToMessageId: /* @__PURE__ */ new Map(),
+    objects: createPendingObjects()
   };
   let modelFirst = null;
   let modelLast = null;
@@ -1933,7 +2085,7 @@ async function compileClaudeFile(bundle, batch, file) {
     const lineNo = i + 1;
     const ordinal = i;
     const lineBytes = Buffer.from(line, "utf8");
-    const rawObjectId = await putBytes(bundle, lineBytes, {
+    const rawObjectId = stageBytes(pending.objects, lineBytes, {
       mimeType: "application/jsonl-line",
       encoding: "utf-8"
     });
@@ -1944,7 +2096,7 @@ async function compileClaudeFile(bundle, batch, file) {
     } catch {
       parserStatus = "failed";
     }
-    const decodedObjectId = parsed != null && parserStatus === "ok" ? await putJson(bundle, parsed) : null;
+    const decodedObjectId = null;
     const nativeId = parsed?.uuid ?? null;
     const rawRecordId2 = rawRecordId(sourceFile.source_file_id, ordinal, rawObjectId);
     pending.rawRecords.push({
@@ -2042,7 +2194,7 @@ async function compileClaudeFile(bundle, batch, file) {
           raw_record_id: rawRecordId2
         });
         if (content.length > PREVIEW_MAX) {
-          const fullId = await putText(bundle, content);
+          const fullId = stageText(pending.objects, content);
           const last = pending.blocks[pending.blocks.length - 1];
           if (last) last.text_object_id = fullId;
         }
@@ -2182,6 +2334,7 @@ async function compileClaudeFile(bundle, batch, file) {
     pending.session.git_branch_initial ??= branchInitial;
   }
   buildSearchDocs(pending);
+  await flushPendingObjects(bundle, pending.objects);
   transactional(bundle.db, () => {
     flushPending(bundle, pending, { modelFirst, modelLast });
   });
@@ -2194,6 +2347,10 @@ async function compileClaudeFile(bundle, batch, file) {
   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"
+  );
   return counts;
 }
 function createSessionFromFirstRecord(file, parsed, meta, ts, rawRecordId2) {
@@ -2241,7 +2398,7 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
       event_id: null,
       ordinal: blockOrdinal,
       block_type: "text",
-      text_object_id: text.length > PREVIEW_MAX ? await putText(bundle, text) : null,
+      text_object_id: text.length > PREVIEW_MAX ? stageText(pending.objects, text) : null,
       text_inline: text.slice(0, PREVIEW_MAX),
       is_error: 0,
       visibility: "default",
@@ -2257,7 +2414,7 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
       event_id: null,
       ordinal: blockOrdinal,
       block_type: "thinking",
-      text_object_id: text.length > PREVIEW_MAX ? await putText(bundle, text) : null,
+      text_object_id: text.length > PREVIEW_MAX ? stageText(pending.objects, text) : null,
       text_inline: text.slice(0, PREVIEW_MAX),
       is_error: 0,
       visibility: "hidden_by_default",
@@ -2269,7 +2426,7 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
     const tu = block;
     const sourceCallId = tu.id ?? `${blockOrdinal}`;
     const toolName = tu.name ?? "unknown";
-    const argsId = tu.input != null ? await putJson(bundle, tu.input) : null;
+    const argsId = tu.input != null ? stageJson(pending.objects, tu.input) : null;
     const command = inferCommandFromArgs(toolName, tu.input);
     const filePath = inferPathFromArgs(tu.input);
     const tcId = toolCallId(sessionId2, sourceCallId);
@@ -2310,13 +2467,14 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
     const sourceCallId = tr.tool_use_id ?? null;
     const isError = tr.is_error === true ? 1 : 0;
     const text = stringifyOrNull(tr.content) ?? "";
+    const overflowId = text.length > PREVIEW_MAX ? stageText(pending.objects, text) : null;
     pending.blocks.push({
       block_id: blkId,
       message_id: messageId2,
       event_id: null,
       ordinal: blockOrdinal,
       block_type: "tool_result",
-      text_object_id: text.length > PREVIEW_MAX ? await putText(bundle, text) : null,
+      text_object_id: overflowId,
       text_inline: text.slice(0, PREVIEW_MAX),
       is_error: isError,
       visibility: "default",
@@ -2335,7 +2493,7 @@ async function processContentBlock(bundle, sessionId2, messageId2, eventId2, blo
       duration_ms: null,
       stdout_object_id: null,
       stderr_object_id: null,
-      output_object_id: text.length > PREVIEW_MAX ? await putText(bundle, text) : null,
+      output_object_id: overflowId,
       preview: text.slice(0, PREVIEW_MAX),
       raw_record_id: rawRecordId2
     });
@@ -2750,17 +2908,27 @@ async function* walk(dir) {
 
 // src/importers/codex/index.ts
 var PREVIEW_MAX2 = 4e3;
-async function compileCodex(bundle, root) {
+async function compileCodex(bundle, root, options = {}) {
+  const logger = options.logger;
   const batch = startBatch(bundle, "codex", [root]);
   const counts = emptyCounts();
+  logger?.info({ batch_id: batch.batch_id, root }, "codex batch started");
   try {
     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);
+        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: error instanceof Error ? error.message : String(error),
@@ -2769,9 +2937,12 @@ async function compileCodex(bundle, root) {
       }
     }
     linkSubagentParents2(bundle);
+    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");
   } catch (error) {
     finishBatch(bundle, batch, counts, "failed");
+    logger?.error({ err: error, batch_id: batch.batch_id, counts }, "codex batch failed");
     throw error;
   }
   return { batch, counts };
@@ -2824,7 +2995,7 @@ function addCounts2(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
-async function compileCodexFile(bundle, batch, filePath) {
+async function compileCodexFile(bundle, batch, filePath, logger) {
   const counts = emptyFileCounts2();
   const { row: sourceFileRow, alreadyKnown } = await registerSourceFile(bundle, {
     sourceTool: "codex",
@@ -2833,9 +3004,17 @@ async function compileCodexFile(bundle, batch, filePath) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
+    logger?.debug(
+      { path: filePath, source_file_id: sourceFileRow.source_file_id },
+      "codex source file skipped"
+    );
     return counts;
   }
   counts.source_files_imported = 1;
+  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;
@@ -2852,7 +3031,8 @@ async function compileCodexFile(bundle, batch, filePath) {
     toolResults: [],
     artifacts: [],
     edges: [],
-    searchDocs: []
+    searchDocs: [],
+    objects: createPendingObjects()
   };
   let sessionStartTs = null;
   let sessionEndTs = null;
@@ -2866,7 +3046,7 @@ async function compileCodexFile(bundle, batch, filePath) {
     const lineNo = i + 1;
     const ordinal = i;
     const lineBytes = Buffer.from(line, "utf8");
-    const rawObjectId = await putBytes(bundle, lineBytes, {
+    const rawObjectId = stageBytes(pending.objects, lineBytes, {
       mimeType: "application/jsonl-line",
       encoding: "utf-8"
     });
@@ -2877,7 +3057,7 @@ async function compileCodexFile(bundle, batch, filePath) {
     } catch {
       parserStatus = "failed";
     }
-    const decodedObjectId = parsed != null && parserStatus === "ok" ? await putJson(bundle, parsed) : null;
+    const decodedObjectId = null;
     const nativeId = parsed ? extractNativeId(parsed) : null;
     const rawRecordId2 = rawRecordId(sourceFileRow.source_file_id, ordinal, rawObjectId);
     pending.rawRecords.push({
@@ -3046,6 +3226,7 @@ async function compileCodexFile(bundle, batch, filePath) {
     pending.session.start_ts ??= sessionStartTs;
   }
   buildSearchDocs2(pending);
+  await flushPendingObjects(bundle, pending.objects);
   transactional(bundle.db, () => {
     flushPending2(bundle, pending, {
       sessionEndTs,
@@ -3064,6 +3245,10 @@ async function compileCodexFile(bundle, batch, filePath) {
   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;
 }
 function handleResponseItem(_bundle, sessionId2, currentTurnId, rawRecordId2, ordinal, ts, ri, payloadObjectId, nextMsgOrdinal, currentModel, pending) {
@@ -3223,8 +3408,8 @@ async function handleEventMsg(bundle, sessionId2, currentTurnId, rawRecordId2, o
   const subtype = em.type ?? "unknown";
   if (subtype === "exec_command_end") {
     const sourceCallId = em.call_id ?? null;
-    const stdoutId = em.stdout ? await putText(bundle, em.stdout, { mimeType: "text/plain" }) : null;
-    const stderrId = em.stderr ? await putText(bundle, em.stderr, { mimeType: "text/plain" }) : 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
@@ -3871,17 +4056,34 @@ async function readdirSafe2(dir) {
 
 // src/importers/cursor/index.ts
 var PREVIEW_MAX3 = 4e3;
-async function compileCursor(bundle, root) {
+async function compileCursor(bundle, root, options = {}) {
+  const logger = options.logger;
   const batch = startBatch(bundle, "cursor", [root]);
   const counts = emptyCounts();
+  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"
+      );
       try {
-        const fc = await compileCursorStore(bundle, batch, store);
+        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"
+        );
         await recordError(bundle, batch.batch_id, {
           kind: "cursor_store_failed",
           message: error instanceof Error ? error.message : String(error),
@@ -3890,8 +4092,10 @@ async function compileCursor(bundle, root) {
       }
     }
     finishBatch(bundle, batch, counts, "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");
     throw error;
   }
   return { batch, counts };
@@ -3926,7 +4130,7 @@ function addCounts3(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
-async function compileCursorStore(bundle, batch, store) {
+async function compileCursorStore(bundle, batch, store, logger) {
   const counts = emptyFileCounts3();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
     sourceTool: "cursor",
@@ -3936,9 +4140,17 @@ async function compileCursorStore(bundle, batch, store) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
+    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 });
   try {
     const pending = {
@@ -3951,7 +4163,8 @@ async function compileCursorStore(bundle, batch, store) {
       toolCallsList: [],
       toolResults: [],
       artifacts: [],
-      searchDocs: []
+      searchDocs: [],
+      objects: createPendingObjects()
     };
     const metaRow = cdb.prepare(`SELECT value FROM meta WHERE key='0'`).get();
     let meta = {};
@@ -3963,7 +4176,7 @@ async function compileCursorStore(bundle, batch, store) {
       } catch {
         meta = {};
       }
-      const metaObjId = await putBytes(bundle, Buffer.from(metaText, "utf8"), {
+      const metaObjId = stageBytes(pending.objects, Buffer.from(metaText, "utf8"), {
         mimeType: "application/json",
         encoding: "utf-8"
       });
@@ -4002,7 +4215,7 @@ async function compileCursorStore(bundle, batch, store) {
       const blob = blobs[i];
       if (!blob) continue;
       const ordinal = i + 1;
-      const blobObjectId = await putBytes(bundle, blob.data);
+      const blobObjectId = stageBytes(pending.objects, blob.data);
       const blobRawId = rawRecordId(sourceFile.source_file_id, ordinal, blobObjectId);
       let parsed = null;
       const firstByte = blob.data[0];
@@ -4022,7 +4235,7 @@ async function compileCursorStore(bundle, batch, store) {
         json_pointer: `blobs/${blob.id}`,
         native_id: blob.id,
         raw_object_id: blobObjectId,
-        decoded_json_object_id: parsed != null ? await putJson(bundle, parsed) : null,
+        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
@@ -4077,6 +4290,7 @@ async function compileCursorStore(bundle, batch, store) {
       }
     }
     buildSearchDocs3(pending);
+    await flushPendingObjects(bundle, pending.objects);
     transactional(bundle.db, () => {
       flushPending3(bundle, pending);
     });
@@ -4088,6 +4302,10 @@ async function compileCursorStore(bundle, batch, store) {
     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"
+    );
     return counts;
   } finally {
     cdb.close();
@@ -4112,7 +4330,7 @@ function mapRole(role) {
 }
 async function pushTextBlock(bundle, pending, messageId2, ordinal, blockType, text, rawRecordId2, visibility = "default") {
   if (!text) return;
-  const overflow = text.length > PREVIEW_MAX3 ? await putText(bundle, text) : null;
+  const overflow = text.length > PREVIEW_MAX3 ? stageText(pending.objects, text) : null;
   pending.blocks.push({
     block_id: blockId(messageId2, ordinal),
     message_id: messageId2,
@@ -4163,7 +4381,7 @@ async function processContentItem(bundle, sessionId2, messageId2, eventId2, ordi
   if (t === "tool-call") {
     const sourceCallId = item.toolCallId ?? `${ordinal}`;
     const toolName = item.toolName ?? "unknown";
-    const argsObjectId = item.args != null ? await putJson(bundle, item.args) : null;
+    const argsObjectId = item.args != null ? stageJson(pending.objects, item.args) : null;
     const tcId = toolCallId(sessionId2, sourceCallId);
     pending.blocks.push({
       block_id: blockId(messageId2, ordinal),
@@ -4200,7 +4418,7 @@ async function processContentItem(bundle, sessionId2, messageId2, eventId2, ordi
   if (t === "tool-result") {
     const sourceCallId = item.toolCallId ?? `${ordinal}`;
     const text = stringifyOrNull3(item.result) ?? "";
-    const overflow = text.length > PREVIEW_MAX3 ? await putText(bundle, text) : null;
+    const overflow = text.length > PREVIEW_MAX3 ? stageText(pending.objects, text) : null;
     const isError = readIsError(item) ? 1 : 0;
     pending.blocks.push({
       block_id: blockId(messageId2, ordinal),
@@ -4564,17 +4782,34 @@ async function readdirSafe3(dir) {
 
 // src/importers/gemini/index.ts
 var PREVIEW_MAX4 = 4e3;
-async function compileGemini(bundle, root) {
+async function compileGemini(bundle, root, options = {}) {
+  const logger = options.logger;
   const batch = startBatch(bundle, "gemini", [root]);
   const counts = emptyCounts();
+  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"
+      );
       try {
-        const fc = await compileGeminiFile(bundle, batch, file);
+        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"
+        );
         await recordError(bundle, batch.batch_id, {
           kind: "gemini_file_failed",
           message: error instanceof Error ? error.message : String(error),
@@ -4583,8 +4818,10 @@ async function compileGemini(bundle, root) {
       }
     }
     finishBatch(bundle, batch, counts, "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");
     throw error;
   }
   return { batch, counts };
@@ -4619,7 +4856,7 @@ function addCounts4(target, source) {
   target.edges += source.edges;
   target.errors += source.errors;
 }
-async function compileGeminiFile(bundle, batch, file) {
+async function compileGeminiFile(bundle, batch, file, logger) {
   const counts = emptyFileCounts4();
   const { row: sourceFile, alreadyKnown } = await registerSourceFile(bundle, {
     sourceTool: "gemini",
@@ -4629,12 +4866,21 @@ async function compileGeminiFile(bundle, batch, file) {
   });
   if (alreadyKnown) {
     counts.source_files_skipped = 1;
+    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"
+  );
   const text = await readFile7(file.filePath, "utf8");
   const parsed = JSON.parse(text);
-  const fileObjectId = await putBytes(bundle, Buffer.from(text, "utf8"), {
+  const objects = createPendingObjects();
+  const fileObjectId = stageBytes(objects, Buffer.from(text, "utf8"), {
     mimeType: "application/json",
     encoding: "utf-8"
   });
@@ -4664,7 +4910,8 @@ async function compileGeminiFile(bundle, batch, file) {
     toolResults: [],
     artifacts: [],
     searchDocs: [],
-    project: null
+    project: null,
+    objects
   };
   const sourceSid = parsed.sessionId ?? path11.basename(file.filePath, ".json");
   const sessionPk = sessionId("gemini", sourceSid);
@@ -4701,6 +4948,7 @@ async function compileGeminiFile(bundle, batch, file) {
     );
   }
   buildSearchDocs4(pending);
+  await flushPendingObjects(bundle, pending.objects);
   transactional(bundle.db, () => {
     flushPending4(bundle, pending);
   });
@@ -4712,12 +4960,16 @@ async function compileGeminiFile(bundle, batch, file) {
   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"
+  );
   return counts;
 }
 async function processMessage(bundle, sessionId2, sourceFileId2, index, msg, batchId, pending) {
   const ordinal = index + 1;
   const ts = msg.timestamp ?? null;
-  const payloadId = await putJson(bundle, msg);
+  const payloadId = stageJson(pending.objects, msg);
   const pointer = `/messages/${index}`;
   const rawObjectIdInput = sha256Hex(`${pointer}
 ${JSON.stringify(msg)}`);
@@ -4834,7 +5086,7 @@ ${JSON.stringify(msg)}`);
 }
 async function pushTextBlock2(bundle, pending, messageId2, blockOrdinal, blockType, text, rawRecordId2, visibility = "default") {
   if (!text) return;
-  const overflowId = text.length > PREVIEW_MAX4 ? await putText(bundle, text) : null;
+  const overflowId = text.length > PREVIEW_MAX4 ? stageText(pending.objects, text) : null;
   pending.blocks.push({
     block_id: blockId(messageId2, blockOrdinal),
     message_id: messageId2,
@@ -4851,7 +5103,7 @@ async function processToolCall(bundle, sessionId2, messageId2, eventId2, index,
   const sourceCallId = tc.id ?? `${messageId2}:${index}`;
   const toolName = tc.name ?? "unknown";
   const toolCallId2 = toolCallId(sessionId2, sourceCallId);
-  const argsObjectId = tc.args ? await putJson(bundle, tc.args) : null;
+  const argsObjectId = tc.args ? stageJson(pending.objects, tc.args) : null;
   pending.toolCallsList.push({
     tool_call_id: toolCallId2,
     message_id: messageId2,
@@ -4870,7 +5122,7 @@ async function processToolCall(bundle, sessionId2, messageId2, eventId2, index,
   });
   const isError = tc.status === "error" ? 1 : 0;
   const resultText = renderToolResultText(tc.result);
-  const overflowId = resultText.length > PREVIEW_MAX4 ? await putText(bundle, resultText) : null;
+  const overflowId = resultText.length > PREVIEW_MAX4 ? stageText(pending.objects, resultText) : null;
   pending.toolResults.push({
     tool_result_id: toolResultId(sessionId2, sourceCallId),
     tool_call_id: toolCallId2,
@@ -4887,7 +5139,7 @@ async function processToolCall(bundle, sessionId2, messageId2, eventId2, index,
     const rd = tc.resultDisplay;
     if (rd.fileDiff || rd.filePath) {
       const diffText = rd.fileDiff ?? "";
-      const diffId = diffText ? await putText(bundle, 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",
@@ -5242,59 +5494,372 @@ function flushPending4(bundle, pending) {
   }
 }
 
-// src/cli/commands/compile.ts
+// src/services/export/parquet.ts
+import { mkdir as mkdir3, rm, writeFile as writeFile4 } from "fs/promises";
+import path12 from "path";
+import { DuckDBConnection } from "@duckdb/node-api";
+var PARQUET_TABLES = [
+  "objects",
+  "source_files",
+  "import_batches",
+  "raw_records",
+  "import_errors",
+  "uncertainties",
+  "projects",
+  "sessions",
+  "turns",
+  "events",
+  "messages",
+  "content_blocks",
+  "tool_calls",
+  "tool_results",
+  "artifacts",
+  "edges",
+  "search_docs"
+];
+async function exportBundleParquet(options) {
+  const snapshot = await openBundleSnapshot(options.bundlePath);
+  const outDir = path12.resolve(options.outDir ?? snapshot.defaultOutDir);
+  await mkdir3(outDir, { recursive: true });
+  const files = Object.fromEntries(
+    PARQUET_TABLES.map((table) => [table, path12.join(outDir, `${table}.parquet`)])
+  );
+  const manifestPath = path12.join(outDir, "manifest.json");
+  for (const file of [...Object.values(files), manifestPath]) {
+    await rm(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)`
+      );
+    }
+  } finally {
+    connection.closeSync();
+  }
+  const manifest = {
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    source_db: snapshot.dbPath,
+    schema_version: snapshot.schemaVersion,
+    parser_version: snapshot.parserVersion,
+    tables: Object.fromEntries(
+      PARQUET_TABLES.map((table) => [
+        table,
+        {
+          file: path12.basename(files[table]),
+          rows: snapshot.counts[table]
+        }
+      ])
+    )
+  };
+  await writeFile4(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return { outDir, manifestPath, files, counts: snapshot.counts };
+}
+async function queryDuckDbParquet(options) {
+  const parquetDir = path12.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(
+          path12.join(parquetDir, `${table}.parquet`)
+        )})`
+      );
+    }
+    const reader = await connection.runAndReadAll(options.sql);
+    return {
+      columns: reader.deduplicatedColumnNames(),
+      rows: reader.getRowObjectsJson()
+    };
+  } catch (error) {
+    if (isMissingParquetError(error)) {
+      throw new Error(
+        `Parquet export not found in ${parquetDir}; run \`prosa export parquet --store <path>\` first`
+      );
+    }
+    throw error;
+  } finally {
+    connection.closeSync();
+  }
+}
+async function createDuckDbConnection() {
+  return DuckDBConnection.create();
+}
+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: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+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];
+      })
+    );
+    return {
+      dbPath: bundle.paths.db,
+      schemaVersion: bundle.manifest.schema_version,
+      parserVersion: bundle.manifest.parser_version,
+      defaultOutDir: bundle.paths.parquet,
+      counts
+    };
+  } finally {
+    closeBundle(bundle);
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function sqlString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function isMissingParquetError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /No files found|does not exist|not found/i.test(message) && /\.parquet/i.test(message);
+}
+
+// src/services/compile.ts
 init_indexing();
-function compileCommand() {
-  return new Command("compile").description("Import session histories from one or more agent CLIs into the bundle.").option("--codex <path>", "root of Codex CLI sessions (e.g. ~/.codex/sessions)").option("--claude <path>", "root of Claude Code projects (e.g. ~/.claude/projects)").option("--gemini <path>", "root of Gemini CLI tmp dir (e.g. ~/.gemini/tmp)").option("--cursor <path>", "root of Cursor agent stores (e.g. ~/.cursor/chats)").option("--store <path>", "bundle directory", defaultBundlePath()).option("--defer-index", "skip immediate FTS5 updates; run `prosa index fts5` later").action(
-    async (options) => {
-      if (!options.codex && !options.claude && !options.gemini && !options.cursor) {
-        process.stderr.write(
-          "no source specified \u2014 pass at least one of --codex / --claude / --gemini / --cursor\n"
-        );
-        process.exit(2);
-      }
-      const bundle = await openBundle(path13.resolve(options.store));
-      let importedAny = false;
+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"),
+    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"),
+    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"),
+    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"),
+    compile: compileCursor
+  }
+];
+function getCompileProvider(source) {
+  const provider = COMPILE_PROVIDERS.find((p) => p.name === source);
+  if (!provider) {
+    throw new Error(`unknown compile source: ${source}`);
+  }
+  return provider;
+}
+function resolveCompilePath(p) {
+  if (p === "~") return os2.homedir();
+  if (p.startsWith("~/")) return path14.join(os2.homedir(), p.slice(2));
+  return path14.resolve(p);
+}
+async function runCompileImports(options) {
+  const { bundle, providers, deferIndex, logger } = options;
+  let importedAny = false;
+  const summaries = [];
+  let tantivy = null;
+  let tantivyError = null;
+  try {
+    if (deferIndex) {
+      logger?.info("disabling FTS5 triggers for deferred indexing");
+      disableFts5Triggers(bundle);
+    }
+    for (const provider of providers) {
+      const sourcePath = resolveCompilePath(options.sessionsPath ?? provider.defaultSessionsPath());
+      const providerLogger = logger?.child({
+        source_tool: provider.name,
+        source_path: sourcePath
+      });
+      providerLogger?.info("starting compile");
+      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"
+      );
+      const summary = {
+        source: provider.name,
+        sourcePath,
+        batchId: r.batch.batch_id,
+        batch: r.batch,
+        counts: r.counts
+      };
+      summaries.push(summary);
+      options.onProviderComplete?.(summary);
+    }
+    logger?.info({ changed: importedAny, fts5_deferred: deferIndex }, "marking indexes");
+    markIndexesAfterImport(bundle, {
+      changed: importedAny,
+      fts5Deferred: deferIndex
+    });
+    if (importedAny) {
       try {
-        if (options.deferIndex) {
-          disableFts5Triggers(bundle);
-        }
-        if (options.codex) {
-          const r = await compileCodex(bundle, path13.resolve(options.codex));
-          importedAny ||= r.counts.source_files_imported > 0;
-          printCounts("codex", r.batch.batch_id, r.counts);
-        }
-        if (options.claude) {
-          const r = await compileClaude(bundle, path13.resolve(options.claude));
-          importedAny ||= r.counts.source_files_imported > 0;
-          printCounts("claude", r.batch.batch_id, r.counts);
-        }
-        if (options.gemini) {
-          const r = await compileGemini(bundle, path13.resolve(options.gemini));
-          importedAny ||= r.counts.source_files_imported > 0;
-          printCounts("gemini", r.batch.batch_id, r.counts);
-        }
-        if (options.cursor) {
-          const r = await compileCursor(bundle, path13.resolve(options.cursor));
-          importedAny ||= r.counts.source_files_imported > 0;
-          printCounts("cursor", r.batch.batch_id, r.counts);
-        }
-        markIndexesAfterImport(bundle, {
-          changed: importedAny,
-          fts5Deferred: options.deferIndex === true
-        });
-      } finally {
-        if (options.deferIndex) {
-          enableFts5Triggers(bundle);
-        }
-        closeBundle(bundle);
+        logger?.info("rebuilding tantivy index");
+        const status = await rebuildTantivyIndex(bundle);
+        tantivy = { indexedDocCount: status.indexed_doc_count };
+        options.onTantivyComplete?.(tantivy);
+      } catch (error) {
+        tantivyError = error instanceof Error ? error.message : String(error);
+        logger?.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
       }
     }
+  } finally {
+    if (deferIndex) {
+      logger?.info("re-enabling FTS5 triggers");
+      enableFts5Triggers(bundle);
+    }
+  }
+  return {
+    providers: summaries,
+    importedAny,
+    tantivy,
+    tantivyError
+  };
+}
+async function exportCompileParquet(options) {
+  const storePath = resolveCompilePath(options.storePath);
+  options.logger?.info({ store_path: storePath }, "exporting parquet");
+  const result = await exportBundleParquet({ bundlePath: storePath });
+  return {
+    outDir: result.outDir,
+    manifestPath: result.manifestPath,
+    tableCount: Object.keys(result.files).length,
+    files: result.files,
+    counts: result.counts
+  };
+}
+
+// src/cli/logger.ts
+import pino from "pino";
+import pretty from "pino-pretty";
+function createCliLogger(options) {
+  const loggerOptions = {
+    base: void 0,
+    level: options.verbose === true ? "debug" : "info"
+  };
+  if (options.jsonLogs === true) {
+    return pino(loggerOptions, pino.destination({ dest: 2, sync: true }));
+  }
+  return pino(
+    loggerOptions,
+    pretty({
+      colorize: process.stderr.isTTY,
+      destination: 2,
+      ignore: "pid,hostname",
+      singleLine: true,
+      sync: true,
+      translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l"
+    })
+  );
+}
+
+// src/cli/commands/compile.ts
+function compileCommand() {
+  const command = addCompileLogOptions(
+    new Command("compile").description(
+      "Import session histories from one agent CLI into the bundle."
+    )
+  );
+  for (const provider of COMPILE_PROVIDERS) {
+    command.addCommand(providerCompileCommand(provider));
+  }
+  command.action(() => {
+    command.help({ error: true });
+  });
+  return command;
+}
+function compileAllCommand() {
+  return addCompileLogOptions(new Command("compile-all")).description("Import all agent CLI session histories using default source paths.").option("--defer-index", "skip immediate FTS5 updates; run `prosa index fts5` later").action(async (options) => {
+    await runCompiles({
+      providers: COMPILE_PROVIDERS,
+      storePath: defaultBundlePath(),
+      deferIndex: options.deferIndex === true,
+      logOptions: options
+    });
+  });
+}
+function providerCompileCommand(provider) {
+  return addCompileLogOptions(new Command(provider.name)).description(provider.description).option(
+    "--sessions-path <path>",
+    `${provider.pathHelp} (default: ${provider.defaultSessionsPath()})`,
+    provider.defaultSessionsPath()
+  ).option("--store <path>", "bundle directory", defaultBundlePath()).option("--defer-index", "skip immediate FTS5 updates; run `prosa index fts5` later").action(
+    async (options, command) => {
+      await runCompiles({
+        providers: [provider],
+        storePath: options.store,
+        deferIndex: options.deferIndex === true,
+        sessionsPath: options.sessionsPath,
+        logOptions: command.optsWithGlobals()
+      });
+    }
   );
 }
-function printCounts(label, batchId, c) {
+function addCompileLogOptions(command) {
+  return command.option("--verbose", "emit debug logs during compilation").option("--json-logs", "emit raw newline-delimited JSON logs instead of pretty logs");
+}
+async function runCompiles(options) {
+  const logger = createCliLogger(options.logOptions);
+  const storePath = resolveCompilePath(options.storePath);
+  logger.info({ store_path: storePath }, "opening bundle");
+  const bundle = await openBundle(storePath);
+  let importedAny = false;
+  try {
+    const result = await runCompileImports({
+      bundle,
+      providers: options.providers,
+      deferIndex: options.deferIndex,
+      sessionsPath: options.sessionsPath,
+      logger,
+      onProviderComplete: printCounts,
+      onTantivyComplete: (status) => {
+        process.stdout.write(`tantivy: indexed ${status.indexedDocCount} docs
+`);
+      }
+    });
+    importedAny = result.importedAny;
+  } finally {
+    closeBundle(bundle);
+    logger.info({ store_path: storePath }, "bundle closed");
+  }
+  if (importedAny) {
+    try {
+      const result = await exportCompileParquet({ storePath, logger });
+      process.stdout.write(`parquet: wrote ${result.tableCount} tables to ${result.outDir}
+`);
+    } catch (error) {
+      logger.error({ err: error }, "parquet export failed; SQLite data is intact");
+    }
+  }
+}
+function printCounts(summary) {
+  const c = summary.counts;
   process.stdout.write(
-    `${label} import: batch=${batchId}
+    `${summary.source} import: batch=${summary.batchId}
   source_files seen=${c.source_files_seen} imported=${c.source_files_imported} skipped=${c.source_files_skipped}
   sessions=${c.sessions} turns=${c.turns} messages=${c.messages} blocks=${c.content_blocks}
   events=${c.events} tool_calls=${c.tool_calls} tool_results=${c.tool_results}
@@ -5419,142 +5984,6 @@ function renderToolCall(c) {
   return lines.join("\n");
 }
 
-// src/services/export/parquet.ts
-import { mkdir as mkdir5, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import path14 from "path";
-import { DuckDBConnection } from "@duckdb/node-api";
-var PARQUET_TABLES = [
-  "objects",
-  "source_files",
-  "import_batches",
-  "raw_records",
-  "import_errors",
-  "uncertainties",
-  "projects",
-  "sessions",
-  "turns",
-  "events",
-  "messages",
-  "content_blocks",
-  "tool_calls",
-  "tool_results",
-  "artifacts",
-  "edges",
-  "search_docs"
-];
-async function exportBundleParquet(options) {
-  const snapshot = await openBundleSnapshot(options.bundlePath);
-  const outDir = path14.resolve(options.outDir ?? snapshot.defaultOutDir);
-  await mkdir5(outDir, { recursive: true });
-  const files = Object.fromEntries(
-    PARQUET_TABLES.map((table) => [table, path14.join(outDir, `${table}.parquet`)])
-  );
-  const manifestPath = path14.join(outDir, "manifest.json");
-  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)`
-      );
-    }
-  } finally {
-    connection.closeSync();
-  }
-  const manifest = {
-    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
-    source_db: snapshot.dbPath,
-    schema_version: snapshot.schemaVersion,
-    parser_version: snapshot.parserVersion,
-    tables: Object.fromEntries(
-      PARQUET_TABLES.map((table) => [
-        table,
-        {
-          file: path14.basename(files[table]),
-          rows: snapshot.counts[table]
-        }
-      ])
-    )
-  };
-  await writeFile5(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  return { outDir, manifestPath, files, counts: snapshot.counts };
-}
-async function queryDuckDbParquet(options) {
-  const parquetDir = path14.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(
-          path14.join(parquetDir, `${table}.parquet`)
-        )})`
-      );
-    }
-    const reader = await connection.runAndReadAll(options.sql);
-    return {
-      columns: reader.deduplicatedColumnNames(),
-      rows: reader.getRowObjectsJson()
-    };
-  } catch (error) {
-    if (isMissingParquetError(error)) {
-      throw new Error(
-        `Parquet export not found in ${parquetDir}; run \`prosa export parquet --store <path>\` first`
-      );
-    }
-    throw error;
-  } finally {
-    connection.closeSync();
-  }
-}
-async function createDuckDbConnection() {
-  return DuckDBConnection.create();
-}
-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: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-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];
-      })
-    );
-    return {
-      dbPath: bundle.paths.db,
-      schemaVersion: bundle.manifest.schema_version,
-      parserVersion: bundle.manifest.parser_version,
-      defaultOutDir: bundle.paths.parquet,
-      counts
-    };
-  } finally {
-    closeBundle(bundle);
-  }
-}
-function quoteIdentifier(value) {
-  return `"${value.replace(/"/g, '""')}"`;
-}
-function sqlString(value) {
-  return `'${value.replace(/'/g, "''")}'`;
-}
-function isMissingParquetError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return /No files found|does not exist|not found/i.test(message) && /\.parquet/i.test(message);
-}
-
 // src/cli/commands/export.ts
 function exportCommand() {
   const session = new Command2("session").description("Export a single session to a human-readable format.").argument("<session-id>", "prosa session_id").requiredOption("--format <fmt>", 'currently only "markdown" is supported').option("--out <path>", "write to file instead of stdout").option("--store <path>", "bundle directory", defaultBundlePath()).action(async (sessionId2, options) => {
@@ -5757,10 +6186,13 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 
 // src/mcp/guidance.ts
 var PROSA_MCP_INSTRUCTIONS = `
-prosa is a read-only memory over local agent session histories. Use it to find prior work,
-commands, decisions, file touches, and full transcripts before answering from memory.
+prosa is a local memory over local agent session histories. Use it to import recent sessions,
+find prior work, commands, decisions, file touches, and full transcripts before answering from
+memory.
 
 Recommended workflow:
+- Use compile to refresh the bundle when recent local sessions may not be indexed yet. With no
+  input it imports all supported providers from default paths.
 - For open-ended questions, start with search_sessions using 2-5 concrete terms.
 - For questions about a file or path, start with find_touched_files, then inspect the returned sessions.
 - After search results, call get_session for the most relevant session_ids before drawing conclusions.
@@ -5810,7 +6242,76 @@ init_search();
 init_sessions();
 function registerProsaTools(server, bundle, options = {}) {
   const searchEngine = options.searchEngine ?? "fts5";
+  const storePath = options.storePath ?? bundle.path;
   registerProsaPrompts(server);
+  server.registerTool(
+    "compile",
+    {
+      title: "Compile sessions",
+      description: "Import local agent session histories into the active prosa bundle. With no input, compiles all providers from default paths. With source, compiles that provider; sessions_path may override that provider path.",
+      inputSchema: {
+        source: z.enum(["cursor", "codex", "claude", "gemini"]).optional(),
+        sessions_path: z.string().min(1).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async ({ source, sessions_path }) => {
+      if (sessions_path && !source) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "sessions_path requires source because providers use incompatible source layouts"
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await runCompileImports({
+          bundle,
+          providers: source ? [getCompileProvider(source)] : COMPILE_PROVIDERS,
+          deferIndex: false,
+          sessionsPath: sessions_path
+        });
+        const parquet = result.importedAny ? await exportCompileParquet({ storePath }) : null;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  providers: result.providers.map((provider) => ({
+                    source: provider.source,
+                    source_path: provider.sourcePath,
+                    batch_id: provider.batchId,
+                    counts: provider.counts
+                  })),
+                  imported_any: result.importedAny,
+                  tantivy: result.tantivy ? { indexed_doc_count: result.tantivy.indexedDocCount } : null,
+                  tantivy_error: result.tantivyError,
+                  parquet: parquet ? {
+                    out_dir: parquet.outDir,
+                    manifest_path: parquet.manifestPath,
+                    table_count: parquet.tableCount,
+                    files: parquet.files,
+                    counts: parquet.counts
+                  } : null
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          isError: true
+        };
+      }
+    }
+  );
   server.registerTool(
     "list_sessions",
     {
@@ -6123,7 +6624,7 @@ function registerProsaPrompts(server) {
 
 // src/mcp/server.ts
 async function listenMcpStdioServer(bundle, options = {}) {
-  const server = createMcpServer(bundle, options.searchEngine ?? "fts5");
+  const server = createMcpServer(bundle, options.searchEngine ?? "fts5", options.storePath);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   return {
@@ -6137,10 +6638,13 @@ async function listenMcpServer(bundle, options) {
   const mcpPath = options.path ?? "/mcp";
   const sessions = /* @__PURE__ */ new Map();
   const searchEngine = options.searchEngine ?? "fts5";
+  const storePath = options.storePath ?? bundle.path;
   const httpServer = http.createServer((req, res) => {
-    handleRequest(req, res, mcpPath, sessions, bundle, searchEngine).catch((error) => {
-      writeError(res, error);
-    });
+    handleRequest(req, res, mcpPath, sessions, bundle, searchEngine, storePath).catch(
+      (error) => {
+        writeError(res, error);
+      }
+    );
   });
   await new Promise((resolve, reject) => {
     httpServer.once("error", reject);
@@ -6163,7 +6667,7 @@ async function listenMcpServer(bundle, options) {
     }
   };
 }
-async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine) {
+async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine, storePath) {
   if (!req.url || !req.url.startsWith(mcpPath)) {
     res.writeHead(404).end();
     return;
@@ -6185,14 +6689,14 @@ async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine)
       res.writeHead(404).end();
       return;
     }
-    entry = await openSession(bundle, sessions, searchEngine);
+    entry = await openSession(bundle, sessions, searchEngine, storePath);
   }
   const bodyText = await readBody(req);
   const body = bodyText.length > 0 ? safeJsonParse(bodyText) : void 0;
   await entry.transport.handleRequest(req, res, body);
 }
-async function openSession(bundle, store, searchEngine) {
-  const server = createMcpServer(bundle, searchEngine);
+async function openSession(bundle, store, searchEngine, storePath) {
+  const server = createMcpServer(bundle, searchEngine, storePath);
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: () => randomUUID(),
     onsessioninitialized: (id) => {
@@ -6210,7 +6714,7 @@ async function openSession(bundle, store, searchEngine) {
   await server.connect(transport);
   return { server, transport };
 }
-function createMcpServer(bundle, searchEngine) {
+function createMcpServer(bundle, searchEngine, storePath) {
   const server = new McpServer(
     {
       name: "prosa",
@@ -6218,7 +6722,7 @@ function createMcpServer(bundle, searchEngine) {
     },
     { instructions: PROSA_MCP_INSTRUCTIONS }
   );
-  registerProsaTools(server, bundle, { searchEngine });
+  registerProsaTools(server, bundle, { searchEngine, storePath });
   return server;
 }
 async function readBody(req) {
@@ -6259,7 +6763,8 @@ function writeError(res, error) {
 function mcpCommand() {
   const serve = new Command5("serve").description("Start a local MCP server over the prosa bundle.").option("--store <path>", "bundle directory", defaultBundlePath()).option("--transport <transport>", "MCP transport: stdio|http", "stdio").option("--host <host>", "bind host", "127.0.0.1").option("--port <port>", "bind port", "7331").option("--path <path>", "HTTP path", "/mcp").option("--search-engine <engine>", "search engine: fts5|tantivy", "fts5").action(
     async (options) => {
-      const bundle = await openBundle(path18.resolve(options.store));
+      const storePath = path18.resolve(options.store);
+      const bundle = await openBundle(storePath);
       try {
         const transport = parseMcpTransport(options.transport);
         const searchEngine = parseSearchEngine(options.searchEngine);
@@ -6272,7 +6777,8 @@ function mcpCommand() {
             host: options.host,
             port,
             path: options.path,
-            searchEngine
+            searchEngine,
+            storePath
           });
           process.stdout.write(`prosa mcp server listening at ${server2.url}
 `);
@@ -6280,7 +6786,7 @@ function mcpCommand() {
           registerShutdown(server2.close, bundle);
           return;
         }
-        const server = await listenMcpStdioServer(bundle, { searchEngine });
+        const server = await listenMcpStdioServer(bundle, { searchEngine, storePath });
         registerShutdown(server.close, bundle);
       } catch (error) {
         closeBundle(bundle);
@@ -6454,6 +6960,7 @@ async function runCli(argv) {
   ).version(PROSA_PARSER_VERSION, "-v, --version");
   program.addCommand(initCommand());
   program.addCommand(compileCommand());
+  program.addCommand(compileAllCommand());
   program.addCommand(indexCommand());
   program.addCommand(sessionsCommand());
   program.addCommand(searchCommand());