@wrongstack/core 0.306.3 → 0.307.0

package/dist/chronicle/index.js

@@ -171,9 +171,9 @@ async function startChronicleFileObserver(options) {
   const recentToolMutations = /* @__PURE__ */ new Map();
   const noteToolMutation = (hint) => {
     const absolute = path3.isAbsolute(hint.path) ? path3.normalize(hint.path) : path3.resolve(root, hint.path);
-    const relative4 = normalizeRelative(path3.relative(root, absolute));
-    if (relative4.startsWith("../") || isExcluded(relative4, excluded, excludedPaths)) return;
-    recentToolMutations.set(relative4, {
+    const relative5 = normalizeRelative(path3.relative(root, absolute));
+    if (relative5.startsWith("../") || isExcluded(relative5, excluded, excludedPaths)) return;
+    recentToolMutations.set(relative5, {
       at: hint.at ?? Date.now(),
       toolUseId: hint.toolUseId,
       toolName: hint.toolName,
@@ -235,9 +235,9 @@ async function startChronicleFileObserver(options) {
       requestFullRescan();
       return;
     }
-    const relative4 = normalizeRelative(String(filename));
-    if (!relative4 || isExcluded(relative4, excluded, excludedPaths)) return;
-    pending.add(relative4);
+    const relative5 = normalizeRelative(String(filename));
+    if (!relative5 || isExcluded(relative5, excluded, excludedPaths)) return;
+    pending.add(relative5);
     bumpDebounce();
   };
   const reconcile = async (changedPaths) => {
@@ -245,15 +245,15 @@ async function startChronicleFileObserver(options) {
     if (wantsFullScan) lastFullScanAt = Date.now();
     const fullScan = wantsFullScan ? await scanProject(root, excluded, excludedPaths, maxHashBytes, options.onError, known) : void 0;
     const candidates = (fullScan ? unionKeys(known, fullScan.files) : changedPaths).filter(
-      (relative4) => !isExcluded(relative4, excluded, excludedPaths)
+      (relative5) => !isExcluded(relative5, excluded, excludedPaths)
     );
     const changes = [];
-    for (const relative4 of candidates) {
-      const before = known.get(relative4);
-      const cached = fullScan?.files.get(relative4);
-      const after = cached ?? (fullScan?.complete ? void 0 : await fingerprint(path3.join(root, relative4), maxHashBytes));
+    for (const relative5 of candidates) {
+      const before = known.get(relative5);
+      const cached = fullScan?.files.get(relative5);
+      const after = cached ?? (fullScan?.complete ? void 0 : await fingerprint(path3.join(root, relative5), maxHashBytes));
       if (sameFingerprint(before, after)) continue;
-      changes.push({ relative: relative4, before, after });
+      changes.push({ relative: relative5, before, after });
     }
     const deleted = changes.filter((change) => change.before && !change.after);
     const created = changes.filter((change) => !change.before && change.after);
@@ -447,25 +447,25 @@ async function scanProject(root, excluded, excludedPaths, maxHashBytes, onError,
       const entries = await fsp.readdir(path3.join(root, relativeDir), { withFileTypes: true });
       const filePaths = [];
       for (const entry of entries) {
-        const relative4 = normalizeRelative(path3.join(relativeDir, entry.name));
-        if (isExcluded(relative4, excluded, excludedPaths)) continue;
+        const relative5 = normalizeRelative(path3.join(relativeDir, entry.name));
+        if (isExcluded(relative5, excluded, excludedPaths)) continue;
         if (entry.isDirectory()) {
-          dirs.push(relative4);
+          dirs.push(relative5);
         } else if (entry.isFile()) {
-          filePaths.push(relative4);
+          filePaths.push(relative5);
         }
       }
       const fingerprints = await mapWithConcurrency(
         filePaths,
         SCAN_HASH_CONCURRENCY,
-        async (relative4) => {
+        async (relative5) => {
           try {
             const value = await fingerprint(
-              path3.join(root, relative4),
+              path3.join(root, relative5),
               maxHashBytes,
-              previous?.get(relative4)
+              previous?.get(relative5)
             );
-            return value ? [relative4, value] : null;
+            return value ? [relative5, value] : null;
           } catch (error) {
             complete = false;
             onError?.(error);
@@ -485,14 +485,14 @@ async function scanProject(root, excluded, excludedPaths, maxHashBytes, onError,
 }
 async function fingerprint(filePath, maxHashBytes, previous) {
   try {
-    const stat4 = await fsp.stat(filePath);
-    if (!stat4.isFile()) return void 0;
-    const base = { size: stat4.size, mtimeMs: stat4.mtimeMs };
-    if (previous?.hash !== void 0 && previous.size === stat4.size && previous.mtimeMs === stat4.mtimeMs) {
+    const stat5 = await fsp.stat(filePath);
+    if (!stat5.isFile()) return void 0;
+    const base = { size: stat5.size, mtimeMs: stat5.mtimeMs };
+    if (previous?.hash !== void 0 && previous.size === stat5.size && previous.mtimeMs === stat5.mtimeMs) {
       base.hash = previous.hash;
       return base;
     }
-    if (stat4.size <= maxHashBytes) {
+    if (stat5.size <= maxHashBytes) {
       base.hash = createHash2("sha256").update(await fsp.readFile(filePath)).digest("hex");
     }
     return base;
@@ -507,8 +507,8 @@ function sameFingerprint(a, b) {
   if (a.hash !== void 0 && b.hash !== void 0) return a.hash === b.hash;
   return a.size === b.size && a.mtimeMs === b.mtimeMs;
 }
-function isExcluded(relative4, excluded, excludedPaths) {
-  const normalized = normalizeRelative(relative4);
+function isExcluded(relative5, excluded, excludedPaths) {
+  const normalized = normalizeRelative(relative5);
   if (normalized.split("/").some((segment) => excluded.has(segment))) return true;
   for (const prefix of excludedPaths) {
     if (normalized === prefix || normalized.startsWith(`${prefix}/`)) return true;
@@ -518,8 +518,8 @@ function isExcluded(relative4, excluded, excludedPaths) {
 function normalizeExcludedPaths(root, values) {
   const result = /* @__PURE__ */ new Set();
   for (const value of values) {
-    const relative4 = path3.isAbsolute(value) ? path3.relative(root, path3.resolve(value)) : value;
-    const normalized = normalizeRelative(relative4).replace(/\/+$/u, "");
+    const relative5 = path3.isAbsolute(value) ? path3.relative(root, path3.resolve(value)) : value;
+    const normalized = normalizeRelative(relative5).replace(/\/+$/u, "");
     if (!normalized || normalized === "." || normalized.startsWith("../")) continue;
     result.add(normalized);
   }
@@ -538,7 +538,7 @@ function unionKeys(a, b) {
 // src/chronicle/project-access.ts
 import * as fsPromises from "node:fs/promises";
 import * as os4 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // src/utils/wstack-paths.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -1376,8 +1376,8 @@ async function readLastEntryState(filePath) {
     throw error;
   }
   try {
-    const stat4 = await handle.stat();
-    const size = stat4.size;
+    const stat5 = await handle.stat();
+    const size = stat5.size;
     let position = size, suffix = "";
     while (position > 0) {
       const length = Math.min(65536, position);
@@ -1394,23 +1394,25 @@ async function readLastEntryState(filePath) {
           return {
             entry: JSON.parse(trimmed),
             size,
-            birthtimeMs: stat4.birthtimeMs
+            birthtimeMs: stat5.birthtimeMs
           };
         } catch {
         }
       }
       suffix = lines[0] ?? "";
     }
-    return { size, birthtimeMs: stat4.birthtimeMs };
+    return { size, birthtimeMs: stat5.birthtimeMs };
   } finally {
     await handle.close();
   }
 }
 async function* streamEntriesStrict(filePath) {
   let lineNumber = 0;
+  let input;
+  let lines;
   try {
-    const input = createReadStream(filePath, { encoding: "utf8", highWaterMark: 256 * 1024 });
-    const lines = createInterface({ input, crlfDelay: Infinity });
+    input = createReadStream(filePath, { encoding: "utf8", highWaterMark: 256 * 1024 });
+    lines = createInterface({ input, crlfDelay: Infinity });
     for await (const line of lines) {
       lineNumber++;
       const trimmed = line.trim();
@@ -1426,6 +1428,9 @@ async function* streamEntriesStrict(filePath) {
   } catch (error) {
     if (isNotFound(error)) return;
     throw error;
+  } finally {
+    lines?.close();
+    input?.destroy();
   }
 }
 async function readEntriesStrict(filePath) {
@@ -1441,33 +1446,12 @@ function errorMessage(error) {
 }
 
 // src/chronicle/metrics-store.ts
+import * as path11 from "node:path";
+
+// src/chronicle/metrics-ingest.ts
 import * as fs7 from "node:fs/promises";
-import { createRequire as createRequire2 } from "node:module";
 import * as path10 from "node:path";
 
-// src/utils/sqlite-warning.ts
-var SQLITE_EXPERIMENTAL_WARNING_RE = /sqlite is an experimental feature/i;
-function isSqliteExperimentalWarning(warning, rest) {
-  const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : "";
-  const typeOrOptions = rest[0];
-  const warningType = typeof warning === "string" ? typeof typeOrOptions === "string" ? typeOrOptions : typeof typeOrOptions === "object" && typeOrOptions !== null && "type" in typeOrOptions && typeof typeOrOptions.type === "string" ? typeOrOptions.type : "" : warning instanceof Error ? warning.name : "";
-  const warningCode = typeof warning === "string" ? typeof typeOrOptions === "object" && typeOrOptions !== null && "code" in typeOrOptions && typeof typeOrOptions.code === "string" ? typeOrOptions.code : typeof rest[1] === "string" ? rest[1] : "" : warning instanceof Error && "code" in warning && typeof warning.code === "string" ? warning.code : "";
-  return SQLITE_EXPERIMENTAL_WARNING_RE.test(message) && (warningType === "ExperimentalWarning" || warningCode === "ExperimentalWarning");
-}
-function withSqliteExperimentalWarningSuppressed(run) {
-  const originalEmitWarning = process.emitWarning;
-  const forwardWarning = originalEmitWarning.bind(process);
-  process.emitWarning = ((warning, ...rest) => {
-    if (isSqliteExperimentalWarning(warning, rest)) return;
-    forwardWarning(warning, ...rest);
-  });
-  try {
-    return run();
-  } finally {
-    process.emitWarning = originalEmitWarning;
-  }
-}
-
 // src/chronicle/query.ts
 import { createHash as createHash5 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
@@ -1562,14 +1546,21 @@ var CHRONICLE_FACET_FIELDS = /* @__PURE__ */ new Set([
   "toolCallId"
 ]);
 var MAX_CURSOR_SNAPSHOT_ENTRIES = 1e4;
-function streamLines(filePath, maxBytes) {
+async function* streamLines(filePath, maxBytes) {
   const stream = createReadStream2(filePath, {
     encoding: "utf8",
     highWaterMark: 256 * 1024,
     ...maxBytes !== void 0 ? { end: maxBytes - 1 } : {}
   });
   const rl = createInterface2({ input: stream, crlfDelay: Infinity });
-  return rl[Symbol.asyncIterator]();
+  try {
+    for await (const line of rl) {
+      yield line;
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
 }
 async function computeOccurredAtRange(file, size) {
   let min;
@@ -2271,9 +2262,143 @@ function facetValue(event, field) {
 
 // src/chronicle/sqlite-journal.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
+import * as path9 from "node:path";
+
+// src/chronicle/sqlite-journal-quota.ts
 import * as fs6 from "node:fs";
+var SQLITE_FIXED_OVERHEAD_BYTES = 16 * 1024 * 1024;
+var MIN_SQLITE_PAGE_BUDGET_BYTES = 64 * 1024;
+var MAX_WAL_RESERVE_BYTES = 32 * 1024 * 1024;
+var WAL_AUTOCHECKPOINT_PAGES = 2e3;
+var WAL_SIZE_LIMIT_BYTES = 16 * 1024 * 1024;
+var ChronicleStorageQuotaError = class extends Error {
+  currentBytes;
+  batchBytes;
+  maxBytes;
+  path;
+  constructor(details) {
+    super(
+      `Chronicle SQLite quota exceeded at ${details.path}: ${details.currentBytes} live bytes + ${details.batchBytes} batch bytes exceeds ${details.maxBytes}; lower chronicle retentionDays/maxEvents to shed data (run chronicle compact to return the freed pages to the filesystem)`
+    );
+    this.name = "ChronicleStorageQuotaError";
+    this.currentBytes = details.currentBytes;
+    this.batchBytes = details.batchBytes;
+    this.maxBytes = details.maxBytes;
+    this.path = details.path;
+  }
+};
+var ChronicleQuotaManager = class {
+  constructor(db, dbPath, maxBytes) {
+    this.db = db;
+    this.dbPath = dbPath;
+    this.maxBytes = maxBytes;
+  }
+  db;
+  dbPath;
+  maxBytes;
+  cachedPageSize;
+  quotaHeadroomBytes = 0;
+  bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
+  configure() {
+    if (this.maxBytes === void 0) {
+      this.db.exec("PRAGMA max_page_count = 2147483646");
+      return;
+    }
+    const halfSplit = Math.floor((this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES) / 2);
+    const sidecarReserve = Math.min(MAX_WAL_RESERVE_BYTES, halfSplit);
+    const mainBudget = this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES - sidecarReserve;
+    if (mainBudget < MIN_SQLITE_PAGE_BUDGET_BYTES) {
+      throw new Error(
+        `maxBytes must be at least ${SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES}`
+      );
+    }
+    const maxPages = Math.max(1, Math.floor(mainBudget / this.pageSizeBytes()));
+    this.db.exec(`PRAGMA max_page_count = ${maxPages}`);
+  }
+  pageSizeBytes() {
+    if (this.cachedPageSize === void 0) {
+      this.cachedPageSize = Number(
+        this.db.prepare("PRAGMA page_size").get().page_size
+      );
+    }
+    return this.cachedPageSize;
+  }
+  aggregateLiveBytes() {
+    let total = 0;
+    for (const file of [`${this.dbPath}-journal`, `${this.dbPath}-wal`, `${this.dbPath}-shm`]) {
+      try {
+        total += fs6.statSync(file).size;
+      } catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+      }
+    }
+    return total + this.mainDatabaseLiveBytes();
+  }
+  mainDatabaseLiveBytes() {
+    const pageCount = Number(
+      this.db.prepare("PRAGMA page_count").get().page_count
+    );
+    const freelist = Number(
+      this.db.prepare("PRAGMA freelist_count").get().freelist_count
+    );
+    return Math.max(0, pageCount - freelist) * this.pageSizeBytes();
+  }
+  invalidateEstimate() {
+    this.quotaHeadroomBytes = 0;
+    this.bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
+  }
+  recordAppendedBytes(bytes) {
+    this.bytesSinceQuotaCheck += bytes;
+  }
+  assertWithinByteQuota(batchBytes) {
+    if (this.maxBytes === void 0) return;
+    if (!this.shouldMeasureQuota(batchBytes)) return;
+    const currentBytes = this.aggregateLiveBytes();
+    this.recordQuotaHeadroom(currentBytes);
+    if (currentBytes + batchBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  assertActualAllocationWithinQuota() {
+    if (this.maxBytes === void 0) return;
+    if (!this.shouldMeasureQuota()) return;
+    const currentBytes = this.aggregateLiveBytes();
+    this.recordQuotaHeadroom(currentBytes);
+    if (currentBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  normalizeQuotaError(error) {
+    if (this.maxBytes === void 0 || !(error instanceof Error)) return error;
+    const sqliteError = error;
+    const quotaExhausted = sqliteError.code === "SQLITE_FULL" || sqliteError.code === 13 || sqliteError.errcode === 13 || /database or disk is full/i.test(sqliteError.message);
+    if (!quotaExhausted) return error;
+    return new ChronicleStorageQuotaError({
+      currentBytes: this.aggregateLiveBytes(),
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  shouldMeasureQuota(batchBytes = 0) {
+    return this.bytesSinceQuotaCheck + batchBytes >= this.quotaHeadroomBytes / 2;
+  }
+  recordQuotaHeadroom(currentBytes) {
+    this.quotaHeadroomBytes = Math.max(0, (this.maxBytes ?? 0) - currentBytes);
+    this.bytesSinceQuotaCheck = 0;
+  }
+};
+
+// src/chronicle/sqlite-journal-schema.ts
 import { createRequire } from "node:module";
-import * as path9 from "node:path";
 
 // src/utils/pid.ts
 function isPidAlive(pid) {
@@ -2289,6 +2414,118 @@ function isPidAlive(pid) {
   }
 }
 
+// src/utils/sqlite-warning.ts
+var SQLITE_EXPERIMENTAL_WARNING_RE = /sqlite is an experimental feature/i;
+function isSqliteExperimentalWarning(warning, rest) {
+  const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : "";
+  const typeOrOptions = rest[0];
+  const warningType = typeof warning === "string" ? typeof typeOrOptions === "string" ? typeOrOptions : typeof typeOrOptions === "object" && typeOrOptions !== null && "type" in typeOrOptions && typeof typeOrOptions.type === "string" ? typeOrOptions.type : "" : warning instanceof Error ? warning.name : "";
+  const warningCode = typeof warning === "string" ? typeof typeOrOptions === "object" && typeOrOptions !== null && "code" in typeOrOptions && typeof typeOrOptions.code === "string" ? typeOrOptions.code : typeof rest[1] === "string" ? rest[1] : "" : warning instanceof Error && "code" in warning && typeof warning.code === "string" ? warning.code : "";
+  return SQLITE_EXPERIMENTAL_WARNING_RE.test(message) && (warningType === "ExperimentalWarning" || warningCode === "ExperimentalWarning");
+}
+function withSqliteExperimentalWarningSuppressed(run) {
+  const originalEmitWarning = process.emitWarning;
+  const forwardWarning = originalEmitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    if (isSqliteExperimentalWarning(warning, rest)) return;
+    forwardWarning(warning, ...rest);
+  });
+  try {
+    return run();
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+// src/chronicle/sqlite-journal-schema.ts
+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 Ctor;
+function loadDatabaseSync() {
+  if (Ctor) return Ctor;
+  if (Ctor === null) throw new Error("node:sqlite is unavailable in this runtime");
+  try {
+    Ctor = withSqliteExperimentalWarningSuppressed(
+      () => createRequire(import.meta.url)("node:sqlite").DatabaseSync
+    );
+    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))
+    );
+  }
+}
+function projectEvent(event) {
+  const occurredAt = event.occurredAt ?? event.observedAt;
+  return {
+    occurredAt,
+    outcome: event.outcome ?? null,
+    projectId: event.scope.projectId ?? null,
+    sessionId: event.scope.sessionId ?? null,
+    agentId: event.scope.agentId ?? null,
+    taskId: event.scope.taskId ?? null,
+    traceId: event.correlation?.traceId ?? null,
+    logicalRequestId: event.correlation?.logicalRequestId ?? null,
+    resourceKind: event.resource?.kind ?? null,
+    resourceId: event.resource?.id ?? null,
+    resourcePath: event.resource?.path ?? null,
+    durationNs: event.durationNs ?? null
+  };
+}
+function ensureChronicleSchema(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      day                TEXT NOT NULL,
+      sequence           INTEGER NOT NULL,
+      event_id           TEXT NOT NULL UNIQUE,
+      hash               TEXT NOT NULL,
+      previous_hash      TEXT NOT NULL,
+      occurred_at        TEXT NOT NULL,
+      event_type         TEXT NOT NULL,
+      outcome            TEXT,
+      project_id         TEXT,
+      session_id         TEXT,
+      agent_id           TEXT,
+      task_id            TEXT,
+      trace_id           TEXT,
+      logical_request_id TEXT,
+      resource_kind      TEXT,
+      resource_id        TEXT,
+      resource_path      TEXT,
+      duration_ns        TEXT,
+      payload            TEXT NOT NULL,
+      PRIMARY KEY (day, sequence)
+    );
+    CREATE INDEX IF NOT EXISTS events_occurred_at ON events(occurred_at);
+    CREATE INDEX IF NOT EXISTS events_type_outcome ON events(event_type, outcome);
+    CREATE INDEX IF NOT EXISTS events_session ON events(session_id, day, sequence);
+    CREATE INDEX IF NOT EXISTS events_trace ON events(trace_id);
+    CREATE INDEX IF NOT EXISTS events_logical_request ON events(logical_request_id);
+
+    CREATE TABLE IF NOT EXISTS chain_checkpoint (
+      day      TEXT PRIMARY KEY,
+      sequence INTEGER NOT NULL,
+      hash     TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS chronicle_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  if (version < 2) {
+    db.exec("DROP INDEX IF EXISTS events_resource_path");
+  }
+  if (version !== SCHEMA_VERSION) {
+    db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+  }
+}
+
 // src/chronicle/sqlite-query.ts
 var MAX_LIMIT = 1e4;
 function encodeCursor2(cursor) {
@@ -2527,49 +2764,8 @@ var ChronicleSqliteQueryEngine = class {
 };
 
 // src/chronicle/sqlite-journal.ts
-var CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
-var LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
-var LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
-var SCHEMA_VERSION = 2;
-var SQLITE_FIXED_OVERHEAD_BYTES = 16 * 1024 * 1024;
-var MIN_SQLITE_PAGE_BUDGET_BYTES = 64 * 1024;
-var MAX_WAL_RESERVE_BYTES = 32 * 1024 * 1024;
-var WAL_AUTOCHECKPOINT_PAGES = 2e3;
-var WAL_SIZE_LIMIT_BYTES = 16 * 1024 * 1024;
 var TRIM_SLACK_RATIO = 0.02;
 var MAX_TRIM_SLACK_EVENTS = 2e3;
-var ChronicleStorageQuotaError = class extends Error {
-  currentBytes;
-  batchBytes;
-  maxBytes;
-  path;
-  constructor(details) {
-    super(
-      `Chronicle SQLite quota exceeded at ${details.path}: ${details.currentBytes} live bytes + ${details.batchBytes} batch bytes exceeds ${details.maxBytes}; lower chronicle retentionDays/maxEvents to shed data (run chronicle compact to return the freed pages to the filesystem)`
-    );
-    this.name = "ChronicleStorageQuotaError";
-    this.currentBytes = details.currentBytes;
-    this.batchBytes = details.batchBytes;
-    this.maxBytes = details.maxBytes;
-    this.path = details.path;
-  }
-};
-var Ctor;
-function loadDatabaseSync() {
-  if (Ctor) return Ctor;
-  if (Ctor === null) throw new Error("node:sqlite is unavailable in this runtime");
-  try {
-    Ctor = withSqliteExperimentalWarningSuppressed(
-      () => createRequire(import.meta.url)("node:sqlite").DatabaseSync
-    );
-    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))
-    );
-  }
-}
 var ChronicleSqliteJournal = class {
   db;
   dbPath;
@@ -2578,21 +2774,12 @@ var ChronicleSqliteJournal = class {
   idFactory;
   retentionDays;
   maxEvents;
-  maxBytes;
   retentionCheckIntervalMs;
   /** Overshoot allowed above `maxEvents` before eviction runs; see TRIM_SLACK_RATIO. */
   trimSlack;
+  quotaManager;
   nextRetentionCheckAt = 0;
   retainedEventCount = 0;
-  /** Resolved lazily by `pageSizeBytes()`; constant for an open database. */
-  cachedPageSize;
-  /**
-   * Bytes the quota is known to have had spare at the last real measurement,
-   * and the bytes appended since. `assertWithinByteQuota` re-measures only once
-   * the second could plausibly have consumed the first — see its comment.
-   */
-  quotaHeadroomBytes = 0;
-  bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
   /**
    * Statements reused across appends.
    *
@@ -2640,7 +2827,6 @@ var ChronicleSqliteJournal = class {
     }
     this.retentionDays = options.retentionDays;
     this.maxEvents = options.maxEvents;
-    this.maxBytes = options.maxBytes;
     this.retentionCheckIntervalMs = options.retentionCheckIntervalMs ?? 60 * 60 * 1e3;
     this.trimSlack = this.maxEvents === void 0 ? 0 : Math.min(MAX_TRIM_SLACK_EVENTS, Math.floor(this.maxEvents * TRIM_SLACK_RATIO));
     const Database = loadDatabaseSync();
@@ -2649,8 +2835,9 @@ var ChronicleSqliteJournal = class {
     this.db.exec("PRAGMA synchronous = FULL");
     this.db.exec(`PRAGMA wal_autocheckpoint = ${WAL_AUTOCHECKPOINT_PAGES}`);
     this.db.exec(`PRAGMA journal_size_limit = ${WAL_SIZE_LIMIT_BYTES}`);
-    this.ensureSchema();
-    this.configureByteQuota();
+    ensureChronicleSchema(this.db);
+    this.quotaManager = new ChronicleQuotaManager(this.db, this.dbPath, options.maxBytes);
+    this.quotaManager.configure();
     if (this.maxEvents !== void 0) {
       const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
       this.retainedEventCount = row.count;
@@ -2664,16 +2851,10 @@ var ChronicleSqliteJournal = class {
     return {
       ...this.counters,
       pendingEvents: 0,
-      // Retained at zero for wire compatibility: partitions do not exist here,
-      // but `ChronicleJournalStats` is part of the IPC health payload.
       partitionRolls: 0,
       ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
     };
   }
-  /**
-   * Writes are synchronous and transactional, so there is nothing buffered to
-   * flush. Kept to satisfy `ChronicleEventSink`.
-   */
   async flush() {
     return Promise.resolve();
   }
@@ -2681,13 +2862,6 @@ var ChronicleSqliteJournal = class {
     const [event] = await this.appendBatch([input]);
     return event;
   }
-  /**
-   * Append a batch as one transaction.
-   *
-   * The chain is computed in memory from a single anchor, so a partially
-   * applied batch would leave a hole in `sequence` that verification can never
-   * reconcile. Rollback plus anchor invalidation is what prevents that.
-   */
   async appendBatch(inputs) {
     if (inputs.length === 0) return [];
     const started = performance.now();
@@ -2720,7 +2894,7 @@ var ChronicleSqliteJournal = class {
     let retainedCountAfterCommit = this.retainedEventCount;
     try {
       this.db.exec("BEGIN IMMEDIATE");
-      this.assertWithinByteQuota(batchBytes);
+      this.quotaManager.assertWithinByteQuota(batchBytes);
       const { insert } = this.preparedStatements();
       for (const [index, event] of events.entries()) {
         const row = projectEvent(event);
@@ -2749,7 +2923,7 @@ var ChronicleSqliteJournal = class {
       retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(
         this.retainedEventCount + events.length
       );
-      this.assertActualAllocationWithinQuota();
+      this.quotaManager.assertActualAllocationWithinQuota();
       this.db.exec("COMMIT");
     } catch (error) {
       try {
@@ -2757,15 +2931,15 @@ var ChronicleSqliteJournal = class {
       } catch {
       }
       this.anchors.clear();
-      this.invalidateQuotaEstimate();
+      this.quotaManager.invalidateEstimate();
       this.counters.failedEvents += inputs.length;
       this.lastBatchDurationMs = performance.now() - started;
-      throw this.normalizeQuotaError(error);
+      throw this.quotaManager.normalizeQuotaError(error);
     }
     this.anchors.set(day, previous);
     this.counters.persistedEvents += events.length;
     this.retainedEventCount = retainedCountAfterCommit;
-    this.bytesSinceQuotaCheck += batchBytes;
+    this.quotaManager.recordAppendedBytes(batchBytes);
     this.lastBatchDurationMs = performance.now() - started;
     await this.enforceRetentionIfDue();
     return events;
@@ -2774,19 +2948,6 @@ var ChronicleSqliteJournal = class {
     const rows = this.db.prepare("SELECT payload FROM events ORDER BY day, sequence").all();
     return rows.map((row) => JSON.parse(row.payload));
   }
-  /**
-   * Walk every chain and prove none has been edited.
-   *
-   * Chronicle chains are scoped to a day, not to the journal: the JSONL writer
-   * anchors each `<day>.events.jsonl` family at `GENESIS_HASH` independently,
-   * so `sequence` restarts at 1 every day. Verification mirrors that — each day
-   * is validated on its own, and a break in one does not implicate the others.
-   *
-   * Three independent properties per day, because each catches a different
-   * failure: a dense `sequence` catches deletions from the middle, the
-   * `previousHash` link catches reordering, and re-hashing the payload catches
-   * an in-place edit that left the links intact.
-   */
   async verify() {
     let entries = 0;
     let lastSequence = 0;
@@ -2838,155 +2999,6 @@ var ChronicleSqliteJournal = class {
     } catch {
     }
   }
-  configureByteQuota() {
-    if (this.maxBytes === void 0) {
-      this.db.exec("PRAGMA max_page_count = 2147483646");
-      return;
-    }
-    const halfSplit = Math.floor((this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES) / 2);
-    const sidecarReserve = Math.min(MAX_WAL_RESERVE_BYTES, halfSplit);
-    const mainBudget = this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES - sidecarReserve;
-    if (mainBudget < MIN_SQLITE_PAGE_BUDGET_BYTES) {
-      throw new Error(
-        `maxBytes must be at least ${SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES}`
-      );
-    }
-    const maxPages = Math.max(1, Math.floor(mainBudget / this.pageSizeBytes()));
-    this.db.exec(`PRAGMA max_page_count = ${maxPages}`);
-  }
-  /**
-   * Bytes the journal actually occupies: live pages in the main database plus
-   * whatever the rollback/WAL sidecars currently hold.
-   *
-   * The quota MUST be measured this way rather than by `statSync` on the main
-   * database file. SQLite never returns freed pages to the filesystem — it
-   * parks them on the freelist and reuses them — so a database that once grew
-   * large keeps that size forever, even after retention and `maxEvents` have
-   * evicted almost everything. Measuring the file instead wedged the journal
-   * permanently: a 3.9 GB file whose live data was 243 MB failed a 512 MB
-   * quota on EVERY append, and the only escape (`chronicle compact`) refuses
-   * to run while the daemon is up — and the daemon respawns on demand. Live
-   * pages shrink when retention deletes rows, so the quota can recover on its
-   * own; allocated size cannot.
-   *
-   * The sidecars keep their on-disk size: they are transient and genuinely
-   * bounded by `configureByteQuota`'s half-of-budget split.
-   */
-  aggregateLiveBytes() {
-    let total = 0;
-    for (const file of [`${this.dbPath}-journal`, `${this.dbPath}-wal`, `${this.dbPath}-shm`]) {
-      try {
-        total += fs6.statSync(file).size;
-      } catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
-      }
-    }
-    return total + this.mainDatabaseLiveBytes();
-  }
-  /** Live (non-freelist) pages of the main database, in bytes. */
-  mainDatabaseLiveBytes() {
-    const pageCount = Number(
-      this.db.prepare("PRAGMA page_count").get().page_count
-    );
-    const freelist = Number(
-      this.db.prepare("PRAGMA freelist_count").get().freelist_count
-    );
-    return Math.max(0, pageCount - freelist) * this.pageSizeBytes();
-  }
-  /** Page size never changes for an open database; resolve it once. */
-  pageSizeBytes() {
-    if (this.cachedPageSize === void 0) {
-      this.cachedPageSize = Number(
-        this.db.prepare("PRAGMA page_size").get().page_size
-      );
-    }
-    return this.cachedPageSize;
-  }
-  normalizeQuotaError(error) {
-    if (this.maxBytes === void 0 || !(error instanceof Error)) return error;
-    const sqliteError = error;
-    const quotaExhausted = sqliteError.code === "SQLITE_FULL" || sqliteError.code === 13 || sqliteError.errcode === 13 || /database or disk is full/i.test(sqliteError.message);
-    if (!quotaExhausted) return error;
-    return new ChronicleStorageQuotaError({
-      currentBytes: this.aggregateLiveBytes(),
-      batchBytes: 0,
-      maxBytes: this.maxBytes,
-      path: this.dbPath
-    });
-  }
-  /** Drop the cached headroom so the next quota check measures for real. */
-  invalidateQuotaEstimate() {
-    this.quotaHeadroomBytes = 0;
-    this.bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
-  }
-  assertActualAllocationWithinQuota() {
-    if (this.maxBytes === void 0) return;
-    if (!this.shouldMeasureQuota()) return;
-    const currentBytes = this.aggregateLiveBytes();
-    this.recordQuotaHeadroom(currentBytes);
-    if (currentBytes <= this.maxBytes) return;
-    throw new ChronicleStorageQuotaError({
-      currentBytes,
-      batchBytes: 0,
-      maxBytes: this.maxBytes,
-      path: this.dbPath
-    });
-  }
-  /**
-   * Refuse a batch that would take the journal past its byte quota.
-   *
-   * This is the *courteous* bound, not the enforced one: `max_page_count` makes
-   * SQLite itself fail the write with `SQLITE_FULL`, which `normalizeQuotaError`
-   * turns into the same {@link ChronicleStorageQuotaError}. Its only job is to
-   * produce that error before a doomed batch has been written, so it does not
-   * have to run on every append — and it should not, because measuring costs two
-   * PRAGMA round trips and three `statSync` calls, twice per transaction.
-   *
-   * So it measures adaptively instead of on a fixed cadence: after a real
-   * measurement it knows the spare bytes, and it may skip until the bytes
-   * appended since then could plausibly have consumed half of them. Far from the
-   * ceiling that is thousands of appends; close to it, every one. The bound
-   * tightens exactly where being wrong would matter.
-   */
-  assertWithinByteQuota(batchBytes) {
-    if (this.maxBytes === void 0) return;
-    if (!this.shouldMeasureQuota(batchBytes)) return;
-    const currentBytes = this.aggregateLiveBytes();
-    this.recordQuotaHeadroom(currentBytes);
-    if (currentBytes + batchBytes <= this.maxBytes) return;
-    throw new ChronicleStorageQuotaError({
-      currentBytes,
-      batchBytes,
-      maxBytes: this.maxBytes,
-      path: this.dbPath
-    });
-  }
-  /**
-   * Is the cached headroom still large enough to vouch for this batch?
-   *
-   * Half the headroom is the budget deliberately: rows carry index and page
-   * overhead beyond their payload bytes, so `bytesSinceQuotaCheck` understates
-   * real growth, and the factor absorbs that without needing to model it.
-   */
-  shouldMeasureQuota(batchBytes = 0) {
-    return this.bytesSinceQuotaCheck + batchBytes >= this.quotaHeadroomBytes / 2;
-  }
-  recordQuotaHeadroom(currentBytes) {
-    this.quotaHeadroomBytes = Math.max(0, (this.maxBytes ?? 0) - currentBytes);
-    this.bytesSinceQuotaCheck = 0;
-  }
-  /**
-   * Evict the oldest events once the row ceiling has been overshot by `trimSlack`.
-   *
-   * @param count Rows now in the table. The caller tracks this rather than the
-   * method querying it: `SELECT COUNT(*)` walks the whole table, and at the
-   * ceiling — where every long-lived journal lives — that was a full scan of
-   * `maxEvents` rows on every append, to learn a number the append path already
-   * knew. The count is re-derived from the database whenever it could have
-   * drifted (open, import, purge), never accumulated blindly across those.
-   * @param slack Overshoot tolerated before evicting; callers that run once,
-   * rather than per append, pass 0 to land on the exact ceiling.
-   */
   enforceEventLimitWithinTransaction(count, slack = this.trimSlack) {
     if (this.maxEvents === void 0 || count <= this.maxEvents + slack) return count;
     const excess = count - this.maxEvents;
@@ -3016,15 +3028,6 @@ var ChronicleSqliteJournal = class {
       throw error;
     }
   }
-  /**
-   * Drop events older than the retention window.
-   *
-   * Retention is day-granular and chains are day-scoped, so a purge removes
-   * whole chains rather than truncating one. That is why nothing needs to be
-   * checkpointed here: there is no surviving suffix left dangling without an
-   * anchor. Any checkpoint imported from a partially-purged legacy day family
-   * is dropped alongside its events.
-   */
   async purge(options) {
     const empty = {
       deletedCount: 0,
@@ -3062,25 +3065,9 @@ var ChronicleSqliteJournal = class {
     }
     this.anchors.clear();
     this.retainedEventCount = this.countRows();
-    this.invalidateQuotaEstimate();
+    this.quotaManager.invalidateEstimate();
     return { ...empty, deletedCount: count };
   }
-  /**
-   * Run one day family's legacy import inside its own transaction.
-   *
-   * Deliberately separate from `appendBatch`: the append path *computes*
-   * `sequence`, `previousHash` and `hash`, while an import must carry them over
-   * untouched. Fusing the two would put a code path one refactor away from
-   * re-hashing historical events, which is the one change that silently
-   * destroys their tamper evidence.
-   *
-   * The transaction is scoped to a single family because chains are: `sequence`
-   * restarts at 1 each day, so one day's break says nothing about the next
-   * day's integrity. A whole-journal transaction made every future day hostage
-   * to the worst day on disk — one corrupt family and the daemon could never
-   * open its store again. The family is still all-or-nothing: a break rolls
-   * back that day entirely, so no partial chain is ever visible.
-   */
   async runFamilyImport(load) {
     const insert = this.db.prepare(
       `INSERT INTO events (
@@ -3096,8 +3083,8 @@ var ChronicleSqliteJournal = class {
     this.db.exec("BEGIN IMMEDIATE");
     let retainedCountAfterCommit = this.retainedEventCount;
     try {
-      this.invalidateQuotaEstimate();
-      this.assertWithinByteQuota(0);
+      this.quotaManager.invalidateEstimate();
+      this.quotaManager.assertWithinByteQuota(0);
       await load({
         insert: (day, event) => {
           const row = projectEvent(event);
@@ -3128,32 +3115,24 @@ var ChronicleSqliteJournal = class {
         }
       });
       retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(this.countRows(), 0);
-      this.invalidateQuotaEstimate();
-      this.assertActualAllocationWithinQuota();
+      this.quotaManager.invalidateEstimate();
+      this.quotaManager.assertActualAllocationWithinQuota();
       this.db.exec("COMMIT");
     } catch (error) {
       try {
         this.db.exec("ROLLBACK");
       } catch {
       }
-      this.invalidateQuotaEstimate();
-      throw this.normalizeQuotaError(error);
+      this.quotaManager.invalidateEstimate();
+      throw this.quotaManager.normalizeQuotaError(error);
     } finally {
       this.anchors.clear();
     }
     this.retainedEventCount = retainedCountAfterCommit;
   }
-  /**
-   * A read engine over this journal's own connection.
-   *
-   * Sharing the connection rather than opening a second one keeps the
-   * single-writer guarantee intact and means a reader can never observe a
-   * half-applied batch: SQLite serialises statements on one handle.
-   */
   queryEngine(options) {
     return new ChronicleSqliteQueryEngine(this.db, options);
   }
-  /** Has the legacy JSONL import already run? */
   hasImportedLegacyJournal() {
     return this.readMeta(LEGACY_JSONL_MIGRATION_KEY) !== void 0;
   }
@@ -3163,15 +3142,6 @@ var ChronicleSqliteJournal = class {
            ON CONFLICT(key) DO UPDATE SET value = 'done'`
     ).run(LEGACY_JSONL_MIGRATION_KEY);
   }
-  /**
-   * Record the day families the import refused to move.
-   *
-   * Persisted rather than merely logged because the import runs once: after the
-   * marker is set nothing re-reads the JSONL, so this row is the only surviving
-   * evidence that a day was dropped. Health reports read it back to say
-   * "degraded, and here is exactly what is missing" instead of quietly serving
-   * a journal with a hole in it.
-   */
   recordQuarantinedFamilies(families) {
     if (families.length === 0) return;
     this.db.prepare(
@@ -3179,20 +3149,31 @@ var ChronicleSqliteJournal = class {
            ON CONFLICT(key) DO UPDATE SET value = excluded.value`
     ).run(LEGACY_JSONL_QUARANTINE_KEY, JSON.stringify(families));
   }
-  /**
-   * Does this day already hold rows?
-   *
-   * Each family commits on its own, so an import interrupted between families
-   * leaves a database that is complete for the days it reached. `(day,
-   * sequence)` is the primary key, so re-inserting one of those days would
-   * abort on a constraint violation rather than start over — this is what lets
-   * the next run resume at the first day it never got to.
-   */
+  /** Record per-partition-file JSONL byte offsets at import time (merged — the
+   *  import persists per family, so a crash mid-run keeps earlier boundaries).
+   *  The metrics ingester folds only bytes beyond these boundaries after the
+   *  migration, so post-migration appends (the jsonl-store fallback) are
+   *  ingested while the migrated bytes are never re-counted. Files absent from
+   *  the map were quarantined (or created post-migration) — their events live
+   *  only in JSONL. */
+  recordLegacyJsonlBoundary(boundary) {
+    let merged = boundary;
+    try {
+      const row = this.db.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_BOUNDARY_KEY);
+      if (row?.value) {
+        merged = { ...JSON.parse(row.value), ...boundary };
+      }
+    } catch {
+    }
+    this.db.prepare(
+      `INSERT INTO chronicle_meta (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(LEGACY_JSONL_BOUNDARY_KEY, JSON.stringify(merged));
+  }
   hasImportedDay(day) {
     const row = this.db.prepare("SELECT 1 AS present FROM events WHERE day = ? LIMIT 1").get(day);
     return row !== void 0;
   }
-  /** Day families the legacy import refused to move, oldest first. */
   quarantinedFamilies() {
     const raw = this.readMeta(LEGACY_JSONL_QUARANTINE_KEY);
     if (!raw) return [];
@@ -3203,7 +3184,6 @@ var ChronicleSqliteJournal = class {
       return [];
     }
   }
-  // ─── internals ────────────────────────────────────────────────────────────
   preparedStatements() {
     this.statements ??= {
       insert: this.db.prepare(
@@ -3227,7 +3207,6 @@ var ChronicleSqliteJournal = class {
     };
     return this.statements;
   }
-  /** Rows currently in the table, straight from the database. */
   countRows() {
     return this.db.prepare("SELECT COUNT(*) AS count FROM events").get().count;
   }
@@ -3238,16 +3217,10 @@ var ChronicleSqliteJournal = class {
   readCheckpoint(day) {
     return this.db.prepare("SELECT sequence, hash FROM chain_checkpoint WHERE day = ?").get(day);
   }
-  /** Days that currently hold at least one event, oldest first. */
   days() {
     const rows = this.db.prepare("SELECT DISTINCT day FROM events ORDER BY day").all();
     return rows.map((row) => row.day);
   }
-  /**
-   * Resolve the chain head, in the same precedence the JSONL journal uses: the
-   * newest event, else the retention checkpoint (every event before it was
-   * purged), else genesis.
-   */
   readAnchor(day) {
     const cached = this.anchors.get(day);
     if (cached) return cached;
@@ -3256,75 +3229,10 @@ var ChronicleSqliteJournal = class {
     this.anchors.set(day, anchor);
     return anchor;
   }
-  ensureSchema() {
-    const version = this.db.prepare("PRAGMA user_version").get().user_version;
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS events (
-        day                TEXT NOT NULL,
-        sequence           INTEGER NOT NULL,
-        event_id           TEXT NOT NULL UNIQUE,
-        hash               TEXT NOT NULL,
-        previous_hash      TEXT NOT NULL,
-        occurred_at        TEXT NOT NULL,
-        event_type         TEXT NOT NULL,
-        outcome            TEXT,
-        project_id         TEXT,
-        session_id         TEXT,
-        agent_id           TEXT,
-        task_id            TEXT,
-        trace_id           TEXT,
-        logical_request_id TEXT,
-        resource_kind      TEXT,
-        resource_id        TEXT,
-        resource_path      TEXT,
-        duration_ns        TEXT,
-        payload            TEXT NOT NULL,
-        PRIMARY KEY (day, sequence)
-      );
-      CREATE INDEX IF NOT EXISTS events_occurred_at ON events(occurred_at);
-      CREATE INDEX IF NOT EXISTS events_type_outcome ON events(event_type, outcome);
-      CREATE INDEX IF NOT EXISTS events_session ON events(session_id, day, sequence);
-      CREATE INDEX IF NOT EXISTS events_trace ON events(trace_id);
-      CREATE INDEX IF NOT EXISTS events_logical_request ON events(logical_request_id);
-
-      CREATE TABLE IF NOT EXISTS chain_checkpoint (
-        day      TEXT PRIMARY KEY,
-        sequence INTEGER NOT NULL,
-        hash     TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS chronicle_meta (
-        key   TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-    if (version < 2) {
-      this.db.exec("DROP INDEX IF EXISTS events_resource_path");
-    }
-    if (version !== SCHEMA_VERSION) {
-      this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
-    }
-  }
 };
-function projectEvent(event) {
-  const occurredAt = event.occurredAt ?? event.observedAt;
-  return {
-    occurredAt,
-    outcome: event.outcome ?? null,
-    projectId: event.scope.projectId ?? null,
-    sessionId: event.scope.sessionId ?? null,
-    agentId: event.scope.agentId ?? null,
-    taskId: event.scope.taskId ?? null,
-    traceId: event.correlation?.traceId ?? null,
-    logicalRequestId: event.correlation?.logicalRequestId ?? null,
-    resourceKind: event.resource?.kind ?? null,
-    resourceId: event.resource?.id ?? null,
-    resourcePath: event.resource?.path ?? null,
-    durationNs: event.durationNs ?? null
-  };
-}
 
-// src/chronicle/metrics-store.ts
+// src/chronicle/metrics-schema.ts
+import { createRequire as createRequire2 } from "node:module";
 var SCHEMA_VERSION2 = 3;
 var READ_CHUNK_BYTES = 1024 * 1024;
 var SQLITE_SOURCE_PREFIX = "sqlite:";
@@ -3364,26 +3272,155 @@ function isChronicleMetricsAvailable() {
     return false;
   }
 }
-var ChronicleMetricsStore = class _ChronicleMetricsStore {
+function ensureMetricsSchema(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version !== 0 && version !== SCHEMA_VERSION2) {
+    db.exec(
+      "DROP TABLE IF EXISTS ingest_state; DROP TABLE IF EXISTS provider_daily;DROP TABLE IF EXISTS task_outcomes; DROP TABLE IF EXISTS file_lineage;DROP TABLE IF EXISTS token_cost; DROP TABLE IF EXISTS daily_counters;DROP TABLE IF EXISTS family_daily; DROP TABLE IF EXISTS agent_daily;DROP TABLE IF EXISTS logical_request_daily; DROP TABLE IF EXISTS file_seen_daily;"
+    );
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ingest_state (
+      file TEXT PRIMARY KEY,
+      bytes INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS provider_daily (
+      day TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      model_id TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      completed INTEGER NOT NULL DEFAULT 0,
+      failed INTEGER NOT NULL DEFAULT 0,
+      retries INTEGER NOT NULL DEFAULT 0,
+      fallbacks INTEGER NOT NULL DEFAULT 0,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      duration_ms_total REAL NOT NULL DEFAULT 0,
+      duration_ms_max REAL NOT NULL DEFAULT 0,
+      duration_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (day, provider_id, model_id)
+    );
+    CREATE TABLE IF NOT EXISTS task_outcomes (
+      task_id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL DEFAULT '',
+      board_id TEXT NOT NULL DEFAULT '',
+      session_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'started',
+      started_at TEXT,
+      ended_at TEXT,
+      duration_ms REAL,
+      retries INTEGER NOT NULL DEFAULT 0,
+      verification_failures INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS file_lineage (
+      event_id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      path_key TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      session_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      task_id TEXT NOT NULL DEFAULT '',
+      board_id TEXT NOT NULL DEFAULT '',
+      run_id TEXT NOT NULL DEFAULT '',
+      tool_name TEXT NOT NULL DEFAULT '',
+      provider_id TEXT NOT NULL DEFAULT '',
+      model_id TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL DEFAULT ''
+    );
+    CREATE INDEX IF NOT EXISTS idx_file_lineage_path ON file_lineage(path_key, occurred_at);
+    CREATE INDEX IF NOT EXISTS idx_file_lineage_task ON file_lineage(task_id);
+    CREATE TABLE IF NOT EXISTS token_cost (
+      scope_key TEXT PRIMARY KEY,
+      day TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      cost REAL NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS daily_counters (
+      day TEXT PRIMARY KEY,
+      tool_calls INTEGER NOT NULL DEFAULT 0,
+      completed_tools INTEGER NOT NULL DEFAULT 0,
+      failed_tools INTEGER NOT NULL DEFAULT 0,
+      tool_duration_ms_total REAL NOT NULL DEFAULT 0,
+      tool_duration_ms_max REAL NOT NULL DEFAULT 0,
+      tool_duration_count INTEGER NOT NULL DEFAULT 0,
+      processes INTEGER NOT NULL DEFAULT 0,
+      failed_processes INTEGER NOT NULL DEFAULT 0,
+      file_events_all INTEGER NOT NULL DEFAULT 0,
+      decisions INTEGER NOT NULL DEFAULT 0,
+      escalations INTEGER NOT NULL DEFAULT 0,
+      agent_events INTEGER NOT NULL DEFAULT 0,
+      failures INTEGER NOT NULL DEFAULT 0,
+      cancellations INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS family_daily (
+      day TEXT NOT NULL,
+      family TEXT NOT NULL,
+      count INTEGER NOT NULL DEFAULT 0,
+      failure_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (day, family)
+    );
+    CREATE TABLE IF NOT EXISTS agent_daily (day TEXT NOT NULL, agent_id TEXT NOT NULL, PRIMARY KEY (day, agent_id));
+    CREATE TABLE IF NOT EXISTS logical_request_daily (day TEXT NOT NULL, logical_request_id TEXT NOT NULL, PRIMARY KEY (day, logical_request_id));
+    CREATE TABLE IF NOT EXISTS file_seen_daily (day TEXT NOT NULL, path_key TEXT NOT NULL, PRIMARY KEY (day, path_key));
+    PRAGMA user_version = ${SCHEMA_VERSION2};
+  `);
+}
+function eventDay(event) {
+  return (event.occurredAt ?? event.observedAt).slice(0, 10);
+}
+function durationMs2(event) {
+  const value = Number(event.durationNs ?? 0) / 1e6;
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+function numberOrDuration(event, attributes) {
+  const explicit = attributes.durationMs;
+  if (typeof explicit === "number" && Number.isFinite(explicit)) return explicit;
+  return durationMs2(event);
+}
+function numberAt2(event, dotPath) {
+  const value = readPath2(event.attributes ?? {}, dotPath);
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function readPath2(value, key) {
+  return key.split(".").reduce(
+    (current, part) => current && typeof current === "object" ? current[part] : void 0,
+    value
+  );
+}
+function stringAt(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function clampLimit(limit, fallback) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return fallback;
+  return Math.min(Math.floor(limit), 1e4);
+}
+function normalizeKey(value) {
+  return value.replaceAll("\\", "/");
+}
+function normalizePathKey(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "").toLowerCase();
+}
+
+// src/chronicle/metrics-ingest.ts
+var REBUILD_MARKER_KEY = `${SQLITE_SOURCE_PREFIX}rebuild_done`;
+var ChronicleMetricsIngester = class {
+  constructor(db, directory, dbPath) {
+    this.db = db;
+    this.directory = directory;
+    this.dbPath = dbPath;
+  }
   db;
   directory;
   dbPath;
-  constructor(directory) {
-    this.directory = path10.resolve(directory);
-    this.dbPath = path10.join(this.directory, "metrics.db");
-    const Database = loadDatabaseSync2();
-    this.db = new Database(this.dbPath);
-    this.db.exec("PRAGMA journal_mode = WAL");
-    this.ensureSchema();
-  }
-  static open(chronicleDirectory) {
-    return new _ChronicleMetricsStore(chronicleDirectory);
-  }
-  close() {
-    this.db.close();
-  }
-  /** Incrementally ingest journal bytes appended since the last refresh.
-   *  Safe across processes: guarded by a file lock on the database path. */
   async refresh() {
     const result = {
       ingestedEvents: 0,
@@ -3394,377 +3431,106 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
     await withFileLock(this.dbPath, async () => {
       const files = await findChroniclePartitions(this.directory);
       const offsets = this.loadOffsets();
-      for (const file of files) {
-        const key = normalizeKey(path10.relative(this.directory, file));
-        const consumed = offsets.get(key) ?? 0;
-        const ingested = await this.ingestFile(file, key, consumed, result);
-        if (ingested) result.sourceFiles++;
+      const journalPath = path10.join(this.directory, CHRONICLE_SQLITE_FILE);
+      let source = null;
+      try {
+        source = new (loadDatabaseSync2())(journalPath, { readOnly: true });
+      } catch {
       }
-      this.pruneOffsets(files);
-      this.ingestSqliteJournal(offsets, result);
-    });
-    return result;
-  }
-  providerDaily(options = {}) {
-    const clauses = [];
-    const params = [];
-    if (options.from) {
-      clauses.push("day >= ?");
-      params.push(options.from.slice(0, 10));
-    }
-    if (options.to) {
-      clauses.push("day <= ?");
-      params.push(options.to.slice(0, 10));
-    }
-    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
-    const rows = this.db.prepare(
-      `SELECT day, provider_id, model_id, attempts, completed, failed, retries, fallbacks,
-        input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-        duration_ms_total, duration_ms_max, duration_count
-       FROM provider_daily${where} ORDER BY day DESC, provider_id, model_id`
-    ).all(...params);
-    return rows.map((row) => ({
-      day: String(row.day),
-      providerId: String(row.provider_id),
-      modelId: String(row.model_id),
-      attempts: Number(row.attempts),
-      completed: Number(row.completed),
-      failed: Number(row.failed),
-      retries: Number(row.retries),
-      fallbacks: Number(row.fallbacks),
-      inputTokens: Number(row.input_tokens),
-      outputTokens: Number(row.output_tokens),
-      cacheReadTokens: Number(row.cache_read_tokens),
-      cacheWriteTokens: Number(row.cache_write_tokens),
-      avgDurationMs: Number(row.duration_count) > 0 ? Number(row.duration_ms_total) / Number(row.duration_count) : 0,
-      maxDurationMs: Number(row.duration_ms_max)
-    }));
+      try {
+        const migrated = source !== null && this.legacyJsonlConsumed(source);
+        const boundary = migrated && source !== null ? this.loadJsonlBoundary(source) : null;
+        const rebuilt = migrated && this.needsSqliteRebuild(offsets);
+        if (rebuilt && source !== null) {
+          this.rebuildFromSqliteJournal(source, result);
+        }
+        if (!migrated || boundary !== null) {
+          for (const file of files) {
+            const key = normalizeKey(path10.relative(this.directory, file));
+            let base;
+            if (!migrated) {
+              base = offsets.get(key) ?? 0;
+            } else if (boundary !== null && boundary.has(key)) {
+              base = Math.max(offsets.get(key) ?? 0, boundary.get(key));
+            } else {
+              base = rebuilt ? 0 : offsets.get(key) ?? 0;
+            }
+            const ingested = await this.ingestFile(file, key, base, result);
+            if (ingested) result.sourceFiles++;
+          }
+        }
+        this.pruneOffsets(files);
+        if (source !== null && !rebuilt) {
+          this.ingestSqliteJournal(source, offsets, result, false);
+          if (migrated) this.ensureRebuildMarker();
+        }
+      } finally {
+        if (source !== null) source.close();
+      }
+    });
+    return result;
   }
-  taskOutcomes(options = {}) {
-    const clauses = [];
-    const params = [];
-    if (options.runId) {
-      clauses.push("t.run_id = ?");
-      params.push(options.runId);
-    }
-    if (options.boardId) {
-      clauses.push("t.board_id = ?");
-      params.push(options.boardId);
-    }
-    if (options.sessionId) {
-      clauses.push("t.session_id = ?");
-      params.push(options.sessionId);
-    }
-    if (options.status) {
-      clauses.push("t.status = ?");
-      params.push(options.status);
-    }
-    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
-    params.push(clampLimit(options.limit, 100));
-    const rows = this.db.prepare(
-      `SELECT t.*, (SELECT COUNT(*) FROM file_lineage f WHERE f.task_id = t.task_id) AS files_touched
-       FROM task_outcomes t${where}
-       ORDER BY COALESCE(t.started_at, '') DESC LIMIT ?`
-    ).all(...params);
-    return rows.map((row) => ({
-      taskId: String(row.task_id),
-      runId: String(row.run_id),
-      boardId: String(row.board_id),
-      sessionId: String(row.session_id),
-      agentId: String(row.agent_id),
-      status: String(row.status),
-      startedAt: row.started_at === null ? null : String(row.started_at),
-      endedAt: row.ended_at === null ? null : String(row.ended_at),
-      durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
-      retries: Number(row.retries),
-      verificationFailures: Number(row.verification_failures),
-      filesTouched: Number(row.files_touched)
-    }));
+  loadOffsets() {
+    const rows = this.db.prepare("SELECT file, bytes FROM ingest_state").all();
+    return new Map(rows.map((row) => [row.file, Number(row.bytes)]));
   }
-  fileLineage(options = {}) {
-    const clauses = [];
-    const params = [];
-    if (options.path) {
-      clauses.push("path_key = ?");
-      params.push(normalizePathKey(options.path));
-    }
-    if (options.paths) {
-      const pathKeys = [...new Set(options.paths.map(normalizePathKey))];
-      if (pathKeys.length === 0) return [];
-      clauses.push(`path_key IN (${pathKeys.map(() => "?").join(",")})`);
-      params.push(...pathKeys);
-    }
-    if (options.taskId) {
-      clauses.push("task_id = ?");
-      params.push(options.taskId);
-    }
-    if (options.boardId) {
-      clauses.push("board_id = ?");
-      params.push(options.boardId);
-    }
-    if (options.sessionId) {
-      clauses.push("session_id = ?");
-      params.push(options.sessionId);
+  /** True once the legacy JSONL journal was imported into the SQLite journal
+   *  (`importLegacyChronicleJournal` records the marker in `chronicle_meta`).
+   *  After that point the SQLite `events` table already holds every JSONL
+   *  event, so folding the leftover partition files again would double-count
+   *  every migrated event in the aggregates. `source` is the already-opened
+   *  read-only journal handle (null when no SQLite journal exists yet). */
+  legacyJsonlConsumed(source) {
+    if (source === null) return false;
+    try {
+      const row = source.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_MIGRATION_KEY);
+      return row?.value !== void 0;
+    } catch {
+      return false;
     }
-    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`;
-    const sql = options.latestPerPath ? `SELECT ${projection} FROM (
-           SELECT ${projection}, ROW_NUMBER() OVER (
-             PARTITION BY path_key ORDER BY occurred_at DESC, event_id DESC
-           ) AS path_rank
-           FROM file_lineage${where}
-         ) WHERE path_rank = 1 ORDER BY occurred_at DESC LIMIT ?` : `SELECT ${projection}
-         FROM file_lineage${where} ORDER BY occurred_at DESC LIMIT ?`;
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => ({
-      path: row.path,
-      operation: row.operation,
-      occurredAt: row.occurred_at,
-      sessionId: row.session_id,
-      agentId: row.agent_id,
-      taskId: row.task_id,
-      boardId: row.board_id,
-      runId: row.run_id,
-      toolName: row.tool_name,
-      providerId: row.provider_id,
-      modelId: row.model_id,
-      source: row.source
-    }));
   }
-  summary() {
-    const provider = this.db.prepare(
-      "SELECT COALESCE(SUM(attempts),0) a, COALESCE(SUM(completed),0) c, COALESCE(SUM(failed),0) f FROM provider_daily"
-    ).get();
-    const tasks = {};
-    for (const row of this.db.prepare("SELECT status, COUNT(*) n FROM task_outcomes GROUP BY status").all()) {
-      tasks[row.status] = Number(row.n);
+  /** Per-partition-file JSONL byte offsets recorded by
+   *  `importLegacyChronicleJournal` at import time (keyed by the same relative
+   *  path the fold uses). Files absent from the map were quarantined (or
+   *  created after the migration) — their events live only in JSONL. */
+  loadJsonlBoundary(source) {
+    try {
+      const row = source.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_BOUNDARY_KEY);
+      if (!row?.value) return null;
+      const parsed = JSON.parse(row.value);
+      return new Map(Object.entries(parsed));
+    } catch {
+      return null;
     }
-    const files = this.db.prepare("SELECT COUNT(*) n, COUNT(DISTINCT path) p FROM file_lineage").get();
-    const cost = this.db.prepare("SELECT COALESCE(SUM(cost),0) c FROM token_cost").get();
-    const terminal = Number(provider.c) + Number(provider.f);
-    return {
-      providers: {
-        attempts: Number(provider.a),
-        completed: Number(provider.c),
-        failed: Number(provider.f),
-        successRate: terminal > 0 ? Number(provider.c) / terminal : 0
-      },
-      tasks,
-      files: { mutations: Number(files.n), uniquePaths: Number(files.p) },
-      estimatedCostUsd: Number(cost.c)
-    };
   }
-  /**
-   * A `ChronicleSummary` for the default/unfiltered dashboard view — only
-   * `from`/`to` (day-precision) narrow it. Any other ad hoc filter (text,
-   * path, provider, model, session) can't be answered from these
-   * fixed-dimension aggregates; callers must fall back to query.ts's
-   * raw-scan summary for those.
-   */
-  defaultSummary(options = {}) {
-    const fromDay = options.from?.slice(0, 10);
-    const toDay = options.to?.slice(0, 10);
-    const dayFilter = (column) => {
-      const clauses = [];
-      const params = [];
-      if (fromDay) {
-        clauses.push(`${column} >= ?`);
-        params.push(fromDay);
-      }
-      if (toDay) {
-        clauses.push(`${column} <= ?`);
-        params.push(toDay);
-      }
-      return { where: clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "", params };
-    };
-    const providerRange = dayFilter("day");
-    const provider = this.db.prepare(
-      `SELECT COALESCE(SUM(attempts),0) attempts, COALESCE(SUM(completed),0) completed, COALESCE(SUM(failed),0) failed,
-        COALESCE(SUM(retries),0) retries, COALESCE(SUM(fallbacks),0) fallbacks,
-        COUNT(DISTINCT provider_id) providers, COUNT(DISTINCT model_id) models,
-        COALESCE(SUM(input_tokens),0) inputTokens, COALESCE(SUM(output_tokens),0) outputTokens,
-        COALESCE(SUM(cache_read_tokens),0) cacheReadTokens, COALESCE(SUM(cache_write_tokens),0) cacheWriteTokens,
-        COALESCE(SUM(duration_ms_total),0) durationTotal, COALESCE(MAX(duration_ms_max),0) durationMax,
-        COALESCE(SUM(duration_count),0) durationCount
-       FROM provider_daily${providerRange.where}`
-    ).get(...providerRange.params);
-    const counterRange = dayFilter("day");
-    const counters = this.db.prepare(
-      `SELECT COALESCE(SUM(tool_calls),0) toolCalls, COALESCE(SUM(completed_tools),0) completedTools,
-        COALESCE(SUM(failed_tools),0) failedTools, COALESCE(SUM(tool_duration_ms_total),0) toolDurationTotal,
-        COALESCE(SUM(tool_duration_count),0) toolDurationCount, COALESCE(SUM(processes),0) processes,
-        COALESCE(SUM(failed_processes),0) failedProcesses, COALESCE(SUM(file_events_all),0) fileEvents,
-        COALESCE(SUM(decisions),0) decisions, COALESCE(SUM(escalations),0) escalations,
-        COALESCE(SUM(agent_events),0) agentEvents, COALESCE(SUM(failures),0) failures,
-        COALESCE(SUM(cancellations),0) cancellations
-       FROM daily_counters${counterRange.where}`
-    ).get(...counterRange.params);
-    const familyRange = dayFilter("day");
-    const familyRows = this.db.prepare(`SELECT family, count, failure_count FROM family_daily${familyRange.where}`).all(...familyRange.params);
-    const families = { ...EMPTY_FAMILIES };
-    const failuresByFamily = { ...EMPTY_FAMILIES };
-    for (const row of familyRows) {
-      const family = row.family;
-      families[family] = Number(row.count);
-      failuresByFamily[family] = Number(row.failure_count);
-    }
-    const agentRange = dayFilter("day");
-    const uniqueAgents = this.db.prepare(`SELECT COUNT(DISTINCT agent_id) n FROM agent_daily${agentRange.where}`).get(...agentRange.params).n;
-    const requestRange = dayFilter("day");
-    const logicalRequests = this.db.prepare(
-      `SELECT COUNT(DISTINCT logical_request_id) n FROM logical_request_daily${requestRange.where}`
-    ).get(...requestRange.params).n;
-    const fileRange = dayFilter("day");
-    const uniqueFiles = this.db.prepare(`SELECT COUNT(DISTINCT path_key) n FROM file_seen_daily${fileRange.where}`).get(...fileRange.params).n;
-    const costRange = dayFilter("day");
-    const cost = this.db.prepare(`SELECT COALESCE(SUM(cost),0) c FROM token_cost${costRange.where}`).get(...costRange.params).c;
-    return {
-      logicalRequests: Number(logicalRequests),
-      modelAttempts: Number(provider.attempts),
-      completedAttempts: Number(provider.completed),
-      failedAttempts: Number(provider.failed),
-      scheduledRetries: Number(provider.retries),
-      fallbacks: Number(provider.fallbacks),
-      providers: Number(provider.providers),
-      models: Number(provider.models),
-      inputTokens: Number(provider.inputTokens),
-      outputTokens: Number(provider.outputTokens),
-      cacheReadTokens: Number(provider.cacheReadTokens),
-      cacheWriteTokens: Number(provider.cacheWriteTokens),
-      estimatedCostUsd: Number(cost),
-      providerAvgDurationMs: Number(provider.durationCount) > 0 ? Number(provider.durationTotal) / Number(provider.durationCount) : 0,
-      // True p95 needs a retained distribution; this per-day aggregate only
-      // keeps sum/max/count, so approximate with the observed max rather
-      // than adding a per-attempt histogram write (would add the same kind
-      // of per-event overhead this whole effort is trying to remove).
-      providerP95DurationMs: Number(provider.durationMax),
-      toolCalls: Number(counters.toolCalls),
-      completedTools: Number(counters.completedTools),
-      failedTools: Number(counters.failedTools),
-      toolAvgDurationMs: Number(counters.toolDurationCount) > 0 ? Number(counters.toolDurationTotal) / Number(counters.toolDurationCount) : 0,
-      processes: Number(counters.processes),
-      failedProcesses: Number(counters.failedProcesses),
-      fileEvents: Number(counters.fileEvents),
-      uniqueFiles: Number(uniqueFiles),
-      agentEvents: Number(counters.agentEvents),
-      uniqueAgents: Number(uniqueAgents),
-      decisions: Number(counters.decisions),
-      escalations: Number(counters.escalations),
-      failures: Number(counters.failures),
-      cancellations: Number(counters.cancellations),
-      families,
-      failuresByFamily
-    };
-  }
-  // ─── Ingest internals ─────────────────────────────────────────────────────
-  ensureSchema() {
-    const version = this.db.prepare("PRAGMA user_version").get().user_version;
-    if (version !== 0 && version !== SCHEMA_VERSION2) {
-      this.db.exec(
-        "DROP TABLE IF EXISTS ingest_state; DROP TABLE IF EXISTS provider_daily;DROP TABLE IF EXISTS task_outcomes; DROP TABLE IF EXISTS file_lineage;DROP TABLE IF EXISTS token_cost; DROP TABLE IF EXISTS daily_counters;DROP TABLE IF EXISTS family_daily; DROP TABLE IF EXISTS agent_daily;DROP TABLE IF EXISTS logical_request_daily; DROP TABLE IF EXISTS file_seen_daily;"
-      );
+  /** Persist the rebuild sentinel idempotently. Its presence makes
+   *  `needsSqliteRebuild` return false, so post-migration jsonl-store offsets
+   *  are never mistaken for pre-migration progress. */
+  ensureRebuildMarker() {
+    this.db.prepare(
+      "INSERT INTO ingest_state (file, bytes) VALUES (?, ?) ON CONFLICT(file) DO UPDATE SET bytes = excluded.bytes"
+    ).run(REBUILD_MARKER_KEY, 1);
+  }
+  /** Upgrade path: `metrics.db` already aggregated the legacy JSONL, then the
+   *  one-shot import copied those same events into the SQLite journal. There
+   *  is no `sqlite:` cursor yet, so a plain incremental fold would replay the
+   *  entire migrated history on top of the existing aggregates. The metrics
+   *  projection is disposable (fully derived from the journal), so rebuild it
+   *  from the SQLite source exactly once — the rebuild writes the cursors and
+   *  subsequent refreshes go back to incremental folding. */
+  needsSqliteRebuild(offsets) {
+    if (offsets.has(REBUILD_MARKER_KEY)) return false;
+    for (const [key, bytes] of offsets) {
+      if (!key.startsWith(SQLITE_SOURCE_PREFIX) && bytes > 0) return true;
     }
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS ingest_state (
-        file TEXT PRIMARY KEY,
-        bytes INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS provider_daily (
-        day TEXT NOT NULL,
-        provider_id TEXT NOT NULL,
-        model_id TEXT NOT NULL,
-        attempts INTEGER NOT NULL DEFAULT 0,
-        completed INTEGER NOT NULL DEFAULT 0,
-        failed INTEGER NOT NULL DEFAULT 0,
-        retries INTEGER NOT NULL DEFAULT 0,
-        fallbacks INTEGER NOT NULL DEFAULT 0,
-        input_tokens INTEGER NOT NULL DEFAULT 0,
-        output_tokens INTEGER NOT NULL DEFAULT 0,
-        cache_read_tokens INTEGER NOT NULL DEFAULT 0,
-        cache_write_tokens INTEGER NOT NULL DEFAULT 0,
-        duration_ms_total REAL NOT NULL DEFAULT 0,
-        duration_ms_max REAL NOT NULL DEFAULT 0,
-        duration_count INTEGER NOT NULL DEFAULT 0,
-        PRIMARY KEY (day, provider_id, model_id)
-      );
-      CREATE TABLE IF NOT EXISTS task_outcomes (
-        task_id TEXT PRIMARY KEY,
-        run_id TEXT NOT NULL DEFAULT '',
-        board_id TEXT NOT NULL DEFAULT '',
-        session_id TEXT NOT NULL DEFAULT '',
-        agent_id TEXT NOT NULL DEFAULT '',
-        status TEXT NOT NULL DEFAULT 'started',
-        started_at TEXT,
-        ended_at TEXT,
-        duration_ms REAL,
-        retries INTEGER NOT NULL DEFAULT 0,
-        verification_failures INTEGER NOT NULL DEFAULT 0
-      );
-      CREATE TABLE IF NOT EXISTS file_lineage (
-        event_id TEXT PRIMARY KEY,
-        path TEXT NOT NULL,
-        path_key TEXT NOT NULL,
-        operation TEXT NOT NULL,
-        occurred_at TEXT NOT NULL,
-        session_id TEXT NOT NULL DEFAULT '',
-        agent_id TEXT NOT NULL DEFAULT '',
-        task_id TEXT NOT NULL DEFAULT '',
-        board_id TEXT NOT NULL DEFAULT '',
-        run_id TEXT NOT NULL DEFAULT '',
-        tool_name TEXT NOT NULL DEFAULT '',
-        provider_id TEXT NOT NULL DEFAULT '',
-        model_id TEXT NOT NULL DEFAULT '',
-        source TEXT NOT NULL DEFAULT ''
-      );
-      -- Lookups filter on the case-normalized path_key (matching the query
-      -- engine); the path column retains original casing for display.
-      CREATE INDEX IF NOT EXISTS idx_file_lineage_path ON file_lineage(path_key, occurred_at);
-      CREATE INDEX IF NOT EXISTS idx_file_lineage_task ON file_lineage(task_id);
-      CREATE TABLE IF NOT EXISTS token_cost (
-        scope_key TEXT PRIMARY KEY,
-        day TEXT NOT NULL,
-        occurred_at TEXT NOT NULL,
-        sequence INTEGER NOT NULL,
-        cost REAL NOT NULL
-      );
-      -- Backing store for defaultSummary(): per-day scalar counters plus
-      -- dedup sets, populated for every ingested event (not just the
-      -- provider/task/file families above).
-      CREATE TABLE IF NOT EXISTS daily_counters (
-        day TEXT PRIMARY KEY,
-        tool_calls INTEGER NOT NULL DEFAULT 0,
-        completed_tools INTEGER NOT NULL DEFAULT 0,
-        failed_tools INTEGER NOT NULL DEFAULT 0,
-        tool_duration_ms_total REAL NOT NULL DEFAULT 0,
-        tool_duration_ms_max REAL NOT NULL DEFAULT 0,
-        tool_duration_count INTEGER NOT NULL DEFAULT 0,
-        processes INTEGER NOT NULL DEFAULT 0,
-        failed_processes INTEGER NOT NULL DEFAULT 0,
-        file_events_all INTEGER NOT NULL DEFAULT 0,
-        decisions INTEGER NOT NULL DEFAULT 0,
-        escalations INTEGER NOT NULL DEFAULT 0,
-        agent_events INTEGER NOT NULL DEFAULT 0,
-        failures INTEGER NOT NULL DEFAULT 0,
-        cancellations INTEGER NOT NULL DEFAULT 0
-      );
-      CREATE TABLE IF NOT EXISTS family_daily (
-        day TEXT NOT NULL,
-        family TEXT NOT NULL,
-        count INTEGER NOT NULL DEFAULT 0,
-        failure_count INTEGER NOT NULL DEFAULT 0,
-        PRIMARY KEY (day, family)
-      );
-      CREATE TABLE IF NOT EXISTS agent_daily (day TEXT NOT NULL, agent_id TEXT NOT NULL, PRIMARY KEY (day, agent_id));
-      CREATE TABLE IF NOT EXISTS logical_request_daily (day TEXT NOT NULL, logical_request_id TEXT NOT NULL, PRIMARY KEY (day, logical_request_id));
-      CREATE TABLE IF NOT EXISTS file_seen_daily (day TEXT NOT NULL, path_key TEXT NOT NULL, PRIMARY KEY (day, path_key));
-      PRAGMA user_version = ${SCHEMA_VERSION2};
-    `);
+    return false;
   }
-  loadOffsets() {
-    const rows = this.db.prepare("SELECT file, bytes FROM ingest_state").all();
-    return new Map(rows.map((row) => [row.file, Number(row.bytes)]));
+  rebuildFromSqliteJournal(source, result) {
+    this.db.exec(
+      "DELETE FROM ingest_state; DELETE FROM provider_daily; DELETE FROM task_outcomes; DELETE FROM file_lineage; DELETE FROM token_cost; DELETE FROM daily_counters; DELETE FROM family_daily; DELETE FROM agent_daily; DELETE FROM logical_request_daily; DELETE FROM file_seen_daily;"
+    );
+    this.ingestSqliteJournal(source, /* @__PURE__ */ new Map(), result, true);
+    this.ensureRebuildMarker();
   }
   pruneOffsets(existingFiles) {
     const keep = new Set(
@@ -3776,27 +3542,7 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
         this.db.prepare("DELETE FROM ingest_state WHERE file = ?").run(row.file);
     }
   }
-  /**
-   * Fold everything the SQLite journal holds past this store's per-day cursor.
-   *
-   * Opened read-only on its own connection: the journal runs in WAL, so this
-   * never blocks the daemon writing to it, and metrics are best-effort — a
-   * journal that cannot be opened (mid-migration, absent, locked) leaves the
-   * cursors untouched and the next refresh retries.
-   *
-   * Rows the journal has already evicted are simply not seen. That is the
-   * intended split of responsibilities: the journal is a bounded ring, and this
-   * store is where an aggregate outlives the raw event it came from — which
-   * only holds if refresh runs more often than the ring turns over.
-   */
-  ingestSqliteJournal(offsets, result) {
-    const journalPath = path10.join(this.directory, CHRONICLE_SQLITE_FILE);
-    let source;
-    try {
-      source = new (loadDatabaseSync2())(journalPath, { readOnly: true });
-    } catch {
-      return;
-    }
+  ingestSqliteJournal(source, offsets, result, propagateErrors) {
     try {
       const days = source.prepare("SELECT DISTINCT day FROM events ORDER BY day").all();
       const read = source.prepare(
@@ -3816,8 +3562,7 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
             if (rows.length === 0) break;
             for (const row of rows) {
               try {
-                this.ingestEvent(JSON.parse(row.payload));
-                result.ingestedEvents++;
+                this.ingestEventAtomically(JSON.parse(row.payload), result);
               } catch {
                 result.invalidLines++;
               }
@@ -3834,14 +3579,10 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
         }
         if (cursor > from) result.sourceFiles++;
       }
-    } catch {
-    } finally {
-      source.close();
+    } catch (error) {
+      if (propagateErrors) throw error;
     }
   }
-  /** Read complete lines appended after `consumed` bytes. The trailing
-   *  partial line of an actively-written partition is left for the next
-   *  refresh — `ingest_state.bytes` only ever advances past full lines. */
   async ingestFile(file, key, consumed, result) {
     let handle;
     try {
@@ -3873,8 +3614,7 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
             const trimmed = line.trim();
             if (!trimmed) continue;
             try {
-              this.ingestEvent(JSON.parse(trimmed));
-              result.ingestedEvents++;
+              this.ingestEventAtomically(JSON.parse(trimmed), result);
             } catch {
               result.invalidLines++;
             }
@@ -3896,6 +3636,27 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
       await handle.close();
     }
   }
+  /** Fold one event into the aggregates atomically. `ingestEvent` runs several
+   *  statements; when one throws mid-way (e.g. a malformed resource path), the
+   *  statements before it already mutated the aggregates. The savepoint rolls
+   *  those partial updates back: `ROLLBACK TO` rewinds, `RELEASE` (reached
+   *  before the re-throw) pops the savepoint so the next event in the batch
+   *  starts from a clean stack, and the batch commits only fully-succeeded
+   *  events. Dropping the `RELEASE` would leak the savepoint into the next
+   *  event's stack — the outer transaction ROLLBACK is never reached because
+   *  the per-event catch swallows the error and continues the batch. */
+  ingestEventAtomically(event, result) {
+    this.db.exec("SAVEPOINT ingest_event");
+    try {
+      this.ingestEvent(event);
+      this.db.exec("RELEASE ingest_event");
+      result.ingestedEvents++;
+    } catch (error) {
+      this.db.exec("ROLLBACK TO ingest_event");
+      this.db.exec("RELEASE ingest_event");
+      throw error;
+    }
+  }
   ingestEvent(event) {
     if (typeof event?.eventType !== "string" || !event.scope) return;
     this.ingestDailyCounters(event);
@@ -3910,9 +3671,6 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
       this.ingestFileEvent(event);
     }
   }
-  /** Runs for every ingested event (not just the type-specific branches
-   *  below) — mirrors query.ts's updateSummary() closely enough that
-   *  defaultSummary() matches what a raw scan of the same window would say. */
   ingestDailyCounters(event) {
     const day = eventDay(event);
     this.db.prepare("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
@@ -4031,109 +3789,344 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
     for (const [column, value] of lineage) {
       if (value) set(`${column} = ?`, value);
     }
-    const base = event.eventType.replace(/^(?:sdd|subagent|kanban)\.task[._]/, "");
-    switch (base) {
-      case "started":
-        set("status = 'started', started_at = COALESCE(started_at, ?)", occurredAt);
-        break;
-      case "completed":
-        set(
-          "status = 'completed', ended_at = ?, duration_ms = ?",
-          occurredAt,
-          numberOrDuration(event, attributes)
-        );
-        break;
-      case "failed":
-        set("status = 'failed', ended_at = ?", occurredAt);
-        break;
-      case "retrying":
-        set("retries = retries + 1");
-        break;
-      case "verification_failed":
-        set("verification_failures = verification_failures + 1");
-        break;
-      case "merged":
-        set("status = 'merged'");
-        break;
-      case "conflict":
-        set("status = 'conflict'");
-        break;
-      default:
-        break;
+    const base = event.eventType.replace(/^(?:sdd|subagent|kanban)\.task[._]/, "");
+    switch (base) {
+      case "started":
+        set("status = 'started', started_at = COALESCE(started_at, ?)", occurredAt);
+        break;
+      case "completed":
+        set(
+          "status = 'completed', ended_at = ?, duration_ms = ?",
+          occurredAt,
+          numberOrDuration(event, attributes)
+        );
+        break;
+      case "failed":
+        set("status = 'failed', ended_at = ?", occurredAt);
+        break;
+      case "retrying":
+        set("retries = retries + 1");
+        break;
+      case "verification_failed":
+        set("verification_failures = verification_failures + 1");
+        break;
+      case "merged":
+        set("status = 'merged'");
+        break;
+      case "conflict":
+        set("status = 'conflict'");
+        break;
+      default:
+        break;
+    }
+  }
+  ingestFileEvent(event) {
+    const attributes = event.attributes ?? {};
+    const operation = stringAt(attributes, "operation") ?? "";
+    if (!operation || operation === "read") return;
+    const filePath = event.resource?.path ?? stringAt(attributes, "filePath");
+    if (!filePath) return;
+    this.db.prepare(
+      `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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      event.eventId,
+      normalizeKey(filePath),
+      normalizePathKey(filePath),
+      operation,
+      event.occurredAt ?? event.observedAt,
+      event.scope.sessionId ?? "",
+      event.scope.agentId ?? "",
+      event.scope.taskId ?? stringAt(attributes, "taskId") ?? "",
+      event.scope.kanbanBoardId ?? stringAt(attributes, "boardId") ?? "",
+      stringAt(attributes, "runId") ?? "",
+      stringAt(attributes, "toolName") ?? "",
+      event.runtime?.providerId ?? stringAt(attributes, "provider") ?? "",
+      event.runtime?.modelId ?? stringAt(attributes, "model") ?? "",
+      stringAt(attributes, "source") ?? (event.eventType === "file.event" ? "tool" : "external")
+    );
+  }
+};
+
+// src/chronicle/metrics-store.ts
+var ChronicleMetricsStore = class _ChronicleMetricsStore {
+  db;
+  directory;
+  dbPath;
+  ingester;
+  constructor(directory) {
+    this.directory = path11.resolve(directory);
+    this.dbPath = path11.join(this.directory, "metrics.db");
+    const Database = loadDatabaseSync2();
+    this.db = new Database(this.dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    ensureMetricsSchema(this.db);
+    this.ingester = new ChronicleMetricsIngester(this.db, this.directory, this.dbPath);
+  }
+  static open(chronicleDirectory) {
+    return new _ChronicleMetricsStore(chronicleDirectory);
+  }
+  close() {
+    this.db.close();
+  }
+  /** Incrementally ingest journal bytes appended since the last refresh.
+   *  Safe across processes: guarded by a file lock on the database path. */
+  async refresh() {
+    return this.ingester.refresh();
+  }
+  providerDaily(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.from) {
+      clauses.push("day >= ?");
+      params.push(options.from.slice(0, 10));
+    }
+    if (options.to) {
+      clauses.push("day <= ?");
+      params.push(options.to.slice(0, 10));
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(
+      `SELECT day, provider_id, model_id, attempts, completed, failed, retries, fallbacks,
+        input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+        duration_ms_total, duration_ms_max, duration_count
+       FROM provider_daily${where} ORDER BY day DESC, provider_id, model_id`
+    ).all(...params);
+    return rows.map((row) => ({
+      day: String(row.day),
+      providerId: String(row.provider_id),
+      modelId: String(row.model_id),
+      attempts: Number(row.attempts),
+      completed: Number(row.completed),
+      failed: Number(row.failed),
+      retries: Number(row.retries),
+      fallbacks: Number(row.fallbacks),
+      inputTokens: Number(row.input_tokens),
+      outputTokens: Number(row.output_tokens),
+      cacheReadTokens: Number(row.cache_read_tokens),
+      cacheWriteTokens: Number(row.cache_write_tokens),
+      avgDurationMs: Number(row.duration_count) > 0 ? Number(row.duration_ms_total) / Number(row.duration_count) : 0,
+      maxDurationMs: Number(row.duration_ms_max)
+    }));
+  }
+  taskOutcomes(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.runId) {
+      clauses.push("t.run_id = ?");
+      params.push(options.runId);
+    }
+    if (options.boardId) {
+      clauses.push("t.board_id = ?");
+      params.push(options.boardId);
+    }
+    if (options.sessionId) {
+      clauses.push("t.session_id = ?");
+      params.push(options.sessionId);
+    }
+    if (options.status) {
+      clauses.push("t.status = ?");
+      params.push(options.status);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    params.push(clampLimit(options.limit, 100));
+    const rows = this.db.prepare(
+      `SELECT t.*, (SELECT COUNT(*) FROM file_lineage f WHERE f.task_id = t.task_id) AS files_touched
+       FROM task_outcomes t${where}
+       ORDER BY COALESCE(t.started_at, '') DESC LIMIT ?`
+    ).all(...params);
+    return rows.map((row) => ({
+      taskId: String(row.task_id),
+      runId: String(row.run_id),
+      boardId: String(row.board_id),
+      sessionId: String(row.session_id),
+      agentId: String(row.agent_id),
+      status: String(row.status),
+      startedAt: row.started_at === null ? null : String(row.started_at),
+      endedAt: row.ended_at === null ? null : String(row.ended_at),
+      durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
+      retries: Number(row.retries),
+      verificationFailures: Number(row.verification_failures),
+      filesTouched: Number(row.files_touched)
+    }));
+  }
+  fileLineage(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.path) {
+      clauses.push("path_key = ?");
+      params.push(normalizePathKey(options.path));
+    }
+    if (options.paths) {
+      const pathKeys = [...new Set(options.paths.map(normalizePathKey))];
+      if (pathKeys.length === 0) return [];
+      clauses.push(`path_key IN (${pathKeys.map(() => "?").join(",")})`);
+      params.push(...pathKeys);
+    }
+    if (options.taskId) {
+      clauses.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (options.boardId) {
+      clauses.push("board_id = ?");
+      params.push(options.boardId);
+    }
+    if (options.sessionId) {
+      clauses.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    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`;
+    const sql = options.latestPerPath ? `SELECT ${projection} FROM (
+           SELECT ${projection}, ROW_NUMBER() OVER (
+             PARTITION BY path_key ORDER BY occurred_at DESC, event_id DESC
+           ) AS path_rank
+           FROM file_lineage${where}
+         ) WHERE path_rank = 1 ORDER BY occurred_at DESC LIMIT ?` : `SELECT ${projection}
+         FROM file_lineage${where} ORDER BY occurred_at DESC LIMIT ?`;
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      path: row.path,
+      operation: row.operation,
+      occurredAt: row.occurred_at,
+      sessionId: row.session_id,
+      agentId: row.agent_id,
+      taskId: row.task_id,
+      boardId: row.board_id,
+      runId: row.run_id,
+      toolName: row.tool_name,
+      providerId: row.provider_id,
+      modelId: row.model_id,
+      source: row.source
+    }));
+  }
+  summary() {
+    const provider = this.db.prepare(
+      "SELECT COALESCE(SUM(attempts),0) a, COALESCE(SUM(completed),0) c, COALESCE(SUM(failed),0) f FROM provider_daily"
+    ).get();
+    const tasks = {};
+    for (const row of this.db.prepare("SELECT status, COUNT(*) n FROM task_outcomes GROUP BY status").all()) {
+      tasks[row.status] = Number(row.n);
     }
+    const files = this.db.prepare("SELECT COUNT(*) n, COUNT(DISTINCT path) p FROM file_lineage").get();
+    const cost = this.db.prepare("SELECT COALESCE(SUM(cost),0) c FROM token_cost").get();
+    const terminal = Number(provider.c) + Number(provider.f);
+    return {
+      providers: {
+        attempts: Number(provider.a),
+        completed: Number(provider.c),
+        failed: Number(provider.f),
+        successRate: terminal > 0 ? Number(provider.c) / terminal : 0
+      },
+      tasks,
+      files: { mutations: Number(files.n), uniquePaths: Number(files.p) },
+      estimatedCostUsd: Number(cost.c)
+    };
   }
-  ingestFileEvent(event) {
-    const attributes = event.attributes ?? {};
-    const operation = stringAt(attributes, "operation") ?? "";
-    if (!operation || operation === "read") return;
-    const filePath = event.resource?.path ?? stringAt(attributes, "filePath");
-    if (!filePath) return;
-    this.db.prepare(
-      `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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      event.eventId,
-      normalizeKey(filePath),
-      normalizePathKey(filePath),
-      operation,
-      event.occurredAt ?? event.observedAt,
-      event.scope.sessionId ?? "",
-      event.scope.agentId ?? "",
-      event.scope.taskId ?? stringAt(attributes, "taskId") ?? "",
-      event.scope.kanbanBoardId ?? stringAt(attributes, "boardId") ?? "",
-      stringAt(attributes, "runId") ?? "",
-      stringAt(attributes, "toolName") ?? "",
-      event.runtime?.providerId ?? stringAt(attributes, "provider") ?? "",
-      event.runtime?.modelId ?? stringAt(attributes, "model") ?? "",
-      stringAt(attributes, "source") ?? (event.eventType === "file.event" ? "tool" : "external")
-    );
+  /**
+   * A `ChronicleSummary` for the default/unfiltered dashboard view — only
+   * `from`/`to` (day-precision) narrow it.
+   */
+  defaultSummary(options = {}) {
+    const fromDay = options.from?.slice(0, 10);
+    const toDay = options.to?.slice(0, 10);
+    const dayFilter = (column) => {
+      const clauses = [];
+      const params = [];
+      if (fromDay) {
+        clauses.push(`${column} >= ?`);
+        params.push(fromDay);
+      }
+      if (toDay) {
+        clauses.push(`${column} <= ?`);
+        params.push(toDay);
+      }
+      return { where: clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "", params };
+    };
+    const providerRange = dayFilter("day");
+    const provider = this.db.prepare(
+      `SELECT COALESCE(SUM(attempts),0) attempts, COALESCE(SUM(completed),0) completed, COALESCE(SUM(failed),0) failed,
+        COALESCE(SUM(retries),0) retries, COALESCE(SUM(fallbacks),0) fallbacks,
+        COUNT(DISTINCT provider_id) providers, COUNT(DISTINCT model_id) models,
+        COALESCE(SUM(input_tokens),0) inputTokens, COALESCE(SUM(output_tokens),0) outputTokens,
+        COALESCE(SUM(cache_read_tokens),0) cacheReadTokens, COALESCE(SUM(cache_write_tokens),0) cacheWriteTokens,
+        COALESCE(SUM(duration_ms_total),0) durationTotal, COALESCE(MAX(duration_ms_max),0) durationMax,
+        COALESCE(SUM(duration_count),0) durationCount
+       FROM provider_daily${providerRange.where}`
+    ).get(...providerRange.params);
+    const counterRange = dayFilter("day");
+    const counters = this.db.prepare(
+      `SELECT COALESCE(SUM(tool_calls),0) toolCalls, COALESCE(SUM(completed_tools),0) completedTools,
+        COALESCE(SUM(failed_tools),0) failedTools, COALESCE(SUM(tool_duration_ms_total),0) toolDurationTotal,
+        COALESCE(SUM(tool_duration_count),0) toolDurationCount, COALESCE(SUM(processes),0) processes,
+        COALESCE(SUM(failed_processes),0) failedProcesses, COALESCE(SUM(file_events_all),0) fileEvents,
+        COALESCE(SUM(decisions),0) decisions, COALESCE(SUM(escalations),0) escalations,
+        COALESCE(SUM(agent_events),0) agentEvents, COALESCE(SUM(failures),0) failures,
+        COALESCE(SUM(cancellations),0) cancellations
+       FROM daily_counters${counterRange.where}`
+    ).get(...counterRange.params);
+    const familyRange = dayFilter("day");
+    const familyRows = this.db.prepare(`SELECT family, count, failure_count FROM family_daily${familyRange.where}`).all(...familyRange.params);
+    const families = { ...EMPTY_FAMILIES };
+    const failuresByFamily = { ...EMPTY_FAMILIES };
+    for (const row of familyRows) {
+      const family = row.family;
+      families[family] = Number(row.count);
+      failuresByFamily[family] = Number(row.failure_count);
+    }
+    const agentRange = dayFilter("day");
+    const uniqueAgents = this.db.prepare(`SELECT COUNT(DISTINCT agent_id) n FROM agent_daily${agentRange.where}`).get(...agentRange.params).n;
+    const requestRange = dayFilter("day");
+    const logicalRequests = this.db.prepare(
+      `SELECT COUNT(DISTINCT logical_request_id) n FROM logical_request_daily${requestRange.where}`
+    ).get(...requestRange.params).n;
+    const fileRange = dayFilter("day");
+    const uniqueFiles = this.db.prepare(`SELECT COUNT(DISTINCT path_key) n FROM file_seen_daily${fileRange.where}`).get(...fileRange.params).n;
+    const costRange = dayFilter("day");
+    const cost = this.db.prepare(`SELECT COALESCE(SUM(cost),0) c FROM token_cost${costRange.where}`).get(...costRange.params).c;
+    return {
+      logicalRequests: Number(logicalRequests),
+      modelAttempts: Number(provider.attempts),
+      completedAttempts: Number(provider.completed),
+      failedAttempts: Number(provider.failed),
+      scheduledRetries: Number(provider.retries),
+      fallbacks: Number(provider.fallbacks),
+      providers: Number(provider.providers),
+      models: Number(provider.models),
+      inputTokens: Number(provider.inputTokens),
+      outputTokens: Number(provider.outputTokens),
+      cacheReadTokens: Number(provider.cacheReadTokens),
+      cacheWriteTokens: Number(provider.cacheWriteTokens),
+      estimatedCostUsd: Number(cost),
+      providerAvgDurationMs: Number(provider.durationCount) > 0 ? Number(provider.durationTotal) / Number(provider.durationCount) : 0,
+      providerP95DurationMs: Number(provider.durationMax),
+      toolCalls: Number(counters.toolCalls),
+      completedTools: Number(counters.completedTools),
+      failedTools: Number(counters.failedTools),
+      toolAvgDurationMs: Number(counters.toolDurationCount) > 0 ? Number(counters.toolDurationTotal) / Number(counters.toolDurationCount) : 0,
+      processes: Number(counters.processes),
+      failedProcesses: Number(counters.failedProcesses),
+      fileEvents: Number(counters.fileEvents),
+      uniqueFiles: Number(uniqueFiles),
+      agentEvents: Number(counters.agentEvents),
+      uniqueAgents: Number(uniqueAgents),
+      decisions: Number(counters.decisions),
+      escalations: Number(counters.escalations),
+      failures: Number(counters.failures),
+      cancellations: Number(counters.cancellations),
+      families,
+      failuresByFamily
+    };
   }
 };
-function eventDay(event) {
-  return (event.occurredAt ?? event.observedAt).slice(0, 10);
-}
-function durationMs2(event) {
-  const value = Number(event.durationNs ?? 0) / 1e6;
-  return Number.isFinite(value) && value > 0 ? value : 0;
-}
-function numberOrDuration(event, attributes) {
-  const explicit = attributes.durationMs;
-  if (typeof explicit === "number" && Number.isFinite(explicit)) return explicit;
-  return durationMs2(event);
-}
-function numberAt2(event, dotPath) {
-  const value = readPath2(event.attributes ?? {}, dotPath);
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function readPath2(value, key) {
-  return key.split(".").reduce(
-    (current, part) => current && typeof current === "object" ? current[part] : void 0,
-    value
-  );
-}
-function stringAt(record, key) {
-  const value = record[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function asString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function clampLimit(limit, fallback) {
-  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return fallback;
-  return Math.min(Math.floor(limit), 1e4);
-}
-function normalizeKey(value) {
-  return value.replaceAll("\\", "/");
-}
-function normalizePathKey(value) {
-  return value.replaceAll("\\", "/").replace(/^\.\//, "").toLowerCase();
-}
 
 // src/chronicle/legacy-journal-import.ts
 import * as fs8 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 var ChronicleImportError = class extends Error {
   constructor(message, day, sequence) {
     super(message);
@@ -4172,12 +4165,14 @@ async function importLegacyChronicleJournal(journal, directory) {
   }
   const families = await discoverFamilies(directory);
   const quarantined = [];
+  const boundary = {};
   let importedEvents = 0;
   let importedFamilies = 0;
   for (const familyBase of families) {
     const day = dayOfFamily(familyBase);
-    const basePath = path11.join(directory, `${familyBase}.jsonl`);
+    const basePath = path12.join(directory, `${familyBase}.jsonl`);
     let familyEvents = 0;
+    const familyBoundary = {};
     if (journal.hasImportedDay(day)) continue;
     try {
       await journal.runFamilyImport(async (sink) => {
@@ -4191,6 +4186,7 @@ async function importLegacyChronicleJournal(journal, directory) {
         let expectedSequence = (checkpoint?.sequence ?? 0) + 1;
         let previousHash = checkpoint?.hash ?? GENESIS_HASH;
         for (const partition of await collectPartitions(basePath)) {
+          familyBoundary[path12.relative(directory, partition).replaceAll("\\", "/")] = (await fs8.stat(partition)).size;
           for await (const event of streamEntriesStrict(partition)) {
             if (event.sequence !== expectedSequence) {
               throw new ChronicleImportError(
@@ -4225,10 +4221,13 @@ async function importLegacyChronicleJournal(journal, directory) {
       quarantined.push({ day, sequence: error.sequence, reason: error.message });
       continue;
     }
+    Object.assign(boundary, familyBoundary);
     if (familyEvents > 0) importedFamilies += 1;
     importedEvents += familyEvents;
+    journal.recordLegacyJsonlBoundary(boundary);
   }
   journal.recordQuarantinedFamilies(quarantined);
+  journal.recordLegacyJsonlBoundary(boundary);
   journal.markLegacyJournalImported();
   return {
     alreadyImported: false,
@@ -4242,13 +4241,13 @@ async function importLegacyChronicleJournal(journal, directory) {
 import { spawn } from "node:child_process";
 import * as fs9 from "node:fs";
 import * as net from "node:net";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/chronicle/project-server-endpoint.ts
 import { createHash as createHash6 } from "node:crypto";
 import * as os3 from "node:os";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // src/chronicle/project-server-protocol.ts
 var CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION = 2;
@@ -4262,25 +4261,25 @@ function encodeChronicleProjectServerMessage(message) {
 // src/chronicle/project-server-endpoint.ts
 var CHRONICLE_PROJECT_SERVER_METADATA_FILE = "server.json";
 function normalizedPath(value) {
-  const resolved = path12.resolve(value);
+  const resolved = path13.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function chronicleProjectServerKey(projectDir) {
-  return createHash6("sha256").update(normalizedPath(path12.join(projectDir, "chronicle"))).digest("hex").slice(0, 24);
+  return createHash6("sha256").update(normalizedPath(path13.join(projectDir, "chronicle"))).digest("hex").slice(0, 24);
 }
 function chronicleProjectServerEndpoint(projectDir) {
   const key = chronicleProjectServerKey(projectDir);
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-chronicle-v${CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path12.join(
+  return path13.join(
     os3.tmpdir(),
     `wsch-v${CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION}`,
     `${key}.sock`
   );
 }
 function chronicleProjectServerMetadataPath(projectDir) {
-  return path12.join(projectDir, "chronicle", CHRONICLE_PROJECT_SERVER_METADATA_FILE);
+  return path13.join(projectDir, "chronicle", CHRONICLE_PROJECT_SERVER_METADATA_FILE);
 }
 
 // src/chronicle/project-server-client.ts
@@ -4715,7 +4714,7 @@ var ChronicleRemoteJournal = class {
   }
 };
 function normalizePath(value) {
-  const resolved = path13.resolve(value);
+  const resolved = path14.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 
@@ -4723,7 +4722,7 @@ function normalizePath(value) {
 function resolveChronicleProjectServerOptions(options) {
   if (options.projectPaths) {
     return {
-      projectRoot: path14.resolve(options.projectRoot),
+      projectRoot: path15.resolve(options.projectRoot),
       ...options.projectPaths,
       ...options.retentionDays !== void 0 ? { retentionDays: options.retentionDays } : {}
     };
@@ -4733,7 +4732,7 @@ function resolveChronicleProjectServerOptions(options) {
     userHome: options.userHome ?? os4.homedir()
   });
   return {
-    projectRoot: path14.resolve(options.projectRoot),
+    projectRoot: path15.resolve(options.projectRoot),
     globalRoot: paths.globalRoot,
     projectId: paths.projectHash,
     projectDir: paths.projectDir,
@@ -4778,7 +4777,7 @@ function createChronicleEventJournal(options) {
   }
   assertInlineWasRequested("createChronicleEventJournal");
   if (useSqliteStore()) {
-    const journal2 = new ChronicleSqliteEventSink(path14.join(resolved.projectDir, "chronicle"));
+    const journal2 = new ChronicleSqliteEventSink(path15.join(resolved.projectDir, "chronicle"));
     return {
       journal: journal2,
       identity,
@@ -4798,7 +4797,7 @@ function createChronicleEventJournal(options) {
   };
 }
 function legacyPartitionPath(location) {
-  return path14.join(location.chronicleDirectory, `${location.day}.events.jsonl`);
+  return path15.join(location.chronicleDirectory, `${location.day}.events.jsonl`);
 }
 function useSqliteStore() {
   return process.env["WRONGSTACK_CHRONICLE_STORE"] !== "jsonl";
@@ -4945,9 +4944,14 @@ var InlineChronicleProjectAccess = class {
       this.sqlite = void 0;
       store.close();
     }
+    for (const journal of this.journals.values()) {
+      await journal.flush().catch(() => {
+      });
+    }
+    this.journals.clear();
   }
   get chronicleDirectory() {
-    return path14.join(this.options.projectDir, "chronicle");
+    return path15.join(this.options.projectDir, "chronicle");
   }
   journalForToday() {
     const now = /* @__PURE__ */ new Date();