@c3-oss/prosa 0.2.0 → 0.3.1

package/dist/bin/prosa.js

@@ -12,8 +12,8 @@ var __export = (target, all) => {
 
 // src/core/db.ts
 import Database from "better-sqlite3";
-function openDb(path23) {
-  const db = new Database(path23);
+function openDb(path20) {
+  const db = new Database(path20);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   db.pragma("synchronous = NORMAL");
@@ -48,6 +48,15 @@ var init_db = __esm({
   }
 });
 
+// src/core/errors.ts
+var getErrorMessage;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    getErrorMessage = (err) => err instanceof Error ? err.message : String(err);
+  }
+});
+
 // src/core/cas/compress.ts
 import { compress as zstdCompress, decompress as zstdDecompress } from "zstd-napi";
 function compressBytes(input) {
@@ -393,7 +402,7 @@ function rebuildFts5Index(bundle) {
       status: "failed",
       sourceDocCount: countSearchDocs(bundle),
       indexedDocCount: countFts5Docs(bundle),
-      errorMessage: error instanceof Error ? error.message : String(error)
+      errorMessage: getErrorMessage(error)
     });
     throw error;
   }
@@ -466,7 +475,7 @@ async function rebuildTantivyIndex(bundle) {
       status: "failed",
       sourceDocCount: countSearchDocs(bundle),
       indexedDocCount: 0,
-      errorMessage: error instanceof Error ? error.message : String(error)
+      errorMessage: getErrorMessage(error)
     });
     throw error;
   }
@@ -514,6 +523,7 @@ var init_indexing = __esm({
   "src/services/indexing.ts"() {
     "use strict";
     init_db();
+    init_errors();
     FTS5_TRIGGER_SQL = `
 CREATE TRIGGER IF NOT EXISTS search_docs_ai AFTER INSERT ON search_docs BEGIN
   INSERT INTO search_docs_fts(rowid, text, role, tool_name, field_kind)
@@ -535,6 +545,16 @@ END;
   }
 });
 
+// src/core/limits.ts
+function clampLimit(value, opts) {
+  return Math.max(opts.min ?? 1, Math.min(opts.max, value ?? opts.fallback));
+}
+var init_limits = __esm({
+  "src/core/limits.ts"() {
+    "use strict";
+  }
+});
+
 // src/services/search.ts
 import { existsSync } from "fs";
 import { createRequire } from "module";
@@ -545,7 +565,7 @@ function searchFullText(bundle, options) {
   if (options.engine === "tantivy") {
     return searchTantivy(bundle, options);
   }
-  const limit = Math.max(1, Math.min(500, options.limit ?? 50));
+  const limit = clampLimit(options.limit, { max: 500, fallback: 50 });
   const sql = `
     SELECT d.doc_id,
            d.entity_type,
@@ -576,7 +596,7 @@ function searchTantivy(bundle, options) {
       `tantivy index is ${status?.status ?? "missing"}; run \`prosa index tantivy\` first`
     );
   }
-  const limit = Math.max(1, Math.min(500, options.limit ?? 50));
+  const limit = clampLimit(options.limit, { max: 500, fallback: 50 });
   const queryText = options.query.trim();
   if (!queryText) return [];
   const tantivy = requireTantivy();
@@ -610,9 +630,7 @@ function requireTantivy() {
   try {
     return require2("@oxdev03/node-tantivy-binding");
   } catch (error) {
-    throw new Error(
-      `tantivy engine is unavailable: ${error instanceof Error ? error.message : String(error)}`
-    );
+    throw new Error(`tantivy engine is unavailable: ${getErrorMessage(error)}`);
   }
 }
 function getStoredText(doc, field) {
@@ -641,6 +659,8 @@ var require2;
 var init_search = __esm({
   "src/services/search.ts"() {
     "use strict";
+    init_errors();
+    init_limits();
     init_indexing();
     require2 = createRequire(import.meta.url);
   }
@@ -669,7 +689,7 @@ function sessionFilterWhere(filters) {
 }
 function listSessions(bundle, filters = {}) {
   const { where, params } = sessionFilterWhere(filters);
-  const limit = Math.max(1, Math.min(1e3, filters.limit ?? 50));
+  const limit = clampLimit(filters.limit, { max: 1e3, fallback: 50 });
   const sql = `
     SELECT s.session_id,
            s.source_tool,
@@ -743,6 +763,7 @@ function getSession(bundle, sessionId2) {
 var init_sessions = __esm({
   "src/services/sessions.ts"() {
     "use strict";
+    init_limits();
   }
 });
 
@@ -1120,8 +1141,6 @@ var PROSA_PARSER_VERSION = "0.1.0";
 var PROSA_SCHEMA_VERSION = 2;
 
 // src/cli/commands/compile.ts
-import os2 from "os";
-import path14 from "path";
 import { Command } from "commander";
 
 // src/core/bundle.ts
@@ -1627,6 +1646,11 @@ function closeBundle(bundle) {
   closeDb(bundle.db);
 }
 
+// src/services/compile.ts
+init_errors();
+import os2 from "os";
+import path14 from "path";
+
 // src/importers/claude/index.ts
 init_cas();
 init_db();
@@ -1676,6 +1700,9 @@ function importBatchId(sourceTool, startedAtIso) {
   return tupleId(["import_batch", sourceTool, startedAtIso, String(Math.random())]);
 }
 
+// src/importers/claude/index.ts
+init_errors();
+
 // src/core/ingest/batch.ts
 init_cas();
 init_db();
@@ -1965,7 +1992,7 @@ async function compileClaude(bundle, root, options = {}) {
         );
         await recordError(bundle, batch.batch_id, {
           kind: "claude_file_failed",
-          message: error instanceof Error ? error.message : String(error),
+          message: getErrorMessage(error),
           payload: { path: file.filePath }
         });
       }
@@ -2880,6 +2907,7 @@ init_cas();
 init_db();
 import { readFile as readFile5 } from "fs/promises";
 import path7 from "path";
+init_errors();
 
 // src/importers/codex/discover.ts
 import { readdir as readdir2 } from "fs/promises";
@@ -2929,7 +2957,7 @@ async function compileCodex(bundle, root, options = {}) {
         );
         await recordError(bundle, batch.batch_id, {
           kind: "codex_file_failed",
-          message: error instanceof Error ? error.message : String(error),
+          message: getErrorMessage(error),
           payload: { path: filePath }
         });
       }
@@ -4020,6 +4048,7 @@ init_cas();
 init_db();
 import path9 from "path";
 import Database2 from "better-sqlite3";
+init_errors();
 
 // src/importers/cursor/discover.ts
 import { readdir as readdir3 } from "fs/promises";
@@ -4084,7 +4113,7 @@ async function compileCursor(bundle, root, options = {}) {
         );
         await recordError(bundle, batch.batch_id, {
           kind: "cursor_store_failed",
-          message: error instanceof Error ? error.message : String(error),
+          message: getErrorMessage(error),
           payload: { path: store.filePath }
         });
       }
@@ -4739,6 +4768,7 @@ init_cas();
 init_db();
 import { readFile as readFile7 } from "fs/promises";
 import path11 from "path";
+init_errors();
 
 // src/importers/gemini/discover.ts
 import { readFile as readFile6, readdir as readdir4 } from "fs/promises";
@@ -4810,7 +4840,7 @@ async function compileGemini(bundle, root, options = {}) {
         );
         await recordError(bundle, batch.batch_id, {
           kind: "gemini_file_failed",
-          message: error instanceof Error ? error.message : String(error),
+          message: getErrorMessage(error),
           payload: { path: file.filePath }
         });
       }
@@ -5496,6 +5526,7 @@ function flushPending4(bundle, pending) {
 import { mkdir as mkdir3, rm, writeFile as writeFile4 } from "fs/promises";
 import path12 from "path";
 import { DuckDBConnection } from "@duckdb/node-api";
+init_errors();
 var PARQUET_TABLES = [
   "objects",
   "source_files",
@@ -5593,7 +5624,7 @@ async function attachSqlite(connection, dbPath) {
     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)}`
+      `DuckDB could not attach prosa.sqlite via the sqlite extension: ${getErrorMessage(error)}`
     );
   }
 }
@@ -5624,39 +5655,13 @@ function sqlString(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function isMissingParquetError(error) {
-  const message = error instanceof Error ? error.message : String(error);
+  const message = getErrorMessage(error);
   return /No files found|does not exist|not found/i.test(message) && /\.parquet/i.test(message);
 }
 
-// src/cli/commands/compile.ts
+// src/services/compile.ts
 init_indexing();
-
-// 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
-var PROVIDERS = [
+var COMPILE_PROVIDERS = [
   {
     name: "codex",
     description: "Import Codex CLI session histories into the bundle.",
@@ -5686,13 +5691,129 @@ var PROVIDERS = [
     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 {
+        logger?.info("rebuilding tantivy index");
+        const status = await rebuildTantivyIndex(bundle);
+        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");
+      }
+    }
+  } 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 ? "debug" : "info"
+  };
+  if (options.jsonLogs) {
+    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 PROVIDERS) {
+  for (const provider of COMPILE_PROVIDERS) {
     command.addCommand(providerCompileCommand(provider));
   }
   command.action(() => {
@@ -5703,9 +5824,9 @@ function compileCommand() {
 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: PROVIDERS,
+      providers: COMPILE_PROVIDERS,
       storePath: defaultBundlePath(),
-      deferIndex: options.deferIndex === true,
+      deferIndex: options.deferIndex ?? false,
       logOptions: options
     });
   });
@@ -5720,7 +5841,7 @@ function providerCompileCommand(provider) {
       await runCompiles({
         providers: [provider],
         storePath: options.store,
-        deferIndex: options.deferIndex === true,
+        deferIndex: options.deferIndex ?? false,
         sessionsPath: options.sessionsPath,
         logOptions: command.optsWithGlobals()
       });
@@ -5732,76 +5853,42 @@ function addCompileLogOptions(command) {
 }
 async function runCompiles(options) {
   const logger = createCliLogger(options.logOptions);
-  const storePath = resolvePath(options.storePath);
+  const storePath = resolveCompilePath(options.storePath);
   logger.info({ store_path: storePath }, "opening bundle");
   const bundle = await openBundle(storePath);
   let importedAny = false;
   try {
-    if (options.deferIndex) {
-      logger.info("disabling FTS5 triggers for deferred indexing");
-      disableFts5Triggers(bundle);
-    }
-    for (const provider of options.providers) {
-      const sourcePath = resolvePath(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"
-      );
-      printCounts(provider.name, r.batch.batch_id, r.counts);
-    }
-    logger.info({ changed: importedAny, fts5_deferred: options.deferIndex }, "marking indexes");
-    markIndexesAfterImport(bundle, {
-      changed: importedAny,
-      fts5Deferred: options.deferIndex
-    });
-    if (importedAny) {
-      try {
-        logger.info("rebuilding tantivy index");
-        const status = await rebuildTantivyIndex(bundle);
-        process.stdout.write(`tantivy: indexed ${status.indexed_doc_count} docs
+    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
 `);
-      } catch (error) {
-        logger.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
       }
-    }
+    });
+    importedAny = result.importedAny;
   } finally {
-    if (options.deferIndex) {
-      logger.info("re-enabling FTS5 triggers");
-      enableFts5Triggers(bundle);
-    }
     closeBundle(bundle);
     logger.info({ store_path: storePath }, "bundle closed");
   }
   if (importedAny) {
     try {
-      logger.info({ store_path: storePath }, "exporting parquet");
-      const result = await exportBundleParquet({ bundlePath: storePath });
-      const tableCount = Object.keys(result.files).length;
-      process.stdout.write(`parquet: wrote ${tableCount} tables to ${result.outDir}
+      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 resolvePath(p) {
-  if (p === "~") return os2.homedir();
-  if (p.startsWith("~/")) return path14.join(os2.homedir(), p.slice(2));
-  return path14.resolve(p);
-}
-function printCounts(label, batchId, c) {
+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}
@@ -5812,7 +5899,7 @@ function printCounts(label, batchId, c) {
 
 // src/cli/commands/export.ts
 import { writeFile as writeFile6 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import { Command as Command2 } from "commander";
 
 // src/services/export/markdown.ts
@@ -5926,30 +6013,38 @@ function renderToolCall(c) {
   return lines.join("\n");
 }
 
+// src/cli/bundle.ts
+import path15 from "path";
+async function withBundle(storePath, fn) {
+  const bundle = await openBundle(path15.resolve(storePath));
+  try {
+    return await fn(bundle);
+  } finally {
+    closeBundle(bundle);
+  }
+}
+
 // 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) => {
     if (options.format !== "markdown") {
       throw new Error(`unsupported format: ${options.format} (try --format markdown)`);
     }
-    const bundle = await openBundle(path15.resolve(options.store));
-    try {
+    await withBundle(options.store, async (bundle) => {
       const markdown = await exportSessionMarkdown(bundle, sessionId2);
       if (options.out) {
-        await writeFile6(path15.resolve(options.out), markdown, "utf8");
-        process.stdout.write(`wrote ${path15.resolve(options.out)}
+        await writeFile6(path16.resolve(options.out), markdown, "utf8");
+        process.stdout.write(`wrote ${path16.resolve(options.out)}
 `);
       } else {
         process.stdout.write(markdown);
       }
-    } finally {
-      closeBundle(bundle);
-    }
+    });
   });
   const parquet = new Command2("parquet").description("Export canonical tables to derived Parquet files for analytics.").option("--store <path>", "bundle directory", defaultBundlePath()).option("--out <path>", "output directory (default: <store>/parquet)").action(async (options) => {
     const result = await exportBundleParquet({
-      bundlePath: path15.resolve(options.store),
-      outDir: options.out ? path15.resolve(options.out) : void 0
+      bundlePath: path16.resolve(options.store),
+      outDir: options.out ? path16.resolve(options.out) : void 0
     });
     process.stdout.write(`wrote parquet export to ${result.outDir}
 `);
@@ -5960,12 +6055,13 @@ function exportCommand() {
 }
 
 // src/cli/commands/index.ts
-import path16 from "path";
 import { Command as Command3 } from "commander";
 init_indexing();
 
 // src/cli/output.ts
 var OUTPUT_FORMATS = ["interactive", "table", "json", "csv"];
+var COL_SEPARATOR = "  ";
+var RULE_CHAR = "-";
 function parseOutputFormat(value, fallback) {
   if (value === void 0) return fallback;
   if (OUTPUT_FORMATS.includes(value)) return value;
@@ -5993,11 +6089,12 @@ function printJson(rows, opts) {
 `);
 }
 function printCsv(rows, opts) {
-  const cols = opts.columns;
-  process.stdout.write(`${cols.map(csvField).join(",")}
+  const columns = opts.columns;
+  process.stdout.write(`${columns.map(csvField).join(",")}
 `);
   for (const row of rows) {
-    const line = cols.map((c) => csvField(formatCell(row[c]))).join(",");
+    const record = row;
+    const line = columns.map((column) => csvField(formatCell(record[column]))).join(",");
     process.stdout.write(`${line}
 `);
   }
@@ -6007,23 +6104,24 @@ function csvField(value) {
   return value;
 }
 function printTable(rows, opts) {
-  const cols = opts.columns;
-  const widths = cols.map((c) => c.length);
-  const cells = rows.map(
-    (row) => cols.map((col, i) => {
-      const text = formatCell(row[col]);
-      const w = widths[i] ?? 0;
-      if (text.length > w) widths[i] = text.length;
+  const columns = opts.columns;
+  const widths = columns.map((column) => column.length);
+  const cells = rows.map((row) => {
+    const record = row;
+    return columns.map((column, index) => {
+      const text = formatCell(record[column]);
+      const width = widths[index] ?? 0;
+      if (text.length > width) widths[index] = text.length;
       return text;
-    })
-  );
-  const header = cols.map((c, i) => c.padEnd(widths[i] ?? 0)).join("  ");
-  const sep = cols.map((_, i) => "-".repeat(widths[i] ?? 0)).join("  ");
+    });
+  });
+  const header = columns.map((column, index) => column.padEnd(widths[index] ?? 0)).join(COL_SEPARATOR);
+  const rule = columns.map((_, index) => RULE_CHAR.repeat(widths[index] ?? 0)).join(COL_SEPARATOR);
   process.stdout.write(`${header}
-${sep}
+${rule}
 `);
   for (const cellRow of cells) {
-    const line = cellRow.map((c, i) => c.padEnd(widths[i] ?? 0)).join("  ");
+    const line = cellRow.map((cell, index) => cell.padEnd(widths[index] ?? 0)).join(COL_SEPARATOR);
     process.stdout.write(`${line}
 `);
   }
@@ -6038,27 +6136,18 @@ function formatCell(value) {
 // src/cli/commands/index.ts
 function indexCommand() {
   const fts5 = new Command3("fts5").description("Rebuild the SQLite FTS5 index from search_docs.").option("--store <path>", "bundle directory", defaultBundlePath()).action(async (options) => {
-    const bundle = await openBundle(path16.resolve(options.store));
-    try {
-      const status2 = rebuildFts5Index(bundle);
-      printIndexStatus(status2);
-    } finally {
-      closeBundle(bundle);
-    }
+    await withBundle(options.store, (bundle) => {
+      printIndexStatus(rebuildFts5Index(bundle));
+    });
   });
   const tantivy = new Command3("tantivy").description("Rebuild the Tantivy sidecar index from search_docs.").option("--store <path>", "bundle directory", defaultBundlePath()).action(async (options) => {
-    const bundle = await openBundle(path16.resolve(options.store));
-    try {
-      const status2 = await rebuildTantivyIndex(bundle);
-      printIndexStatus(status2);
-    } finally {
-      closeBundle(bundle);
-    }
+    await withBundle(options.store, async (bundle) => {
+      printIndexStatus(await rebuildTantivyIndex(bundle));
+    });
   });
   const status = new Command3("status").description("Show derived search index status.").option("--store <path>", "bundle directory", defaultBundlePath()).option("--output-format <fmt>", "interactive|table|json|csv", "table").action(async (options) => {
     const format = parseOutputFormat(options.outputFormat, "table");
-    const bundle = await openBundle(path16.resolve(options.store));
-    try {
+    await withBundle(options.store, (bundle) => {
       const rows = getSearchIndexStatuses(bundle);
       printRows(rows, {
         format,
@@ -6071,9 +6160,7 @@ function indexCommand() {
           "error_message"
         ]
       });
-    } finally {
-      closeBundle(bundle);
-    }
+    });
   });
   return new Command3("index").description("Build or inspect derived search indexes.").addCommand(fts5).addCommand(tantivy).addCommand(status);
 }
@@ -6120,6 +6207,7 @@ import path18 from "path";
 import { Command as Command5 } from "commander";
 
 // src/mcp/server.ts
+init_errors();
 import { randomUUID } from "crypto";
 import http from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -6128,10 +6216,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.
@@ -6176,19 +6267,95 @@ Use this workflow:
 
 // src/mcp/tools.ts
 import { z } from "zod";
+
+// src/core/domain/types.ts
+var SOURCE_TOOLS = ["cursor", "codex", "claude", "gemini"];
+
+// src/mcp/tools.ts
+init_errors();
+init_limits();
 init_indexing();
 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(SOURCE_TOOLS).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: getErrorMessage(error) }],
+          isError: true
+        };
+      }
+    }
+  );
   server.registerTool(
     "list_sessions",
     {
       title: "List sessions",
       description: "List recent sessions when you need candidates by source/date before deeper inspection. Next step: call get_session for relevant session_id values.",
       inputSchema: {
-        source: z.enum(["cursor", "codex", "claude", "gemini"]).optional(),
+        source: z.enum(SOURCE_TOOLS).optional(),
         since: z.string().optional().describe("ISO timestamp lower bound (inclusive)"),
         until: z.string().optional().describe("ISO timestamp upper bound (exclusive)"),
         limit: z.number().int().min(1).max(500).optional().default(50)
@@ -6274,7 +6441,7 @@ function registerProsaTools(server, bundle, options = {}) {
         return { content: [{ type: "text", text: md }] };
       } catch (error) {
         return {
-          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          content: [{ type: "text", text: getErrorMessage(error) }],
           isError: true
         };
       }
@@ -6333,7 +6500,7 @@ function registerProsaTools(server, bundle, options = {}) {
           LEFT JOIN tool_results tr ON tr.tool_call_id = tc.tool_call_id
           ${where}
          ORDER BY tc.timestamp_start DESC
-         LIMIT ${Math.max(1, Math.min(500, limit ?? 100))}
+         LIMIT ${clampLimit(limit, { max: 500, fallback: 100 })}
       `;
       const rows = bundle.db.prepare(sql).all(...params);
       return {
@@ -6364,7 +6531,7 @@ function registerProsaTools(server, bundle, options = {}) {
           FROM artifacts a
          WHERE a.path IS NOT NULL AND a.path LIKE ?
          ORDER BY timestamp_start DESC
-         LIMIT ${Math.max(1, Math.min(500, limit ?? 100))}
+         LIMIT ${clampLimit(limit, { max: 500, fallback: 100 })}
       `;
       const like = `%${path_substring}%`;
       const rows = bundle.db.prepare(sql).all(like, like);
@@ -6452,14 +6619,14 @@ function registerProsaPrompts(server) {
         path: z.string().min(1).describe("File path, directory, or distinctive path suffix")
       }
     },
-    ({ path: path23 }) => ({
+    ({ path: path20 }) => ({
       description: "Find sessions that touched a path and summarize the evidence.",
       messages: [
         {
           role: "user",
           content: {
             type: "text",
-            text: FIND_FILE_HISTORY_PROMPT.replace("{{path}}", path23)
+            text: FIND_FILE_HISTORY_PROMPT.replace("{{path}}", path20)
           }
         }
       ]
@@ -6494,7 +6661,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 {
@@ -6508,10 +6675,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);
@@ -6534,7 +6704,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;
@@ -6556,14 +6726,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) => {
@@ -6581,7 +6751,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",
@@ -6589,7 +6759,7 @@ function createMcpServer(bundle, searchEngine) {
     },
     { instructions: PROSA_MCP_INSTRUCTIONS }
   );
-  registerProsaTools(server, bundle, { searchEngine });
+  registerProsaTools(server, bundle, { searchEngine, storePath });
   return server;
 }
 async function readBody(req) {
@@ -6620,17 +6790,33 @@ function writeError(res, error) {
   res.end(
     JSON.stringify({
       jsonrpc: "2.0",
-      error: { code: -32603, message: error instanceof Error ? error.message : String(error) },
+      error: { code: -32603, message: getErrorMessage(error) },
       id: null
     })
   );
 }
 
+// src/cli/parsers.ts
+function parseSearchEngine(value) {
+  if (value === "fts5" || value === "tantivy") return value;
+  throw new Error(`invalid search engine: ${value} (expected fts5 or tantivy)`);
+}
+function parseMcpTransport(value) {
+  if (value === "stdio" || value === "http") return value;
+  throw new Error(`invalid transport: ${value} (expected stdio or http)`);
+}
+function parseSourceTool(value) {
+  if (value === void 0) return void 0;
+  if (SOURCE_TOOLS.includes(value)) return value;
+  throw new Error(`invalid source tool: ${value} (expected one of ${SOURCE_TOOLS.join(", ")})`);
+}
+
 // src/cli/commands/mcp.ts
 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);
@@ -6643,7 +6829,8 @@ function mcpCommand() {
             host: options.host,
             port,
             path: options.path,
-            searchEngine
+            searchEngine,
+            storePath
           });
           process.stdout.write(`prosa mcp server listening at ${server2.url}
 `);
@@ -6651,7 +6838,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);
@@ -6661,14 +6848,6 @@ function mcpCommand() {
   );
   return new Command5("mcp").description("MCP server commands.").addCommand(serve);
 }
-function parseMcpTransport(value) {
-  if (value === "stdio" || value === "http") return value;
-  throw new Error(`invalid --transport: ${value} (expected stdio or http)`);
-}
-function parseSearchEngine(value) {
-  if (value === "fts5" || value === "tantivy") return value;
-  throw new Error(`invalid --search-engine: ${value} (expected fts5 or tantivy)`);
-}
 function registerShutdown(closeServer, bundle) {
   const shutdown = async () => {
     await closeServer();
@@ -6690,7 +6869,7 @@ function queryCommand() {
   const duckdb = new Command6("duckdb").description("Run a DuckDB SQL query over exported Parquet tables.").argument("<sql>", "DuckDB SQL query").option("--store <path>", "bundle directory", defaultBundlePath()).option("--parquet-dir <path>", "Parquet directory (default: <store>/parquet)").option("--output-format <fmt>", "interactive|table|json|csv", "table").action(
     async (sql, options) => {
       const format = parseOutputFormat(options.outputFormat, "table");
-      const parquetDir = options.parquetDir ? path19.resolve(options.parquetDir) : await defaultParquetDir(path19.resolve(options.store));
+      const parquetDir = options.parquetDir ? path19.resolve(options.parquetDir) : await withBundle(options.store, (bundle) => bundle.paths.parquet);
       const result = await queryDuckDbParquet({ parquetDir, sql });
       printRows(result.rows, {
         format,
@@ -6701,26 +6880,16 @@ function queryCommand() {
   );
   return new Command6("query").description("Run derived analytical queries.").addCommand(duckdb);
 }
-async function defaultParquetDir(storePath) {
-  const bundle = await openBundle(storePath);
-  try {
-    return bundle.paths.parquet;
-  } finally {
-    closeBundle(bundle);
-  }
-}
 
 // src/cli/commands/search.ts
-import path20 from "path";
 import { Command as Command7 } from "commander";
 init_search();
 function searchCommand() {
   return new Command7("search").description("Full-text search across messages, tool calls and tool outputs.").argument("<query>", "FTS5 query string (supports MATCH syntax)").option("--store <path>", "bundle directory", defaultBundlePath()).option("--limit <n>", "maximum hits", "50").option("--engine <engine>", "search engine: fts5|tantivy", "fts5").option("--output-format <fmt>", "interactive|table|json|csv", "table").action(
     async (query, options) => {
-      const engine = parseSearchEngine2(options.engine);
+      const engine = parseSearchEngine(options.engine);
       const format = parseOutputFormat(options.outputFormat, "table");
-      const bundle = await openBundle(path20.resolve(options.store));
-      try {
+      await withBundle(options.store, (bundle) => {
         const hits = searchFullText(bundle, {
           query,
           limit: Number.parseInt(options.limit, 10),
@@ -6731,29 +6900,21 @@ function searchCommand() {
           columns: ["timestamp", "role", "tool_name", "session_id", "snippet"],
           meta: { query, engine, count: hits.length }
         });
-      } finally {
-        closeBundle(bundle);
-      }
+      });
     }
   );
 }
-function parseSearchEngine2(value) {
-  if (value === "fts5" || value === "tantivy") return value;
-  throw new Error(`invalid --engine: ${value} (expected fts5 or tantivy)`);
-}
 
 // src/cli/commands/sessions.ts
-import path21 from "path";
 import { Command as Command8 } from "commander";
 init_sessions();
 function sessionsCommand() {
   const command = new Command8("sessions").description("List sessions in the bundle, with filters.").enablePositionalOptions().option("--store <path>", "bundle directory", defaultBundlePath()).option("--source <tool>", "filter by source tool: cursor|codex|claude|gemini").option("--since <iso>", "sessions starting on/after this ISO timestamp").option("--until <iso>", "sessions starting before this ISO timestamp").option("--limit <n>", "maximum rows", "50").option("--output-format <fmt>", "interactive|table|json|csv", "table").action(
     async (options) => {
       const format = parseOutputFormat(options.outputFormat, "table");
-      const bundle = await openBundle(path21.resolve(options.store));
-      try {
+      await withBundle(options.store, (bundle) => {
         const rows = listSessions(bundle, {
-          sourceTool: options.source,
+          sourceTool: parseSourceTool(options.source),
           sinceIso: options.since,
           untilIso: options.until,
           limit: Number.parseInt(options.limit, 10)
@@ -6771,26 +6932,21 @@ function sessionsCommand() {
             "title"
           ]
         });
-      } finally {
-        closeBundle(bundle);
-      }
+      });
     }
   );
   command.addCommand(
     new Command8("count").description("Count sessions in the bundle, with filters.").option("--store <path>", "bundle directory", defaultBundlePath()).option("--source <tool>", "filter by source tool: cursor|codex|claude|gemini").option("--since <iso>", "sessions starting on/after this ISO timestamp").option("--until <iso>", "sessions starting before this ISO timestamp").action(
       async (options) => {
-        const bundle = await openBundle(path21.resolve(options.store));
-        try {
+        await withBundle(options.store, (bundle) => {
           const count = countSessions(bundle, {
-            sourceTool: options.source,
+            sourceTool: parseSourceTool(options.source),
             sinceIso: options.since,
             untilIso: options.until
           });
           process.stdout.write(`${count}
 `);
-        } finally {
-          closeBundle(bundle);
-        }
+        });
       }
     )
   );
@@ -6798,7 +6954,6 @@ function sessionsCommand() {
 }
 
 // src/cli/commands/tui.ts
-import path22 from "path";
 import { Command as Command9 } from "commander";
 function tuiCommand() {
   return new Command9("tui").description("Open the interactive Ink-based explorer.").option("--store <path>", "bundle directory", defaultBundlePath()).action(async (options) => {
@@ -6807,14 +6962,11 @@ function tuiCommand() {
       import("react"),
       Promise.resolve().then(() => (init_App(), App_exports))
     ]);
-    const bundle = await openBundle(path22.resolve(options.store));
-    try {
+    await withBundle(options.store, async (bundle) => {
       console.clear();
       const app = render(React.createElement(App2, { bundle }));
       await app.waitUntilExit();
-    } finally {
-      closeBundle(bundle);
-    }
+    });
   });
 }