@c3-oss/prosa 0.3.2 → 0.5.0

package/dist/index.js

@@ -402,10 +402,291 @@ INSERT OR IGNORE INTO search_index_status (
   ('tantivy', 'missing', 0, 0, strftime('%Y-%m-%dT%H:%M:%fZ','now'), NULL);
 `;
 
+// src/core/schema/sql/003_analytics_views.ts
+var SQL_003_ANALYTICS_VIEWS = String.raw`
+CREATE VIEW IF NOT EXISTS session_facts AS
+WITH turn_counts AS (
+  SELECT session_id, count(*) AS turn_count
+    FROM turns
+   GROUP BY session_id
+),
+message_counts AS (
+  SELECT session_id,
+         count(*) AS message_count,
+         sum(CASE WHEN role = 'user' THEN 1 ELSE 0 END) AS user_message_count,
+         sum(CASE WHEN role = 'assistant' THEN 1 ELSE 0 END) AS assistant_message_count
+    FROM messages
+   GROUP BY session_id
+),
+tool_call_counts AS (
+  SELECT session_id,
+         count(*) AS tool_call_count,
+         sum(CASE WHEN status = 'error' THEN 1 ELSE 0 END) AS tool_call_error_count
+    FROM tool_calls
+   GROUP BY session_id
+),
+tool_result_counts AS (
+  SELECT session_id,
+         count(*) AS tool_result_count,
+         sum(CASE WHEN is_error = 1 OR (exit_code IS NOT NULL AND exit_code <> 0)
+                  THEN 1 ELSE 0 END) AS tool_result_error_count,
+         sum(COALESCE(duration_ms, 0)) AS tool_duration_ms
+    FROM tool_results
+   GROUP BY session_id
+),
+search_doc_counts AS (
+  SELECT session_id, count(*) AS search_doc_count
+    FROM search_docs
+   WHERE session_id IS NOT NULL
+   GROUP BY session_id
+)
+SELECT s.session_id,
+       s.source_tool,
+       s.source_session_id,
+       s.project_id,
+       p.display_name AS project_name,
+       p.canonical_path AS project_path,
+       s.parent_session_id,
+       s.is_subagent,
+       s.agent_role,
+       s.agent_nickname,
+       s.title,
+       s.start_ts,
+       s.end_ts,
+       CASE
+         WHEN s.start_ts IS NOT NULL AND s.end_ts IS NOT NULL
+         THEN ROUND((julianday(s.end_ts) - julianday(s.start_ts)) * 86400, 3)
+         ELSE NULL
+       END AS duration_seconds,
+       s.cwd_initial,
+       s.git_branch_initial,
+       s.model_first,
+       s.model_last,
+       s.status,
+       s.timeline_confidence,
+       sf.path AS source_file_path,
+       COALESCE(tc.turn_count, 0) AS turn_count,
+       COALESCE(mc.message_count, 0) AS message_count,
+       COALESCE(mc.user_message_count, 0) AS user_message_count,
+       COALESCE(mc.assistant_message_count, 0) AS assistant_message_count,
+       COALESCE(tcc.tool_call_count, 0) AS tool_call_count,
+       COALESCE(trc.tool_result_count, 0) AS tool_result_count,
+       COALESCE(tcc.tool_call_error_count, 0)
+         + COALESCE(trc.tool_result_error_count, 0) AS tool_error_count,
+       COALESCE(trc.tool_duration_ms, 0) AS tool_duration_ms,
+       COALESCE(sdc.search_doc_count, 0) AS search_doc_count
+  FROM sessions s
+  LEFT JOIN projects p ON p.project_id = s.project_id
+  LEFT JOIN raw_records rr ON rr.raw_record_id = s.raw_record_id
+  LEFT JOIN source_files sf ON sf.source_file_id = rr.source_file_id
+  LEFT JOIN turn_counts tc ON tc.session_id = s.session_id
+  LEFT JOIN message_counts mc ON mc.session_id = s.session_id
+  LEFT JOIN tool_call_counts tcc ON tcc.session_id = s.session_id
+  LEFT JOIN tool_result_counts trc ON trc.session_id = s.session_id
+  LEFT JOIN search_doc_counts sdc ON sdc.session_id = s.session_id;
+
+CREATE VIEW IF NOT EXISTS tool_usage_facts AS
+WITH result_rollup AS (
+  SELECT tool_call_id,
+         session_id,
+         count(*) AS tool_result_count,
+         max(status) AS result_status,
+         max(is_error) AS is_error,
+         min(exit_code) AS exit_code,
+         sum(COALESCE(duration_ms, 0)) AS duration_ms,
+         max(preview) AS preview
+    FROM tool_results
+   GROUP BY tool_call_id, session_id
+)
+SELECT tc.tool_call_id,
+       tc.session_id,
+       s.source_tool,
+       s.source_session_id,
+       s.project_id,
+       p.display_name AS project_name,
+       p.canonical_path AS project_path,
+       tc.turn_id,
+       tc.message_id,
+       tc.event_id,
+       tc.source_call_id,
+       tc.tool_name,
+       tc.canonical_tool_type,
+       tc.command,
+       tc.cwd,
+       tc.path,
+       tc.query,
+       tc.timestamp_start,
+       tc.timestamp_end,
+       CASE
+         WHEN tc.timestamp_start IS NOT NULL AND tc.timestamp_end IS NOT NULL
+         THEN ROUND((julianday(tc.timestamp_end) - julianday(tc.timestamp_start)) * 86400, 3)
+         ELSE NULL
+       END AS call_duration_seconds,
+       tc.status AS call_status,
+       rr.result_status,
+       COALESCE(rr.is_error, 0) AS is_error,
+       rr.exit_code,
+       rr.duration_ms AS result_duration_ms,
+       COALESCE(rr.tool_result_count, 0) AS tool_result_count,
+       rr.preview,
+       tc.raw_record_id
+  FROM tool_calls tc
+  LEFT JOIN sessions s ON s.session_id = tc.session_id
+  LEFT JOIN projects p ON p.project_id = s.project_id
+  LEFT JOIN result_rollup rr ON rr.tool_call_id = tc.tool_call_id;
+
+CREATE VIEW IF NOT EXISTS error_facts AS
+SELECT 'tool_result:' || tr.tool_result_id AS error_id,
+       'tool_result' AS error_category,
+       s.source_tool,
+       s.project_id,
+       p.display_name AS project_name,
+       tr.session_id,
+       COALESCE(tc.timestamp_end, tc.timestamp_start) AS timestamp,
+       tc.tool_name,
+       tc.canonical_tool_type,
+       COALESCE(tr.status, tc.status) AS status,
+       tr.exit_code,
+       NULL AS message,
+       tr.preview,
+       NULL AS entity_type,
+       NULL AS entity_id,
+       tr.raw_record_id
+  FROM tool_results tr
+  LEFT JOIN tool_calls tc ON tc.tool_call_id = tr.tool_call_id
+  LEFT JOIN sessions s ON s.session_id = tr.session_id
+  LEFT JOIN projects p ON p.project_id = s.project_id
+ WHERE tr.is_error = 1 OR (tr.exit_code IS NOT NULL AND tr.exit_code <> 0)
+UNION ALL
+SELECT 'import_error:' || CAST(ie.error_id AS TEXT) AS error_id,
+       'import_error' AS error_category,
+       COALESCE(rr.source_tool, ib.source_tool) AS source_tool,
+       NULL AS project_id,
+       NULL AS project_name,
+       NULL AS session_id,
+       ie.occurred_at AS timestamp,
+       NULL AS tool_name,
+       NULL AS canonical_tool_type,
+       ie.kind AS status,
+       NULL AS exit_code,
+       ie.message,
+       NULL AS preview,
+       NULL AS entity_type,
+       NULL AS entity_id,
+       ie.raw_record_id
+  FROM import_errors ie
+  LEFT JOIN import_batches ib ON ib.batch_id = ie.batch_id
+  LEFT JOIN raw_records rr ON rr.raw_record_id = ie.raw_record_id
+UNION ALL
+SELECT 'uncertainty:' || CAST(u.uncertainty_id AS TEXT) AS error_id,
+       'uncertainty' AS error_category,
+       NULL AS source_tool,
+       NULL AS project_id,
+       NULL AS project_name,
+       CASE WHEN u.entity_type = 'session' THEN u.entity_id ELSE NULL END AS session_id,
+       NULL AS timestamp,
+       NULL AS tool_name,
+       NULL AS canonical_tool_type,
+       u.reason AS status,
+       NULL AS exit_code,
+       u.reason AS message,
+       NULL AS preview,
+       u.entity_type,
+       u.entity_id,
+       NULL AS raw_record_id
+  FROM uncertainties u;
+
+CREATE VIEW IF NOT EXISTS model_usage AS
+WITH model_events AS (
+  SELECT s.source_tool,
+         s.project_id,
+         p.display_name AS project_name,
+         p.canonical_path AS project_path,
+         s.session_id,
+         NULL AS turn_id,
+         s.model_first AS model,
+         s.start_ts AS timestamp,
+         'session_first' AS observation_type
+    FROM sessions s
+    LEFT JOIN projects p ON p.project_id = s.project_id
+   WHERE s.model_first IS NOT NULL
+  UNION ALL
+  SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+         s.session_id, NULL AS turn_id, s.model_last AS model, s.end_ts AS timestamp,
+         'session_last' AS observation_type
+    FROM sessions s
+    LEFT JOIN projects p ON p.project_id = s.project_id
+   WHERE s.model_last IS NOT NULL
+  UNION ALL
+  SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+         t.session_id, t.turn_id, t.model, t.start_ts AS timestamp, 'turn' AS observation_type
+    FROM turns t
+    LEFT JOIN sessions s ON s.session_id = t.session_id
+    LEFT JOIN projects p ON p.project_id = s.project_id
+   WHERE t.model IS NOT NULL
+  UNION ALL
+  SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+         m.session_id, m.turn_id, m.model, m.timestamp, 'message' AS observation_type
+    FROM messages m
+    LEFT JOIN sessions s ON s.session_id = m.session_id
+    LEFT JOIN projects p ON p.project_id = s.project_id
+   WHERE m.model IS NOT NULL
+)
+SELECT source_tool,
+       project_id,
+       project_name,
+       project_path,
+       model,
+       count(DISTINCT session_id) AS session_count,
+       count(DISTINCT turn_id) AS turn_count,
+       count(*) AS observation_count,
+       sum(CASE WHEN observation_type = 'message' THEN 1 ELSE 0 END) AS message_count,
+       min(timestamp) AS first_seen_ts,
+       max(timestamp) AS last_seen_ts
+  FROM model_events
+ GROUP BY source_tool, project_id, project_name, project_path, model;
+
+CREATE VIEW IF NOT EXISTS project_activity AS
+SELECT s.source_tool,
+       s.project_id,
+       COALESCE(p.display_name, s.cwd_initial, '(unknown)') AS project_name,
+       p.canonical_path AS project_path,
+       min(s.start_ts) AS first_session_ts,
+       max(COALESCE(s.end_ts, s.start_ts)) AS latest_session_ts,
+       count(DISTINCT s.session_id) AS session_count,
+       count(DISTINCT CASE WHEN s.timeline_confidence = 'low' THEN s.session_id END)
+         AS low_confidence_session_count,
+       count(DISTINCT t.turn_id) AS turn_count,
+       count(DISTINCT m.message_id) AS message_count,
+       count(DISTINCT tc.tool_call_id) AS tool_call_count,
+       count(DISTINCT tr.tool_result_id) AS tool_result_count,
+       count(DISTINCT CASE
+         WHEN tr.is_error = 1 OR (tr.exit_code IS NOT NULL AND tr.exit_code <> 0)
+         THEN tr.tool_result_id
+       END) AS tool_error_count,
+       count(DISTINCT sd.doc_id) AS search_doc_count
+  FROM sessions s
+  LEFT JOIN projects p ON p.project_id = s.project_id
+  LEFT JOIN turns t ON t.session_id = s.session_id
+  LEFT JOIN messages m ON m.session_id = s.session_id
+  LEFT JOIN tool_calls tc ON tc.session_id = s.session_id
+  LEFT JOIN tool_results tr ON tr.session_id = s.session_id
+  LEFT JOIN search_docs sd ON sd.session_id = s.session_id
+ GROUP BY s.source_tool, s.project_id, p.display_name, s.cwd_initial, p.canonical_path;
+`;
+
+// src/core/schema/sql/004_tantivy_checkpoint.ts
+var SQL_004_TANTIVY_CHECKPOINT = String.raw`
+ALTER TABLE search_index_status ADD COLUMN last_indexed_rowid INTEGER;
+ALTER TABLE search_index_status ADD COLUMN schema_fingerprint TEXT;
+`;
+
 // src/core/schema/migrate.ts
 var MIGRATIONS = [
   { version: 1, name: "init", sql: SQL_001_INIT },
-  { version: 2, name: "search_index_status", sql: SQL_002_SEARCH_INDEX_STATUS }
+  { version: 2, name: "search_index_status", sql: SQL_002_SEARCH_INDEX_STATUS },
+  { version: 3, name: "analytics_views", sql: SQL_003_ANALYTICS_VIEWS },
+  { version: 4, name: "tantivy_checkpoint", sql: SQL_004_TANTIVY_CHECKPOINT }
 ];
 function runMigrations(db) {
   db.exec(`
@@ -447,7 +728,7 @@ function currentSchemaVersion(db) {
 
 // src/core/version.ts
 var PROSA_PARSER_VERSION = "0.1.0";
-var PROSA_SCHEMA_VERSION = 2;
+var PROSA_SCHEMA_VERSION = 4;
 
 // src/core/bundle.ts
 function defaultBundlePath() {
@@ -764,8 +1045,8 @@ var FS_WRITE_CONCURRENCY = 16;
 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++) {
+  const limit2 = Math.min(FS_WRITE_CONCURRENCY, tasks.length);
+  for (let w = 0; w < limit2; w++) {
     workers.push(
       (async () => {
         while (true) {
@@ -1046,7 +1327,7 @@ function sessionFilterWhere(filters) {
 }
 function listSessions(bundle, filters = {}) {
   const { where, params } = sessionFilterWhere(filters);
-  const limit = clampLimit(filters.limit, { max: 1e3, fallback: 50 });
+  const limit2 = clampLimit(filters.limit, { max: 1e3, fallback: 50 });
   const sql = `
     SELECT s.session_id,
            s.source_tool,
@@ -1067,7 +1348,7 @@ function listSessions(bundle, filters = {}) {
       FROM sessions s
       ${where}
      ORDER BY s.start_ts DESC NULLS LAST
-     LIMIT ${limit}
+     LIMIT ${limit2}
   `;
   return bundle.db.prepare(sql).all(...params);
 }
@@ -1119,15 +1400,21 @@ function getSession(bundle, sessionId2) {
 }
 
 // src/services/search.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { createRequire } from "module";
 
 // src/core/errors.ts
 var getErrorMessage = (err) => err instanceof Error ? err.message : String(err);
 
 // src/services/indexing.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync } from "fs";
 import { mkdir as mkdir3, rm, writeFile as writeFile4 } from "fs/promises";
 import path4 from "path";
+var SEARCH_INDEX_STATUS_COLUMNS = `
+  engine, status, source_doc_count, indexed_doc_count, updated_at,
+  error_message, last_indexed_rowid, schema_fingerprint
+`;
 var 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)
@@ -1159,7 +1446,7 @@ function disableFts5Triggers(bundle) {
 function getSearchIndexStatuses(bundle) {
   ensureSearchIndexStatusRows(bundle);
   return bundle.db.prepare(
-    `SELECT engine, status, source_doc_count, indexed_doc_count, updated_at, error_message
+    `SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
          FROM search_index_status
         ORDER BY engine`
   ).all();
@@ -1167,28 +1454,13 @@ function getSearchIndexStatuses(bundle) {
 function getSearchIndexStatus(bundle, engine) {
   ensureSearchIndexStatusRows(bundle);
   return bundle.db.prepare(
-    `SELECT engine, status, source_doc_count, indexed_doc_count, updated_at, error_message
+    `SELECT ${SEARCH_INDEX_STATUS_COLUMNS}
            FROM search_index_status
           WHERE engine = ?`
   ).get(engine) ?? null;
 }
 function markIndexesAfterImport(bundle, options) {
   if (!options.changed) return;
-  if (options.fts5Deferred) {
-    updateSearchIndexStatus(bundle, "fts5", {
-      status: "stale",
-      sourceDocCount: countSearchDocs(bundle),
-      indexedDocCount: countFts5Docs(bundle),
-      errorMessage: null
-    });
-  } else {
-    updateSearchIndexStatus(bundle, "fts5", {
-      status: "ready",
-      sourceDocCount: countSearchDocs(bundle),
-      indexedDocCount: countFts5Docs(bundle),
-      errorMessage: null
-    });
-  }
   const tantivy = getSearchIndexStatus(bundle, "tantivy");
   if (tantivy?.status === "ready" || tantivy?.status === "stale" || tantivy?.status === "failed") {
     updateSearchIndexStatus(bundle, "tantivy", {
@@ -1229,46 +1501,100 @@ function rebuildFts5Index(bundle) {
   }
   return getSearchIndexStatus(bundle, "fts5");
 }
-async function rebuildTantivyIndex(bundle) {
+var TANTIVY_SCHEMA_FIELDS = [
+  { name: "doc_id", tokenizer: "raw" },
+  { name: "entity_type", tokenizer: "raw" },
+  { name: "entity_id", tokenizer: "raw" },
+  { name: "session_id", tokenizer: "raw" },
+  { name: "project_id", tokenizer: "raw" },
+  { name: "timestamp", tokenizer: "raw" },
+  { name: "role", tokenizer: "raw" },
+  { name: "tool_name", tokenizer: "raw" },
+  { name: "canonical_tool_type", tokenizer: "raw" },
+  { name: "field_kind", tokenizer: "raw" },
+  // The text field uses tantivy's default tokenizer (en_stem in the binding).
+  { name: "text", tokenizer: "default" }
+];
+function buildTantivySchema(tantivy) {
+  const builder = new tantivy.SchemaBuilder();
+  for (const field of TANTIVY_SCHEMA_FIELDS) {
+    if (field.tokenizer === "default") {
+      builder.addTextField(field.name, { stored: true });
+    } else {
+      builder.addTextField(field.name, { stored: true, tokenizerName: field.tokenizer });
+    }
+  }
+  return builder.build();
+}
+function computeSchemaFingerprint() {
+  const canonical = TANTIVY_SCHEMA_FIELDS.map((f) => `${f.name}:${f.tokenizer}:stored`).join("|");
+  return createHash2("sha256").update(canonical).digest("hex");
+}
+function tantivyIndexLooksValid(dir) {
+  return existsSync(path4.join(dir, "meta.json"));
+}
+function makeTantivyDoc(tantivy, row) {
+  const doc = new tantivy.Document();
+  doc.addText("doc_id", row.doc_id);
+  doc.addText("entity_type", row.entity_type);
+  doc.addText("entity_id", row.entity_id);
+  doc.addText("session_id", row.session_id ?? "");
+  doc.addText("project_id", row.project_id ?? "");
+  doc.addText("timestamp", row.timestamp ?? "");
+  doc.addText("role", row.role ?? "");
+  doc.addText("tool_name", row.tool_name ?? "");
+  doc.addText("canonical_tool_type", row.canonical_tool_type ?? "");
+  doc.addText("field_kind", row.field_kind);
+  doc.addText("text", row.text);
+  return doc;
+}
+var SEARCH_DOCS_SELECT = `
+  SELECT rowid, doc_id, entity_type, entity_id, session_id, project_id, timestamp,
+         role, tool_name, canonical_tool_type, field_kind, text
+    FROM search_docs
+`;
+async function rebuildTantivyIndex(bundle, options = {}) {
   ensureSearchIndexStatusRows(bundle);
+  const sourceDocCount = countSearchDocs(bundle);
+  const prev = getSearchIndexStatus(bundle, "tantivy");
+  const fingerprint = computeSchemaFingerprint();
+  const indexDirValid = tantivyIndexLooksValid(bundle.paths.tantivy);
+  const fingerprintMatches = prev?.schema_fingerprint === fingerprint;
+  const lastIndexedRowid = typeof prev?.last_indexed_rowid === "number" ? prev.last_indexed_rowid : 0;
+  const wantFullRebuild = options.overwrite === true || !indexDirValid || !fingerprintMatches || lastIndexedRowid <= 0;
   updateSearchIndexStatus(bundle, "tantivy", {
     status: "building",
-    sourceDocCount: countSearchDocs(bundle),
+    sourceDocCount,
     indexedDocCount: 0,
     errorMessage: null
   });
   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 mkdir3(bundle.paths.tantivy, { recursive: true });
-    const index = new tantivy.Index(schema, bundle.paths.tantivy, false);
-    const writer = index.writer(5e7, 1);
-    let indexedDocCount = 0;
-    const rows = bundle.db.prepare(
-      `SELECT rowid, doc_id, entity_type, entity_id, session_id, project_id, timestamp,
-                role, tool_name, canonical_tool_type, field_kind, text
-           FROM search_docs
-          ORDER BY rowid`
-    ).iterate();
-    for (const row of rows) {
-      const doc = new tantivy.Document();
-      doc.addText("doc_id", row.doc_id);
-      doc.addText("entity_type", row.entity_type);
-      doc.addText("entity_id", row.entity_id);
-      doc.addText("session_id", row.session_id ?? "");
-      doc.addText("project_id", row.project_id ?? "");
-      doc.addText("timestamp", row.timestamp ?? "");
-      doc.addText("role", row.role ?? "");
-      doc.addText("tool_name", row.tool_name ?? "");
-      doc.addText("canonical_tool_type", row.canonical_tool_type ?? "");
-      doc.addText("field_kind", row.field_kind);
-      doc.addText("text", row.text);
-      writer.addDocument(doc);
-      indexedDocCount++;
+    const schema = buildTantivySchema(tantivy);
+    let index;
+    if (wantFullRebuild) {
+      await rm(bundle.paths.tantivy, { recursive: true, force: true });
+      await mkdir3(bundle.paths.tantivy, { recursive: true });
+      index = new tantivy.Index(schema, bundle.paths.tantivy, false);
+    } else {
+      index = tantivy.Index.open(bundle.paths.tantivy);
+    }
+    const writer = index.writer(3e8, 4);
+    const select = wantFullRebuild ? `${SEARCH_DOCS_SELECT} ORDER BY rowid` : `${SEARCH_DOCS_SELECT} WHERE rowid > ${lastIndexedRowid} ORDER BY rowid`;
+    let addedDocCount = 0;
+    let maxRowid = wantFullRebuild ? 0 : lastIndexedRowid;
+    for (const row of bundle.db.prepare(select).iterate()) {
+      if (!wantFullRebuild) {
+        writer.deleteDocumentsByTerm("doc_id", row.doc_id);
+      }
+      writer.addDocument(makeTantivyDoc(tantivy, row));
+      addedDocCount++;
+      if (row.rowid > maxRowid) maxRowid = row.rowid;
     }
     writer.commit();
     index.reload();
+    writer.waitMergingThreads();
+    const indexedDocCount = wantFullRebuild ? addedDocCount : countTantivyDocsBest(prev, addedDocCount);
     await writeFile4(
       path4.join(bundle.paths.tantivy, "prosa-index.json"),
       `${JSON.stringify(
@@ -1276,8 +1602,11 @@ async function rebuildTantivyIndex(bundle) {
           engine: "tantivy",
           source: "search_docs",
           built_at: (/* @__PURE__ */ new Date()).toISOString(),
-          source_doc_count: countSearchDocs(bundle),
-          indexed_doc_count: indexedDocCount
+          mode: wantFullRebuild ? "full" : "incremental",
+          source_doc_count: sourceDocCount,
+          indexed_doc_count: indexedDocCount,
+          last_indexed_rowid: maxRowid,
+          schema_fingerprint: fingerprint
         },
         null,
         2
@@ -1287,14 +1616,16 @@ async function rebuildTantivyIndex(bundle) {
     );
     updateSearchIndexStatus(bundle, "tantivy", {
       status: "ready",
-      sourceDocCount: countSearchDocs(bundle),
+      sourceDocCount,
       indexedDocCount,
-      errorMessage: null
+      errorMessage: null,
+      lastIndexedRowid: maxRowid,
+      schemaFingerprint: fingerprint
     });
   } catch (error) {
     updateSearchIndexStatus(bundle, "tantivy", {
       status: "failed",
-      sourceDocCount: countSearchDocs(bundle),
+      sourceDocCount,
       indexedDocCount: 0,
       errorMessage: getErrorMessage(error)
     });
@@ -1302,36 +1633,53 @@ async function rebuildTantivyIndex(bundle) {
   }
   return getSearchIndexStatus(bundle, "tantivy");
 }
+function countTantivyDocsBest(prev, added) {
+  if (prev && typeof prev.indexed_doc_count === "number") {
+    return prev.indexed_doc_count + added;
+  }
+  return added;
+}
 function ensureSearchIndexStatusRows(bundle) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stmt = prepare(
     bundle.db,
     `INSERT OR IGNORE INTO search_index_status (
-       engine, status, source_doc_count, indexed_doc_count, updated_at, error_message
-     ) VALUES (?, ?, 0, 0, ?, NULL)`
+       engine, status, source_doc_count, indexed_doc_count, updated_at,
+       error_message, last_indexed_rowid, schema_fingerprint
+     ) VALUES (?, ?, 0, 0, ?, NULL, NULL, NULL)`
   );
   stmt.run("fts5", "ready", now);
   stmt.run("tantivy", "missing", now);
 }
 function updateSearchIndexStatus(bundle, engine, values) {
   ensureSearchIndexStatusRows(bundle);
-  prepare(
-    bundle.db,
-    `UPDATE search_index_status
-        SET status = ?,
-            source_doc_count = ?,
-            indexed_doc_count = ?,
-            updated_at = ?,
-            error_message = ?
-      WHERE engine = ?`
-  ).run(
+  const setClauses = [
+    "status = ?",
+    "source_doc_count = ?",
+    "indexed_doc_count = ?",
+    "updated_at = ?",
+    "error_message = ?"
+  ];
+  const params = [
     values.status,
     values.sourceDocCount,
     values.indexedDocCount,
     (/* @__PURE__ */ new Date()).toISOString(),
-    values.errorMessage,
-    engine
-  );
+    values.errorMessage
+  ];
+  if (values.lastIndexedRowid !== void 0) {
+    setClauses.push("last_indexed_rowid = ?");
+    params.push(values.lastIndexedRowid);
+  }
+  if (values.schemaFingerprint !== void 0) {
+    setClauses.push("schema_fingerprint = ?");
+    params.push(values.schemaFingerprint);
+  }
+  params.push(engine);
+  prepare(
+    bundle.db,
+    `UPDATE search_index_status SET ${setClauses.join(", ")} WHERE engine = ?`
+  ).run(...params);
 }
 function countSearchDocs(bundle) {
   return bundle.db.prepare(`SELECT count(*) AS n FROM search_docs`).get()?.n ?? 0;
@@ -1349,7 +1697,7 @@ function searchFullText(bundle, options) {
   if (options.engine === "tantivy") {
     return searchTantivy(bundle, options);
   }
-  const limit = clampLimit(options.limit, { max: 500, fallback: 50 });
+  const limit2 = clampLimit(options.limit, { max: 500, fallback: 50 });
   const sql = `
     SELECT d.doc_id,
            d.entity_type,
@@ -1364,14 +1712,14 @@ function searchFullText(bundle, options) {
       JOIN search_docs d ON d.rowid = search_docs_fts.rowid
      WHERE search_docs_fts MATCH ?
      ORDER BY bm25(search_docs_fts), d.timestamp DESC
-     LIMIT ${limit}
+     LIMIT ${limit2}
   `;
   const ftsQuery = options.raw ? options.query : escapeFtsQuery(options.query);
   if (!ftsQuery) return [];
   return bundle.db.prepare(sql).all(ftsQuery);
 }
 function searchTantivy(bundle, options) {
-  if (!existsSync(bundle.paths.tantivy)) {
+  if (!existsSync2(bundle.paths.tantivy)) {
     throw new Error("tantivy index not found; run `prosa index tantivy` first");
   }
   const status = getSearchIndexStatus(bundle, "tantivy");
@@ -1380,7 +1728,7 @@ function searchTantivy(bundle, options) {
       `tantivy index is ${status?.status ?? "missing"}; run \`prosa index tantivy\` first`
     );
   }
-  const limit = clampLimit(options.limit, { max: 500, fallback: 50 });
+  const limit2 = clampLimit(options.limit, { max: 500, fallback: 50 });
   const queryText = options.query.trim();
   if (!queryText) return [];
   const tantivy = requireTantivy();
@@ -1389,7 +1737,7 @@ function searchTantivy(bundle, options) {
   const [query] = options.raw ? [index.parseQuery(queryText, ["text"])] : index.parseQueryLenient(queryText, ["text"], void 0, {
     text: [true, 2, true]
   });
-  const result = searcher.search(query, limit, true);
+  const result = searcher.search(query, limit2, true);
   const snippets = tantivy.SnippetGenerator.create(searcher, query, index.schema, "text");
   snippets.setMaxNumChars(180);
   return result.hits.map((hit) => {
@@ -5079,6 +5427,13 @@ var PARQUET_TABLES = [
   "edges",
   "search_docs"
 ];
+var ANALYTICS_VIEWS = [
+  "session_facts",
+  "tool_usage_facts",
+  "error_facts",
+  "model_usage",
+  "project_activity"
+];
 async function exportBundleParquet(options) {
   const snapshot = await openBundleSnapshot(options.bundlePath);
   const outDir = path13.resolve(options.outDir ?? snapshot.defaultOutDir);
@@ -5095,7 +5450,7 @@ async function exportBundleParquet(options) {
     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)`
+        `COPY (SELECT * FROM prosa.${quoteIdentifier(table)}) TO ${sqlString(files[table])} (FORMAT parquet, COMPRESSION zstd, COMPRESSION_LEVEL 1, ROW_GROUP_SIZE 100000)`
       );
     }
   } finally {
@@ -5131,6 +5486,7 @@ async function queryDuckDbParquet(options) {
         )})`
       );
     }
+    await createAnalyticsViews(connection);
     const reader = await connection.runAndReadAll(options.sql);
     return {
       columns: reader.deduplicatedColumnNames(),
@@ -5161,6 +5517,285 @@ async function attachSqlite(connection, dbPath) {
     );
   }
 }
+async function createAnalyticsViews(connection) {
+  await connection.run(`
+    CREATE OR REPLACE VIEW session_facts AS
+    WITH turn_counts AS (
+      SELECT session_id, count(*) AS turn_count
+        FROM turns
+       GROUP BY session_id
+    ),
+    message_counts AS (
+      SELECT session_id,
+             count(*) AS message_count,
+             sum(CASE WHEN role = 'user' THEN 1 ELSE 0 END) AS user_message_count,
+             sum(CASE WHEN role = 'assistant' THEN 1 ELSE 0 END) AS assistant_message_count
+        FROM messages
+       GROUP BY session_id
+    ),
+    tool_call_counts AS (
+      SELECT session_id,
+             count(*) AS tool_call_count,
+             sum(CASE WHEN status = 'error' THEN 1 ELSE 0 END) AS tool_call_error_count
+        FROM tool_calls
+       GROUP BY session_id
+    ),
+    tool_result_counts AS (
+      SELECT session_id,
+             count(*) AS tool_result_count,
+             sum(CASE WHEN is_error = 1 OR (exit_code IS NOT NULL AND exit_code <> 0)
+                      THEN 1 ELSE 0 END) AS tool_result_error_count,
+             sum(COALESCE(duration_ms, 0)) AS tool_duration_ms
+        FROM tool_results
+       GROUP BY session_id
+    ),
+    search_doc_counts AS (
+      SELECT session_id, count(*) AS search_doc_count
+        FROM search_docs
+       WHERE session_id IS NOT NULL
+       GROUP BY session_id
+    )
+    SELECT s.session_id,
+           s.source_tool,
+           s.source_session_id,
+           s.project_id,
+           p.display_name AS project_name,
+           p.canonical_path AS project_path,
+           s.parent_session_id,
+           s.is_subagent,
+           s.agent_role,
+           s.agent_nickname,
+           s.title,
+           s.start_ts,
+           s.end_ts,
+           CASE
+             WHEN s.start_ts IS NOT NULL AND s.end_ts IS NOT NULL
+             THEN date_diff('millisecond', TRY_CAST(s.start_ts AS TIMESTAMP),
+                    TRY_CAST(s.end_ts AS TIMESTAMP)) / 1000.0
+             ELSE NULL
+           END AS duration_seconds,
+           s.cwd_initial,
+           s.git_branch_initial,
+           s.model_first,
+           s.model_last,
+           s.status,
+           s.timeline_confidence,
+           sf.path AS source_file_path,
+           COALESCE(tc.turn_count, 0) AS turn_count,
+           COALESCE(mc.message_count, 0) AS message_count,
+           COALESCE(mc.user_message_count, 0) AS user_message_count,
+           COALESCE(mc.assistant_message_count, 0) AS assistant_message_count,
+           COALESCE(tcc.tool_call_count, 0) AS tool_call_count,
+           COALESCE(trc.tool_result_count, 0) AS tool_result_count,
+           COALESCE(tcc.tool_call_error_count, 0)
+             + COALESCE(trc.tool_result_error_count, 0) AS tool_error_count,
+           COALESCE(trc.tool_duration_ms, 0) AS tool_duration_ms,
+           COALESCE(sdc.search_doc_count, 0) AS search_doc_count
+      FROM sessions s
+      LEFT JOIN projects p ON p.project_id = s.project_id
+      LEFT JOIN raw_records rr ON rr.raw_record_id = s.raw_record_id
+      LEFT JOIN source_files sf ON sf.source_file_id = rr.source_file_id
+      LEFT JOIN turn_counts tc ON tc.session_id = s.session_id
+      LEFT JOIN message_counts mc ON mc.session_id = s.session_id
+      LEFT JOIN tool_call_counts tcc ON tcc.session_id = s.session_id
+      LEFT JOIN tool_result_counts trc ON trc.session_id = s.session_id
+      LEFT JOIN search_doc_counts sdc ON sdc.session_id = s.session_id
+  `);
+  await connection.run(`
+    CREATE OR REPLACE VIEW tool_usage_facts AS
+    WITH result_rollup AS (
+      SELECT tool_call_id,
+             session_id,
+             count(*) AS tool_result_count,
+             max(status) AS result_status,
+             max(is_error) AS is_error,
+             min(exit_code) AS exit_code,
+             sum(COALESCE(duration_ms, 0)) AS duration_ms,
+             max(preview) AS preview
+        FROM tool_results
+       GROUP BY tool_call_id, session_id
+    )
+    SELECT tc.tool_call_id,
+           tc.session_id,
+           s.source_tool,
+           s.source_session_id,
+           s.project_id,
+           p.display_name AS project_name,
+           p.canonical_path AS project_path,
+           tc.turn_id,
+           tc.message_id,
+           tc.event_id,
+           tc.source_call_id,
+           tc.tool_name,
+           tc.canonical_tool_type,
+           tc.command,
+           tc.cwd,
+           tc.path,
+           tc.query,
+           tc.timestamp_start,
+           tc.timestamp_end,
+           CASE
+             WHEN tc.timestamp_start IS NOT NULL AND tc.timestamp_end IS NOT NULL
+             THEN date_diff('millisecond', TRY_CAST(tc.timestamp_start AS TIMESTAMP),
+                    TRY_CAST(tc.timestamp_end AS TIMESTAMP)) / 1000.0
+             ELSE NULL
+           END AS call_duration_seconds,
+           tc.status AS call_status,
+           rr.result_status,
+           COALESCE(rr.is_error, 0) AS is_error,
+           rr.exit_code,
+           rr.duration_ms AS result_duration_ms,
+           COALESCE(rr.tool_result_count, 0) AS tool_result_count,
+           rr.preview,
+           tc.raw_record_id
+      FROM tool_calls tc
+      LEFT JOIN sessions s ON s.session_id = tc.session_id
+      LEFT JOIN projects p ON p.project_id = s.project_id
+      LEFT JOIN result_rollup rr ON rr.tool_call_id = tc.tool_call_id
+  `);
+  await connection.run(`
+    CREATE OR REPLACE VIEW error_facts AS
+    SELECT 'tool_result:' || tr.tool_result_id AS error_id,
+           'tool_result' AS error_category,
+           s.source_tool,
+           s.project_id,
+           p.display_name AS project_name,
+           tr.session_id,
+           COALESCE(tc.timestamp_end, tc.timestamp_start) AS timestamp,
+           tc.tool_name,
+           tc.canonical_tool_type,
+           COALESCE(tr.status, tc.status) AS status,
+           tr.exit_code,
+           NULL AS message,
+           tr.preview,
+           NULL AS entity_type,
+           NULL AS entity_id,
+           tr.raw_record_id
+      FROM tool_results tr
+      LEFT JOIN tool_calls tc ON tc.tool_call_id = tr.tool_call_id
+      LEFT JOIN sessions s ON s.session_id = tr.session_id
+      LEFT JOIN projects p ON p.project_id = s.project_id
+     WHERE tr.is_error = 1 OR (tr.exit_code IS NOT NULL AND tr.exit_code <> 0)
+    UNION ALL
+    SELECT 'import_error:' || CAST(ie.error_id AS VARCHAR) AS error_id,
+           'import_error' AS error_category,
+           COALESCE(rr.source_tool, ib.source_tool) AS source_tool,
+           NULL AS project_id,
+           NULL AS project_name,
+           NULL AS session_id,
+           ie.occurred_at AS timestamp,
+           NULL AS tool_name,
+           NULL AS canonical_tool_type,
+           ie.kind AS status,
+           NULL AS exit_code,
+           ie.message,
+           NULL AS preview,
+           NULL AS entity_type,
+           NULL AS entity_id,
+           ie.raw_record_id
+      FROM import_errors ie
+      LEFT JOIN import_batches ib ON ib.batch_id = ie.batch_id
+      LEFT JOIN raw_records rr ON rr.raw_record_id = ie.raw_record_id
+    UNION ALL
+    SELECT 'uncertainty:' || CAST(u.uncertainty_id AS VARCHAR) AS error_id,
+           'uncertainty' AS error_category,
+           NULL AS source_tool,
+           NULL AS project_id,
+           NULL AS project_name,
+           CASE WHEN u.entity_type = 'session' THEN u.entity_id ELSE NULL END AS session_id,
+           NULL AS timestamp,
+           NULL AS tool_name,
+           NULL AS canonical_tool_type,
+           u.reason AS status,
+           NULL AS exit_code,
+           u.reason AS message,
+           NULL AS preview,
+           u.entity_type,
+           u.entity_id,
+           NULL AS raw_record_id
+      FROM uncertainties u
+  `);
+  await connection.run(`
+    CREATE OR REPLACE VIEW model_usage AS
+    WITH model_events AS (
+      SELECT s.source_tool,
+             s.project_id,
+             p.display_name AS project_name,
+             p.canonical_path AS project_path,
+             s.session_id,
+             NULL AS turn_id,
+             s.model_first AS model,
+             s.start_ts AS timestamp,
+             'session_first' AS observation_type
+        FROM sessions s
+        LEFT JOIN projects p ON p.project_id = s.project_id
+       WHERE s.model_first IS NOT NULL
+      UNION ALL
+      SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+             s.session_id, NULL AS turn_id, s.model_last AS model, s.end_ts AS timestamp,
+             'session_last' AS observation_type
+        FROM sessions s
+        LEFT JOIN projects p ON p.project_id = s.project_id
+       WHERE s.model_last IS NOT NULL
+      UNION ALL
+      SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+             t.session_id, t.turn_id, t.model, t.start_ts AS timestamp, 'turn' AS observation_type
+        FROM turns t
+        LEFT JOIN sessions s ON s.session_id = t.session_id
+        LEFT JOIN projects p ON p.project_id = s.project_id
+       WHERE t.model IS NOT NULL
+      UNION ALL
+      SELECT s.source_tool, s.project_id, p.display_name, p.canonical_path,
+             m.session_id, m.turn_id, m.model, m.timestamp, 'message' AS observation_type
+        FROM messages m
+        LEFT JOIN sessions s ON s.session_id = m.session_id
+        LEFT JOIN projects p ON p.project_id = s.project_id
+       WHERE m.model IS NOT NULL
+    )
+    SELECT source_tool,
+           project_id,
+           project_name,
+           project_path,
+           model,
+           count(DISTINCT session_id) AS session_count,
+           count(DISTINCT turn_id) AS turn_count,
+           count(*) AS observation_count,
+           sum(CASE WHEN observation_type = 'message' THEN 1 ELSE 0 END) AS message_count,
+           min(timestamp) AS first_seen_ts,
+           max(timestamp) AS last_seen_ts
+      FROM model_events
+     GROUP BY source_tool, project_id, project_name, project_path, model
+  `);
+  await connection.run(`
+    CREATE OR REPLACE VIEW project_activity AS
+    SELECT s.source_tool,
+           s.project_id,
+           COALESCE(p.display_name, s.cwd_initial, '(unknown)') AS project_name,
+           p.canonical_path AS project_path,
+           min(s.start_ts) AS first_session_ts,
+           max(COALESCE(s.end_ts, s.start_ts)) AS latest_session_ts,
+           count(DISTINCT s.session_id) AS session_count,
+           count(DISTINCT CASE WHEN s.timeline_confidence = 'low' THEN s.session_id END)
+             AS low_confidence_session_count,
+           count(DISTINCT t.turn_id) AS turn_count,
+           count(DISTINCT m.message_id) AS message_count,
+           count(DISTINCT tc.tool_call_id) AS tool_call_count,
+           count(DISTINCT tr.tool_result_id) AS tool_result_count,
+           count(DISTINCT CASE
+             WHEN tr.is_error = 1 OR (tr.exit_code IS NOT NULL AND tr.exit_code <> 0)
+             THEN tr.tool_result_id
+           END) AS tool_error_count,
+           count(DISTINCT sd.doc_id) AS search_doc_count
+      FROM sessions s
+      LEFT JOIN projects p ON p.project_id = s.project_id
+      LEFT JOIN turns t ON t.session_id = s.session_id
+      LEFT JOIN messages m ON m.session_id = s.session_id
+      LEFT JOIN tool_calls tc ON tc.session_id = s.session_id
+      LEFT JOIN tool_results tr ON tr.session_id = s.session_id
+      LEFT JOIN search_docs sd ON sd.session_id = s.session_id
+     GROUP BY s.source_tool, s.project_id, p.display_name, s.cwd_initial, p.canonical_path
+  `);
+}
 async function openBundleSnapshot(bundlePath) {
   const bundle = await openBundle(bundlePath);
   try {
@@ -5236,16 +5871,16 @@ function resolveCompilePath(p) {
   return path14.resolve(p);
 }
 async function runCompileImports(options) {
-  const { bundle, providers, deferIndex, logger } = options;
+  const { bundle, providers, logger } = options;
+  const overwrite = options.overwrite === true;
   let importedAny = false;
   const summaries = [];
   let tantivy = null;
   let tantivyError = null;
+  let fts5Error = null;
   try {
-    if (deferIndex) {
-      logger?.info("disabling FTS5 triggers for deferred indexing");
-      disableFts5Triggers(bundle);
-    }
+    logger?.info("disabling FTS5 triggers for bulk rebuild");
+    disableFts5Triggers(bundle);
     for (const provider of providers) {
       const sourcePath = resolveCompilePath(options.sessionsPath ?? provider.defaultSessionsPath());
       const providerLogger = logger?.child({
@@ -5272,15 +5907,23 @@ async function runCompileImports(options) {
       summaries.push(summary);
       options.onProviderComplete?.(summary);
     }
-    logger?.info({ changed: importedAny, fts5_deferred: deferIndex }, "marking indexes");
-    markIndexesAfterImport(bundle, {
-      changed: importedAny,
-      fts5Deferred: deferIndex
-    });
-    if (importedAny) {
+    const shouldRebuildIndexes = importedAny || overwrite;
+    if (shouldRebuildIndexes) {
+      logger?.info(
+        { changed: importedAny, overwrite },
+        importedAny ? "marking indexes" : "overwrite forces rebuild despite no new imports"
+      );
+      markIndexesAfterImport(bundle, { changed: true });
+      try {
+        logger?.info("rebuilding fts5 index");
+        rebuildFts5Index(bundle);
+      } catch (error) {
+        fts5Error = getErrorMessage(error);
+        logger?.error({ err: error }, "fts5 rebuild failed; SQLite data is intact");
+      }
       try {
-        logger?.info("rebuilding tantivy index");
-        const status = await rebuildTantivyIndex(bundle);
+        logger?.info({ overwrite }, "rebuilding tantivy index");
+        const status = await rebuildTantivyIndex(bundle, { overwrite });
         tantivy = { indexedDocCount: status.indexed_doc_count };
         options.onTantivyComplete?.(tantivy);
       } catch (error) {
@@ -5289,16 +5932,14 @@ async function runCompileImports(options) {
       }
     }
   } finally {
-    if (deferIndex) {
-      logger?.info("re-enabling FTS5 triggers");
-      enableFts5Triggers(bundle);
-    }
+    enableFts5Triggers(bundle);
   }
   return {
     providers: summaries,
     importedAny,
     tantivy,
-    tantivyError
+    tantivyError,
+    fts5Error
   };
 }
 async function exportCompileParquet(options) {
@@ -5314,6 +5955,251 @@ async function exportCompileParquet(options) {
   };
 }
 
+// src/services/analytics.ts
+var ANALYTICS_REPORTS = ["sessions", "tools", "errors", "models", "projects"];
+async function runAnalyticsReport(options) {
+  return queryDuckDbParquet({
+    parquetDir: options.parquetDir,
+    sql: buildAnalyticsSql(options.report, options.filters ?? {}, "duckdb")
+  });
+}
+function runAnalyticsReportFromBundle(options) {
+  const sql = buildAnalyticsSql(options.report, options.filters ?? {}, "sqlite");
+  const stmt = options.bundle.db.prepare(sql);
+  const rows = stmt.all();
+  const columns = stmt.columns().map((column) => column.name);
+  return { columns, rows };
+}
+function buildAnalyticsSql(report, filters, dialect) {
+  switch (report) {
+    case "sessions":
+      return buildSessionsSql(filters, dialect);
+    case "tools":
+      return buildToolsSql(filters, dialect);
+    case "errors":
+      return buildErrorsSql(filters, dialect);
+    case "models":
+      return buildModelsSql(filters, dialect);
+    case "projects":
+      return buildProjectsSql(filters, dialect);
+  }
+}
+function buildSessionsSql(filters, dialect) {
+  const where = buildWhere([
+    sourceFilter(filters),
+    timeFilter("start_ts", filters),
+    projectFilter(filters, dialect),
+    filters.sessionId ? `session_id = ${sqlString2(filters.sessionId)}` : null,
+    filters.sourcePathSubstring ? `source_file_path LIKE ${sqlString2(`%${escapeLike(filters.sourcePathSubstring)}%`)} ESCAPE '\\'` : null
+  ]);
+  return `
+    SELECT start_ts, source_tool, project_name, source_file_path, session_id,
+           source_session_id, model_last, duration_seconds,
+           message_count, tool_call_count, tool_result_count, tool_error_count,
+           tool_duration_ms, timeline_confidence, title
+      FROM session_facts
+      ${where}
+     ORDER BY start_ts DESC NULLS LAST
+     LIMIT ${limit(filters)}
+  `;
+}
+function buildToolsSql(filters, dialect) {
+  const where = buildWhere([
+    sourceFilter(filters),
+    timeFilter("timestamp_start", filters),
+    projectFilter(filters, dialect),
+    filters.toolName ? `tool_name = ${sqlString2(filters.toolName)}` : null,
+    filters.canonicalType ? `canonical_tool_type = ${sqlString2(filters.canonicalType)}` : null,
+    filters.errorsOnly ? `(is_error = 1 OR call_status = 'error')` : null
+  ]);
+  return `
+    SELECT tool_name, canonical_tool_type, source_tool, project_name,
+           count(*) AS call_count,
+           sum(CASE WHEN is_error = 1 OR call_status = 'error' THEN 1 ELSE 0 END) AS error_count,
+           round(avg(result_duration_ms), 3) AS avg_result_duration_ms,
+           max(timestamp_start) AS latest_ts
+      FROM tool_usage_facts
+      ${where}
+     GROUP BY tool_name, canonical_tool_type, source_tool, project_name
+     ORDER BY call_count DESC, error_count DESC, tool_name ASC
+     LIMIT ${limit(filters)}
+  `;
+}
+function buildErrorsSql(filters, dialect) {
+  const where = buildWhere([
+    sourceFilter(filters),
+    timeFilter("timestamp", filters),
+    projectFilter(filters, dialect),
+    filters.toolName ? `tool_name = ${sqlString2(filters.toolName)}` : null,
+    filters.category ? `error_category = ${sqlString2(filters.category)}` : null
+  ]);
+  return `
+    SELECT timestamp, error_category, source_tool, project_name, session_id,
+           tool_name, status, exit_code, message, preview
+      FROM error_facts
+      ${where}
+     ORDER BY timestamp DESC NULLS LAST, error_id DESC
+     LIMIT ${limit(filters)}
+  `;
+}
+function buildModelsSql(filters, dialect) {
+  const where = buildWhere([
+    sourceFilter(filters),
+    rangeOverlapFilter("first_seen_ts", "last_seen_ts", filters),
+    projectFilter(filters, dialect),
+    filters.model ? `model = ${sqlString2(filters.model)}` : null
+  ]);
+  return `
+    SELECT model, source_tool, project_name, session_count, turn_count,
+           message_count, observation_count, first_seen_ts, last_seen_ts
+      FROM model_usage
+      ${where}
+     ORDER BY session_count DESC, observation_count DESC, model ASC
+     LIMIT ${limit(filters)}
+  `;
+}
+function buildProjectsSql(filters, dialect) {
+  const where = buildWhere([
+    sourceFilter(filters),
+    rangeOverlapFilter("first_session_ts", "latest_session_ts", filters),
+    projectFilter(filters, dialect)
+  ]);
+  return `
+    SELECT latest_session_ts, source_tool, project_name, project_path,
+           session_count, message_count, tool_call_count, tool_error_count,
+           low_confidence_session_count
+      FROM project_activity
+      ${where}
+     ORDER BY latest_session_ts DESC NULLS LAST, session_count DESC, project_name ASC
+     LIMIT ${limit(filters)}
+  `;
+}
+function sourceFilter(filters) {
+  return filters.source ? `source_tool = ${sqlString2(filters.source)}` : null;
+}
+function timeFilter(column, filters) {
+  const filtersSql = [];
+  if (filters.since)
+    filtersSql.push(`(${column} IS NULL OR ${column} >= ${sqlString2(filters.since)})`);
+  if (filters.until)
+    filtersSql.push(`(${column} IS NULL OR ${column} < ${sqlString2(filters.until)})`);
+  return filtersSql.length ? filtersSql.join(" AND ") : null;
+}
+function rangeOverlapFilter(firstColumn, lastColumn, filters) {
+  const filtersSql = [];
+  if (filters.since) {
+    filtersSql.push(`(${lastColumn} IS NULL OR ${lastColumn} >= ${sqlString2(filters.since)})`);
+  }
+  if (filters.until) {
+    filtersSql.push(`(${firstColumn} IS NULL OR ${firstColumn} < ${sqlString2(filters.until)})`);
+  }
+  return filtersSql.length ? filtersSql.join(" AND ") : null;
+}
+function projectFilter(filters, dialect) {
+  if (!filters.project) return null;
+  const exact = sqlString2(filters.project);
+  const like = sqlString2(`%${escapeLike(filters.project)}%`);
+  const op = dialect === "duckdb" ? "ILIKE" : "LIKE";
+  return `(project_id = ${exact} OR project_name ${op} ${like} ESCAPE '\\' OR project_path ${op} ${like} ESCAPE '\\')`;
+}
+function buildWhere(filters) {
+  const active = filters.filter((filter) => Boolean(filter));
+  return active.length ? `WHERE ${active.join(" AND ")}` : "";
+}
+function limit(filters) {
+  const value = Number.isFinite(filters.limit) ? filters.limit : void 0;
+  return clampLimit(value, { max: 500, fallback: 50 });
+}
+function sqlString2(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+
+// src/services/tool_calls.ts
+function listToolCalls(bundle, filters = {}) {
+  const conds = [];
+  const params = [];
+  if (filters.toolName) {
+    conds.push("tc.tool_name = ?");
+    params.push(filters.toolName);
+  }
+  if (filters.canonicalType) {
+    conds.push("tc.canonical_tool_type = ?");
+    params.push(filters.canonicalType);
+  }
+  if (filters.sessionId) {
+    conds.push("tc.session_id = ?");
+    params.push(filters.sessionId);
+  }
+  if (filters.errorsOnly) {
+    conds.push("(tr.is_error = 1 OR tc.status = ?)");
+    params.push("error");
+  }
+  if (filters.pathSubstring) {
+    conds.push("tc.path IS NOT NULL AND tc.path LIKE ?");
+    params.push(`%${filters.pathSubstring}%`);
+  }
+  if (filters.sinceIso) {
+    conds.push("(tc.timestamp_start IS NULL OR tc.timestamp_start >= ?)");
+    params.push(filters.sinceIso);
+  }
+  if (filters.untilIso) {
+    conds.push("(tc.timestamp_start IS NULL OR tc.timestamp_start < ?)");
+    params.push(filters.untilIso);
+  }
+  const where = conds.length ? `WHERE ${conds.join(" AND ")}` : "";
+  const limit2 = clampLimit(filters.limit, { max: 500, fallback: 100 });
+  const toolCallSql = `
+    SELECT 'tool_call' AS entity_type,
+           tc.session_id,
+           tc.tool_call_id,
+           NULL AS artifact_id,
+           tc.tool_name,
+           tc.canonical_tool_type,
+           tc.command,
+           tc.path,
+           tc.status,
+           tc.timestamp_start,
+           tr.is_error,
+           tr.exit_code,
+           tr.preview
+      FROM tool_calls tc
+      LEFT JOIN tool_results tr ON tr.tool_call_id = tc.tool_call_id
+      ${where}
+  `;
+  if (!filters.pathSubstring) {
+    const sql2 = `${toolCallSql} ORDER BY tc.timestamp_start DESC LIMIT ${limit2}`;
+    return bundle.db.prepare(sql2).all(...params);
+  }
+  const artifactSql = `
+    SELECT 'artifact' AS entity_type,
+           a.session_id,
+           NULL AS tool_call_id,
+           a.artifact_id,
+           NULL AS tool_name,
+           NULL AS canonical_tool_type,
+           NULL AS command,
+           a.path,
+           NULL AS status,
+           a.created_ts AS timestamp_start,
+           NULL AS is_error,
+           NULL AS exit_code,
+           NULL AS preview
+      FROM artifacts a
+     WHERE a.path IS NOT NULL AND a.path LIKE ?
+  `;
+  const sql = `
+    ${toolCallSql}
+    UNION ALL
+    ${artifactSql}
+    ORDER BY timestamp_start DESC
+    LIMIT ${limit2}
+  `;
+  return bundle.db.prepare(sql).all(...params, `%${filters.pathSubstring}%`);
+}
+
 // src/services/export/markdown.ts
 async function exportSessionMarkdown(bundle, sessionId2) {
   const session = bundle.db.prepare(
@@ -5424,6 +6310,8 @@ function renderToolCall(c) {
   return lines.join("\n");
 }
 export {
+  ANALYTICS_REPORTS,
+  ANALYTICS_VIEWS,
   COMPILE_PROVIDERS,
   PARQUET_TABLES,
   PROSA_PARSER_VERSION,
@@ -5453,6 +6341,7 @@ export {
   getText,
   initBundle,
   listSessions,
+  listToolCalls,
   markIndexesAfterImport,
   openBundle,
   openOrInitBundle,
@@ -5465,6 +6354,8 @@ export {
   recordError,
   registerSourceFile,
   resolveCompilePath,
+  runAnalyticsReport,
+  runAnalyticsReportFromBundle,
   runCompileImports,
   runMigrations,
   searchFullText,