@wrongstack/core 0.309.1 → 0.310.0

package/dist/chronicle/index.js

@@ -2047,7 +2047,11 @@ function relationKeys(event) {
   add("attempt", event.correlation.attemptId, "explicit");
   add("decision", event.attributes?.decisionId, "explicit");
   add("network_request", event.attributes?.requestId, "explicit");
-  add("prompt_manifest", event.attributes?.promptManifest?.manifestId, "explicit");
+  add(
+    "prompt_manifest",
+    event.correlation.promptManifestId ?? event.attributes?.promptManifest?.manifestId,
+    "explicit"
+  );
   add("resource_lineage", event.resource?.id, "inferred");
   if (event.eventType === "metrics.rollup" && event.attributes?.signal === "tool.resource.observed") {
     const resources = event.attributes.resources;
@@ -2069,6 +2073,7 @@ function matches(event, query) {
   if (!equal(query.agentId, event.scope.agentId) || !equal(query.taskId, event.scope.taskId)) return false;
   if (!equal(query.providerId, event.runtime?.providerId) || !equal(query.modelId, event.runtime?.modelId)) return false;
   if (!equal(query.traceId, event.correlation.traceId) || !equal(query.logicalRequestId, event.correlation.logicalRequestId)) return false;
+  if (!equal(query.promptManifestId, event.correlation.promptManifestId)) return false;
   if (!equal(query.attemptId, event.correlation.attemptId) || !equal(query.toolCallId, event.correlation.toolCallId)) return false;
   if (!equal(query.resourceKind, event.resource?.kind) || !equal(query.resourceId, event.resource?.id)) return false;
   if (query.path && normalize2(event.resource?.path) !== normalize2(query.path)) return false;
@@ -2209,6 +2214,7 @@ function isChronicleEvent(value) {
   ]) && typeof value.correlation.traceId === "string" && typeof value.correlation.spanId === "string" && optionalStrings(value.correlation, [
     "parentSpanId",
     "logicalRequestId",
+    "promptManifestId",
     "attemptId",
     "toolCallId"
   ]) && isRuntime(value.runtime) && isResource(value.resource) && (value.attributes === void 0 || isRecord(value.attributes)) && (value.tags === void 0 || isStringRecord(value.tags));
@@ -2398,7 +2404,7 @@ var ChronicleQuotaManager = class {
 };
 
 // src/chronicle/sqlite-journal-schema.ts
-import { createRequire } from "node:module";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
 
 // src/utils/pid.ts
 function isPidAlive(pid) {
@@ -2442,20 +2448,18 @@ var CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
 var LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
 var LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
 var LEGACY_JSONL_BOUNDARY_KEY = "legacy-jsonl-v1:boundary";
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
 var Ctor;
 function loadDatabaseSync() {
   if (Ctor) return Ctor;
-  if (Ctor === null) throw new Error("node:sqlite is unavailable in this runtime");
+  if (Ctor === null) throw new Error("SQLite is unavailable in this runtime");
   try {
-    Ctor = withSqliteExperimentalWarningSuppressed(
-      () => createRequire(import.meta.url)("node:sqlite").DatabaseSync
-    );
+    Ctor = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync);
     return Ctor;
   } catch (error) {
     Ctor = null;
     throw new Error(
-      "The Chronicle journal needs Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
+      "The Chronicle journal needs node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
     );
   }
 }
@@ -2470,6 +2474,7 @@ function projectEvent(event) {
     taskId: event.scope.taskId ?? null,
     traceId: event.correlation?.traceId ?? null,
     logicalRequestId: event.correlation?.logicalRequestId ?? null,
+    promptManifestId: event.correlation?.promptManifestId ?? null,
     resourceKind: event.resource?.kind ?? null,
     resourceId: event.resource?.id ?? null,
     resourcePath: event.resource?.path ?? null,
@@ -2494,6 +2499,7 @@ function ensureChronicleSchema(db) {
       task_id            TEXT,
       trace_id           TEXT,
       logical_request_id TEXT,
+      prompt_manifest_id TEXT,
       resource_kind      TEXT,
       resource_id        TEXT,
       resource_path      TEXT,
@@ -2521,6 +2527,10 @@ function ensureChronicleSchema(db) {
   if (version < 2) {
     db.exec("DROP INDEX IF EXISTS events_resource_path");
   }
+  if (version > 0 && version < 3) {
+    db.exec("ALTER TABLE events ADD COLUMN prompt_manifest_id TEXT");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS events_prompt_manifest ON events(prompt_manifest_id)");
   if (version !== SCHEMA_VERSION) {
     db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
   }
@@ -2557,6 +2567,7 @@ function pushDown(query) {
   eq("task_id", query.taskId);
   eq("trace_id", query.traceId);
   eq("logical_request_id", query.logicalRequestId);
+  eq("prompt_manifest_id", query.promptManifestId);
   eq("resource_kind", query.resourceKind);
   eq("resource_id", query.resourceId);
   if (query.eventTypes?.length) {
@@ -2913,6 +2924,7 @@ var ChronicleSqliteJournal = class {
           row.taskId,
           row.traceId,
           row.logicalRequestId,
+          row.promptManifestId,
           row.resourceKind,
           row.resourceId,
           row.resourcePath,
@@ -3072,9 +3084,9 @@ var ChronicleSqliteJournal = class {
     const insert = this.db.prepare(
       `INSERT INTO events (
          day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-         project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+         project_id, session_id, agent_id, task_id, trace_id, logical_request_id, prompt_manifest_id,
          resource_kind, resource_id, resource_path, duration_ns, payload
-       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
     );
     const checkpoint = this.db.prepare(
       `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
@@ -3103,6 +3115,7 @@ var ChronicleSqliteJournal = class {
             row.taskId,
             row.traceId,
             row.logicalRequestId,
+            row.promptManifestId,
             row.resourceKind,
             row.resourceId,
             row.resourcePath,
@@ -3189,9 +3202,9 @@ var ChronicleSqliteJournal = class {
       insert: this.db.prepare(
         `INSERT INTO events (
            day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-           project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+           project_id, session_id, agent_id, task_id, trace_id, logical_request_id, prompt_manifest_id,
            resource_kind, resource_id, resource_path, duration_ns, payload
-         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
       ),
       trimBoundary: this.db.prepare(
         "SELECT day, sequence, hash FROM events ORDER BY day, sequence LIMIT 1 OFFSET ?"
@@ -3232,8 +3245,8 @@ var ChronicleSqliteJournal = class {
 };
 
 // src/chronicle/metrics-schema.ts
-import { createRequire as createRequire2 } from "node:module";
-var SCHEMA_VERSION2 = 3;
+import { loadRuntimeDatabaseSync as loadRuntimeDatabaseSync2 } from "@wrongstack/persistence";
+var SCHEMA_VERSION2 = 4;
 var READ_CHUNK_BYTES = 1024 * 1024;
 var SQLITE_SOURCE_PREFIX = "sqlite:";
 var SQLITE_INGEST_BATCH = 2e3;
@@ -3251,16 +3264,14 @@ var EMPTY_FAMILIES = {
 var Ctor2;
 function loadDatabaseSync2() {
   if (Ctor2) return Ctor2;
-  if (Ctor2 === null) throw new Error("node:sqlite is unavailable in this runtime");
+  if (Ctor2 === null) throw new Error("SQLite is unavailable in this runtime");
   try {
-    Ctor2 = withSqliteExperimentalWarningSuppressed(
-      () => createRequire2(import.meta.url)("node:sqlite").DatabaseSync
-    );
+    Ctor2 = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync2);
     return Ctor2;
   } catch (error) {
     Ctor2 = null;
     throw new Error(
-      "Chronicle metrics need Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
+      "Chronicle metrics need node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
     );
   }
 }
@@ -3329,6 +3340,9 @@ function ensureMetricsSchema(db) {
       tool_name TEXT NOT NULL DEFAULT '',
       provider_id TEXT NOT NULL DEFAULT '',
       model_id TEXT NOT NULL DEFAULT '',
+      logical_request_id TEXT NOT NULL DEFAULT '',
+      prompt_manifest_id TEXT NOT NULL DEFAULT '',
+      provenance_confidence TEXT NOT NULL DEFAULT 'unknown',
       source TEXT NOT NULL DEFAULT ''
     );
     CREATE INDEX IF NOT EXISTS idx_file_lineage_path ON file_lineage(path_key, occurred_at);
@@ -3421,6 +3435,20 @@ var ChronicleMetricsIngester = class {
   db;
   directory;
   dbPath;
+  /**
+   * Prepared-statement cache for the per-event ingest hot paths. Preparing
+   * the same SQL on every event was the dominant ingest cost; node:sqlite
+   * statements are reusable, so each distinct SQL string is prepared once.
+   */
+  stmtCache = /* @__PURE__ */ new Map();
+  stmt(sql) {
+    let s = this.stmtCache.get(sql);
+    if (!s) {
+      s = this.db.prepare(sql);
+      this.stmtCache.set(sql, s);
+    }
+    return s;
+  }
   async refresh() {
     const result = {
       ingestedEvents: 0,
@@ -3450,7 +3478,7 @@ var ChronicleMetricsIngester = class {
             let base;
             if (!migrated) {
               base = offsets.get(key) ?? 0;
-            } else if (boundary !== null && boundary.has(key)) {
+            } else if (boundary?.has(key)) {
               base = Math.max(offsets.get(key) ?? 0, boundary.get(key));
             } else {
               base = rebuilt ? 0 : offsets.get(key) ?? 0;
@@ -3673,11 +3701,11 @@ var ChronicleMetricsIngester = class {
   }
   ingestDailyCounters(event) {
     const day = eventDay(event);
-    this.db.prepare("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
-    const bump = (sql, ...params) => this.db.prepare(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
+    this.stmt("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
+    const bump = (sql, ...params) => this.stmt(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
     const family = signalFamily(event);
     const failed = isTerminalFailure(event) ? 1 : 0;
-    this.db.prepare(
+    this.stmt(
       `INSERT INTO family_daily (day, family, count, failure_count) VALUES (?, ?, 1, ?)
        ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
     ).run(day, family, failed);
@@ -3686,12 +3714,15 @@ var ChronicleMetricsIngester = class {
       bump("cancellations = cancellations + 1");
     if (family === "agent") bump("agent_events = agent_events + 1");
     if (event.correlation.logicalRequestId) {
-      this.db.prepare(
+      this.stmt(
         "INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)"
       ).run(day, event.correlation.logicalRequestId);
     }
     if (event.scope.agentId) {
-      this.db.prepare("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(day, event.scope.agentId);
+      this.stmt("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(
+        day,
+        event.scope.agentId
+      );
     }
     const type = event.eventType;
     if (type === "decision.requested") bump("decisions = decisions + 1");
@@ -3713,7 +3744,10 @@ var ChronicleMetricsIngester = class {
     if (event.resource?.kind === "file" || type.startsWith("file.")) {
       bump("file_events_all = file_events_all + 1");
       if (event.resource?.path) {
-        this.db.prepare("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(day, normalizePathKey(event.resource.path));
+        this.stmt("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(
+          day,
+          normalizePathKey(event.resource.path)
+        );
       }
     }
   }
@@ -3722,8 +3756,10 @@ var ChronicleMetricsIngester = class {
     const providerId = event.runtime?.providerId ?? asString(readPath2(event.attributes ?? {}, "from.providerId")) ?? "";
     const modelId = event.runtime?.modelId ?? asString(readPath2(event.attributes ?? {}, "from.model")) ?? "";
     if (!providerId && !modelId) return;
-    this.db.prepare("INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)").run(day, providerId, modelId);
-    const update = (sql, ...params) => this.db.prepare(
+    this.stmt(
+      "INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)"
+    ).run(day, providerId, modelId);
+    const update = (sql, ...params) => this.stmt(
       `UPDATE provider_daily SET ${sql} WHERE day = ? AND provider_id = ? AND model_id = ?`
     ).run(...params, day, providerId, modelId);
     const duration = durationMs2(event);
@@ -3764,7 +3800,7 @@ var ChronicleMetricsIngester = class {
     if (typeof cost !== "number" || !Number.isFinite(cost)) return;
     const scopeKey2 = `${event.scope.projectId ?? ""}\0${event.scope.sessionId ?? ""}\0${event.scope.agentId ?? ""}`;
     const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare(
+    this.stmt(
       `INSERT INTO token_cost (scope_key, day, occurred_at, sequence, cost) VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(scope_key) DO UPDATE SET
          day = excluded.day, occurred_at = excluded.occurred_at,
@@ -3778,8 +3814,8 @@ var ChronicleMetricsIngester = class {
     const taskId = event.scope.taskId ?? stringAt(attributes, "taskId");
     if (!taskId) return;
     const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
-    const set = (sql, ...params) => this.db.prepare(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
+    this.stmt("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
+    const set = (sql, ...params) => this.stmt(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
     const lineage = [
       ["run_id", stringAt(attributes, "runId")],
       ["board_id", event.scope.kanbanBoardId ?? stringAt(attributes, "boardId")],
@@ -3826,11 +3862,12 @@ var ChronicleMetricsIngester = class {
     if (!operation || operation === "read") return;
     const filePath = event.resource?.path ?? stringAt(attributes, "filePath");
     if (!filePath) return;
-    this.db.prepare(
+    this.stmt(
       `INSERT OR IGNORE INTO file_lineage
         (event_id, path, path_key, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
-         tool_name, provider_id, model_id, source)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+         tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+         provenance_confidence, source)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(
       event.eventId,
       normalizeKey(filePath),
@@ -3845,10 +3882,17 @@ var ChronicleMetricsIngester = class {
       stringAt(attributes, "toolName") ?? "",
       event.runtime?.providerId ?? stringAt(attributes, "provider") ?? "",
       event.runtime?.modelId ?? stringAt(attributes, "model") ?? "",
+      event.correlation.logicalRequestId ?? stringAt(attributes, "logicalRequestId") ?? "",
+      event.correlation.promptManifestId ?? stringAt(attributes, "promptManifestId") ?? "",
+      provenanceConfidence(attributes),
       stringAt(attributes, "source") ?? (event.eventType === "file.event" ? "tool" : "external")
     );
   }
 };
+function provenanceConfidence(attributes) {
+  const value = attributes["provenanceConfidence"];
+  return value === "explicit" || value === "correlated" || value === "inferred" ? value : "unknown";
+}
 
 // src/chronicle/metrics-store.ts
 var ChronicleMetricsStore = class _ChronicleMetricsStore {
@@ -3980,7 +4024,8 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
     const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
     params.push(clampLimit(options.limit, 200));
     const projection = `path, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
-       tool_name, provider_id, model_id, source`;
+       tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+       provenance_confidence, source`;
     const sql = options.latestPerPath ? `SELECT ${projection} FROM (
            SELECT ${projection}, ROW_NUMBER() OVER (
              PARTITION BY path_key ORDER BY occurred_at DESC, event_id DESC
@@ -4001,6 +4046,9 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
       toolName: row.tool_name,
       providerId: row.provider_id,
       modelId: row.model_id,
+      logicalRequestId: row.logical_request_id,
+      promptManifestId: row.prompt_manifest_id,
+      provenanceConfidence: row.provenance_confidence,
       source: row.source
     }));
   }
@@ -4845,6 +4893,7 @@ var EMPTY_JOURNAL_STATS = {
   largestBatch: 0,
   partitionRolls: 0
 };
+var MAX_OPEN_JOURNAL_DAYS = 2;
 var InlineChronicleProjectAccess = class {
   constructor(options) {
     this.options = options;
@@ -4953,6 +5002,26 @@ var InlineChronicleProjectAccess = class {
   get chronicleDirectory() {
     return path15.join(this.options.projectDir, "chronicle");
   }
+  /**
+   * Drop journals for days we will not write to again.
+   *
+   * Mirrors the daemon's `pruneJournals` in `project-server.ts`: without a cap
+   * an inline access object that lives across midnight kept one open
+   * `ChronicleJournal` (with its write buffer and file handle) per day, forever.
+   */
+  pruneJournals(currentDay) {
+    if (this.journals.size <= MAX_OPEN_JOURNAL_DAYS) return;
+    const keep = new Set(
+      [...this.journals.keys()].sort().reverse().slice(0, MAX_OPEN_JOURNAL_DAYS)
+    );
+    keep.add(currentDay);
+    for (const [day, journal] of this.journals) {
+      if (keep.has(day)) continue;
+      this.journals.delete(day);
+      void journal.flush().catch(() => {
+      });
+    }
+  }
   journalForToday() {
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
@@ -4969,6 +5038,7 @@ var InlineChronicleProjectAccess = class {
         retentionDays: this.options.retentionDays
       });
       this.journals.set(day, journal);
+      this.pruneJournals(day);
     }
     return journal;
   }
@@ -5016,8 +5086,7 @@ var InlineChronicleProjectAccess = class {
 
 // src/chronicle/sqlite-compaction.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-var require2 = createRequire3(import.meta.url);
+import { loadRuntimeDatabaseSync as loadRuntimeDatabaseSync3 } from "@wrongstack/persistence";
 var ChronicleCompactionBusyError = class extends Error {
   constructor(pid) {
     super(`Chronicle project server is still running (pid ${pid}); stop it before compacting`);
@@ -5040,9 +5109,7 @@ function compactChronicleSqlite(options) {
   if (!existsSync2(options.dbPath)) {
     return { beforeBytes, afterBytes: beforeBytes, reclaimedBytes: 0 };
   }
-  const Database = withSqliteExperimentalWarningSuppressed(
-    () => require2("node:sqlite").DatabaseSync
-  );
+  const Database = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync3);
   const db = new Database(options.dbPath);
   try {
     db.exec("PRAGMA busy_timeout = 1");
@@ -5112,6 +5179,7 @@ function persist(options, event, base, seenToolManifests) {
       ...context.correlation,
       ...event.traceId ? { traceId: event.traceId } : {},
       logicalRequestId: event.logicalRequestId,
+      ...event.promptManifestId ? { promptManifestId: event.promptManifestId } : {},
       attemptId: event.attemptId
     },
     runtime: { providerId: event.providerId, modelId: event.model },
@@ -5127,6 +5195,7 @@ function providerAttributes(event, seenToolManifests) {
     providerId: _providerId,
     model: _model,
     logicalRequestId: _logicalRequestId,
+    promptManifestId: _promptManifestId,
     attemptId: _attemptId,
     ...rest
   } = event;
@@ -5269,6 +5338,8 @@ function persist2(options, event, fields) {
     correlation: {
       ...context.correlation,
       ...event.traceId ? { traceId: event.traceId } : {},
+      ...event.logicalRequestId ? { logicalRequestId: event.logicalRequestId } : {},
+      ...event.promptManifestId ? { promptManifestId: event.promptManifestId } : {},
       ...event.id ? { toolCallId: event.id } : {}
     },
     ...event.provider || event.model ? {
@@ -5528,7 +5599,8 @@ function wireDomainEventsToChronicle(options) {
         ...stringField(record, "traceId") ? { traceId: stringField(record, "traceId") } : {},
         ...stringField(record, "toolCallId") ? { toolCallId: stringField(record, "toolCallId") } : {},
         ...stringField(record, "attemptId") ? { attemptId: stringField(record, "attemptId") } : {},
-        ...stringField(record, "logicalRequestId") ? { logicalRequestId: stringField(record, "logicalRequestId") } : {}
+        ...stringField(record, "logicalRequestId") ? { logicalRequestId: stringField(record, "logicalRequestId") } : {},
+        ...stringField(record, "promptManifestId") ? { promptManifestId: stringField(record, "promptManifestId") } : {}
       },
       outcome: inferOutcome(eventName, record),
       runtime: {

package/dist/chronicle/metrics-ingest.d.ts

@@ -4,7 +4,14 @@ export declare class ChronicleMetricsIngester {
     private readonly db;
     private readonly directory;
     private readonly dbPath;
+    /**
+     * Prepared-statement cache for the per-event ingest hot paths. Preparing
+     * the same SQL on every event was the dominant ingest cost; node:sqlite
+     * statements are reusable, so each distinct SQL string is prepared once.
+     */
+    private stmtCache;
     constructor(db: DatabaseSync, directory: string, dbPath: string);
+    private stmt;
     refresh(): Promise<ChronicleMetricsRefreshResult>;
     private loadOffsets;
     /** True once the legacy JSONL journal was imported into the SQLite journal

package/dist/chronicle/metrics-schema.d.ts

@@ -1,7 +1,7 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { ChronicleSignalFamily } from './query.js';
 import type { ChronicleEvent } from './types.js';
-export declare const SCHEMA_VERSION = 3;
+export declare const SCHEMA_VERSION = 4;
 export declare const READ_CHUNK_BYTES: number;
 export declare const SQLITE_SOURCE_PREFIX = "sqlite:";
 export declare const SQLITE_INGEST_BATCH = 2000;
@@ -54,6 +54,9 @@ export interface ChronicleFileLineageRow {
     toolName: string;
     providerId: string;
     modelId: string;
+    logicalRequestId: string;
+    promptManifestId: string;
+    provenanceConfidence: 'explicit' | 'correlated' | 'inferred' | 'unknown';
     source: string;
 }
 export interface ChronicleMetricsSummary {