@c3-oss/prosa 0.3.0 → 0.3.2

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();
   }
 });
 
@@ -1621,11 +1642,24 @@ async function openBundle(rootPath) {
   }
   return { path: resolved, db, manifest, paths };
 }
+async function openOrInitBundle(rootPath) {
+  const resolved = path.resolve(rootPath);
+  const paths = bundlePaths(resolved);
+  const dirStat = await stat(resolved).catch(() => null);
+  if (dirStat && !dirStat.isDirectory()) {
+    throw new Error(`bundle path not found or not a directory: ${resolved}`);
+  }
+  if (!dirStat || !await exists(paths.manifest)) {
+    return await initBundle(resolved);
+  }
+  return await openBundle(resolved);
+}
 function closeBundle(bundle) {
   closeDb(bundle.db);
 }
 
 // src/services/compile.ts
+init_errors();
 import os2 from "os";
 import path14 from "path";
 
@@ -1678,6 +1712,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();
@@ -1967,7 +2004,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 }
         });
       }
@@ -2882,6 +2919,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";
@@ -2931,7 +2969,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 }
         });
       }
@@ -4022,6 +4060,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";
@@ -4086,7 +4125,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 }
         });
       }
@@ -4741,6 +4780,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";
@@ -4812,7 +4852,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 }
         });
       }
@@ -5498,6 +5538,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",
@@ -5595,7 +5636,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)}`
     );
   }
 }
@@ -5626,7 +5667,7 @@ 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);
 }
 
@@ -5723,7 +5764,7 @@ async function runCompileImports(options) {
         tantivy = { indexedDocCount: status.indexed_doc_count };
         options.onTantivyComplete?.(tantivy);
       } catch (error) {
-        tantivyError = error instanceof Error ? error.message : String(error);
+        tantivyError = getErrorMessage(error);
         logger?.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
       }
     }
@@ -5759,9 +5800,9 @@ import pretty from "pino-pretty";
 function createCliLogger(options) {
   const loggerOptions = {
     base: void 0,
-    level: options.verbose === true ? "debug" : "info"
+    level: options.verbose ? "debug" : "info"
   };
-  if (options.jsonLogs === true) {
+  if (options.jsonLogs) {
     return pino(loggerOptions, pino.destination({ dest: 2, sync: true }));
   }
   return pino(
@@ -5797,7 +5838,7 @@ function compileAllCommand() {
     await runCompiles({
       providers: COMPILE_PROVIDERS,
       storePath: defaultBundlePath(),
-      deferIndex: options.deferIndex === true,
+      deferIndex: options.deferIndex ?? false,
       logOptions: options
     });
   });
@@ -5812,7 +5853,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()
       });
@@ -5870,7 +5911,7 @@ function printCounts(summary) {
 
 // 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
@@ -5984,30 +6025,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}
 `);
@@ -6018,12 +6067,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;
@@ -6051,11 +6101,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}
 `);
   }
@@ -6065,23 +6116,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}
 `);
   }
@@ -6096,27 +6148,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,
@@ -6129,9 +6172,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);
 }
@@ -6178,6 +6219,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";
@@ -6237,12 +6279,20 @@ 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;
+  const ensureStore = options.ensureStore ?? false;
   registerProsaPrompts(server);
   server.registerTool(
     "compile",
@@ -6250,12 +6300,12 @@ function registerProsaTools(server, bundle, options = {}) {
       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(),
+        source: z.enum(SOURCE_TOOLS).optional(),
         sessions_path: z.string().min(1).optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
     },
-    async ({ source, sessions_path }) => {
+    async ({ source, sessions_path }) => withToolBundle(bundle, storePath, ensureStore, async (activeBundle) => {
       if (sessions_path && !source) {
         return {
           content: [
@@ -6269,7 +6319,7 @@ function registerProsaTools(server, bundle, options = {}) {
       }
       try {
         const result = await runCompileImports({
-          bundle,
+          bundle: activeBundle,
           providers: source ? [getCompileProvider(source)] : COMPILE_PROVIDERS,
           deferIndex: false,
           sessionsPath: sessions_path
@@ -6306,11 +6356,11 @@ function registerProsaTools(server, bundle, options = {}) {
         };
       } catch (error) {
         return {
-          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          content: [{ type: "text", text: getErrorMessage(error) }],
           isError: true
         };
       }
-    }
+    })
   );
   server.registerTool(
     "list_sessions",
@@ -6318,15 +6368,15 @@ function registerProsaTools(server, bundle, options = {}) {
       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)
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async (input) => {
-      const rows = listSessions(bundle, {
+    async (input) => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
+      const rows = listSessions(activeBundle, {
         sourceTool: input.source,
         sinceIso: input.since,
         untilIso: input.until,
@@ -6335,7 +6385,7 @@ function registerProsaTools(server, bundle, options = {}) {
       return {
         content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
       };
-    }
+    })
   );
   server.registerTool(
     "get_session",
@@ -6347,8 +6397,8 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ session_id }) => {
-      const detail = getSession(bundle, session_id);
+    async ({ session_id }) => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
+      const detail = getSession(activeBundle, session_id);
       if (!detail) {
         return {
           content: [{ type: "text", text: `session not found: ${session_id}` }],
@@ -6358,7 +6408,7 @@ function registerProsaTools(server, bundle, options = {}) {
       return {
         content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
       };
-    }
+    })
   );
   server.registerTool(
     "search_sessions",
@@ -6372,8 +6422,13 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ query, limit, raw }) => {
-      const hits = searchFullText(bundle, { query, limit: limit ?? 50, raw, engine: searchEngine });
+    async ({ query, limit, raw }) => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
+      const hits = searchFullText(activeBundle, {
+        query,
+        limit: limit ?? 50,
+        raw,
+        engine: searchEngine
+      });
       return {
         content: [
           {
@@ -6386,7 +6441,7 @@ function registerProsaTools(server, bundle, options = {}) {
           }
         ]
       };
-    }
+    })
   );
   server.registerTool(
     "export_session_markdown",
@@ -6398,17 +6453,17 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ session_id }) => {
+    async ({ session_id }) => withToolBundle(bundle, storePath, ensureStore, async (activeBundle) => {
       try {
-        const md = await exportSessionMarkdown(bundle, session_id);
+        const md = await exportSessionMarkdown(activeBundle, session_id);
         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
         };
       }
-    }
+    })
   );
   server.registerTool(
     "list_tool_calls",
@@ -6435,7 +6490,7 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ tool_name, canonical_type, session_id, errors_only, limit }) => {
+    async ({ tool_name, canonical_type, session_id, errors_only, limit }) => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
       const conds = [];
       const params = [];
       if (tool_name) {
@@ -6463,13 +6518,13 @@ 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);
+      const rows = activeBundle.db.prepare(sql).all(...params);
       return {
         content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
       };
-    }
+    })
   );
   server.registerTool(
     "find_touched_files",
@@ -6482,7 +6537,7 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ path_substring, limit }) => {
+    async ({ path_substring, limit }) => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
       const sql = `
         SELECT tc.session_id, tc.tool_name, tc.canonical_tool_type, tc.path,
                tc.timestamp_start, tc.command
@@ -6494,14 +6549,14 @@ 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);
+      const rows = activeBundle.db.prepare(sql).all(like, like);
       return {
         content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
       };
-    }
+    })
   );
   server.registerTool(
     "get_artifact",
@@ -6513,8 +6568,8 @@ function registerProsaTools(server, bundle, options = {}) {
       },
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async ({ artifact_id }) => {
-      const row = bundle.db.prepare(`SELECT text_object_id, object_id, mime_type FROM artifacts WHERE artifact_id = ?`).get(artifact_id);
+    async ({ artifact_id }) => withToolBundle(bundle, storePath, ensureStore, async (activeBundle) => {
+      const row = activeBundle.db.prepare(`SELECT text_object_id, object_id, mime_type FROM artifacts WHERE artifact_id = ?`).get(artifact_id);
       if (!row) {
         return {
           content: [{ type: "text", text: `artifact not found: ${artifact_id}` }],
@@ -6527,12 +6582,12 @@ function registerProsaTools(server, bundle, options = {}) {
       }
       try {
         const { getText: getText2 } = await Promise.resolve().then(() => (init_cas(), cas_exports));
-        const text = await getText2(bundle, objectId);
+        const text = await getText2(activeBundle, objectId);
         return { content: [{ type: "text", text }] };
       } catch {
         return { content: [{ type: "text", text: `[binary artifact: ${objectId}]` }] };
       }
-    }
+    })
   );
   server.registerTool(
     "index_status",
@@ -6542,14 +6597,25 @@ function registerProsaTools(server, bundle, options = {}) {
       inputSchema: {},
       annotations: { readOnlyHint: true, idempotentHint: true }
     },
-    async () => {
-      const rows = getSearchIndexStatuses(bundle);
+    async () => withToolBundle(bundle, storePath, ensureStore, (activeBundle) => {
+      const rows = getSearchIndexStatuses(activeBundle);
       return {
         content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
       };
-    }
+    })
   );
 }
+async function withToolBundle(fallbackBundle, storePath, ensureStore, fn) {
+  if (!ensureStore) {
+    return await fn(fallbackBundle);
+  }
+  const bundle = await openOrInitBundle(storePath);
+  try {
+    return await fn(bundle);
+  } finally {
+    closeBundle(bundle);
+  }
+}
 function registerProsaPrompts(server) {
   server.registerPrompt(
     "investigate_prior_work",
@@ -6582,14 +6648,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)
           }
         }
       ]
@@ -6722,7 +6788,7 @@ function createMcpServer(bundle, searchEngine, storePath) {
     },
     { instructions: PROSA_MCP_INSTRUCTIONS }
   );
-  registerProsaTools(server, bundle, { searchEngine, storePath });
+  registerProsaTools(server, bundle, { ensureStore: true, searchEngine, storePath });
   return server;
 }
 async function readBody(req) {
@@ -6753,18 +6819,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 storePath = path18.resolve(options.store);
-      const bundle = await openBundle(storePath);
+      const bundle = await openOrInitBundle(storePath);
       try {
         const transport = parseMcpTransport(options.transport);
         const searchEngine = parseSearchEngine(options.searchEngine);
@@ -6796,14 +6877,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();
@@ -6825,7 +6898,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,
@@ -6836,26 +6909,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),
@@ -6866,29 +6929,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)
@@ -6906,26 +6961,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);
-        }
+        });
       }
     )
   );
@@ -6933,7 +6983,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) => {
@@ -6942,14 +6991,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);
-    }
+    });
   });
 }