@wrongstack/core 0.302.0 → 0.302.2

package/dist/chronicle/index.js

@@ -1436,9 +1436,9 @@ function errorMessage(error) {
 }
 
 // src/chronicle/metrics-store.ts
-import * as fs6 from "node:fs/promises";
-import { createRequire } from "node:module";
-import * as path9 from "node:path";
+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;
@@ -2264,1127 +2264,1076 @@ function facetValue(event, field) {
   return values[field];
 }
 
-// src/chronicle/metrics-store.ts
-var SCHEMA_VERSION = 3;
-var READ_CHUNK_BYTES = 1024 * 1024;
-var EMPTY_FAMILIES = {
-  llm: 0,
-  agent: 0,
-  tool: 0,
-  file: 0,
-  memory: 0,
-  task: 0,
-  decision: 0,
-  runtime: 0,
-  finding: 0
-};
-var Ctor;
-function loadDatabaseSync() {
-  if (Ctor) return Ctor;
-  if (Ctor === null) throw new Error("node:sqlite is unavailable in this runtime");
+// src/chronicle/sqlite-journal.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import * as fs6 from "node:fs";
+import { createRequire } from "node:module";
+import * as path9 from "node:path";
+
+// src/utils/pid.ts
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
   try {
-    Ctor = withSqliteExperimentalWarningSuppressed(
-      () => createRequire(import.meta.url)("node:sqlite").DatabaseSync
-    );
-    return Ctor;
-  } catch (error) {
-    Ctor = null;
-    throw new Error(
-      "Chronicle metrics need Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
-    );
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
   }
 }
-function isChronicleMetricsAvailable() {
+
+// src/chronicle/sqlite-query.ts
+var MAX_LIMIT = 1e4;
+function encodeCursor2(cursor) {
+  return Buffer.from(`${cursor.day}:${cursor.sequence}`, "utf8").toString("base64url");
+}
+function decodeCursor2(raw) {
+  if (!raw) return void 0;
   try {
-    loadDatabaseSync();
-    return true;
+    const [day, sequence] = Buffer.from(raw, "base64url").toString("utf8").split(":");
+    if (!day || sequence === void 0) return void 0;
+    const parsed = Number(sequence);
+    return Number.isSafeInteger(parsed) ? { day, sequence: parsed } : void 0;
   } catch {
-    return false;
+    return void 0;
   }
 }
-var ChronicleMetricsStore = class _ChronicleMetricsStore {
-  db;
-  directory;
-  dbPath;
-  constructor(directory) {
-    this.directory = path9.resolve(directory);
-    this.dbPath = path9.join(this.directory, "metrics.db");
-    const Database = loadDatabaseSync();
-    this.db = new Database(this.dbPath);
-    this.db.exec("PRAGMA journal_mode = WAL");
-    this.ensureSchema();
+function pushDown(query) {
+  const clauses = [];
+  const params = [];
+  const eq = (column, value) => {
+    if (value === void 0) return;
+    clauses.push(`${column} = ?`);
+    params.push(value);
+  };
+  eq("event_id", query.eventId);
+  eq("project_id", query.projectId);
+  eq("session_id", query.sessionId);
+  eq("agent_id", query.agentId);
+  eq("task_id", query.taskId);
+  eq("trace_id", query.traceId);
+  eq("logical_request_id", query.logicalRequestId);
+  eq("resource_kind", query.resourceKind);
+  eq("resource_id", query.resourceId);
+  if (query.eventTypes?.length) {
+    clauses.push(`event_type IN (${query.eventTypes.map(() => "?").join(",")})`);
+    params.push(...query.eventTypes);
   }
-  static open(chronicleDirectory) {
-    return new _ChronicleMetricsStore(chronicleDirectory);
+  if (query.outcomes?.length) {
+    clauses.push(`outcome IN (${query.outcomes.map(() => "?").join(",")})`);
+    params.push(...query.outcomes);
   }
-  close() {
-    this.db.close();
+  if (query.from) {
+    clauses.push("occurred_at >= ?");
+    params.push(query.from);
   }
-  /** Incrementally ingest journal bytes appended since the last refresh.
-   *  Safe across processes: guarded by a file lock on the database path. */
-  async refresh() {
+  if (query.to) {
+    clauses.push("occurred_at <= ?");
+    params.push(query.to);
+  }
+  return { clause: clauses.length ? clauses.join(" AND ") : "1=1", params };
+}
+var ChronicleSqliteQueryEngine = class {
+  constructor(db, options = {}) {
+    this.db = db;
+    this.batchSize = Math.max(1, options.batchSize ?? 1e3);
+  }
+  db;
+  diagnostics = { sourceFiles: 1, invalidLines: 0 };
+  batchSize;
+  async query(query = {}) {
+    const order = query.order ?? "desc";
+    const limit = Math.max(1, Math.min(query.limit ?? 100, MAX_LIMIT));
+    const cursor = decodeCursor2(query.cursor);
+    const pushed = pushDown(query);
+    const direction = order === "asc" ? "ASC" : "DESC";
+    const comparison = order === "asc" ? ">" : "<";
+    const keyset = cursor ? ` AND (day, sequence) ${comparison} (?, ?)` : "";
+    const sql = `SELECT day, sequence, payload FROM events WHERE ${pushed.clause}${keyset} ORDER BY day ${direction}, sequence ${direction} LIMIT ? OFFSET ?`;
+    const summary = createSummaryAccumulator();
+    const page = [];
+    let total = 0;
+    let scannedEvents = 0;
+    let last;
+    let offset = 0;
+    for (; ; ) {
+      const params = [...pushed.params];
+      if (cursor) params.push(cursor.day, cursor.sequence);
+      params.push(this.batchSize, offset);
+      const rows = this.db.prepare(sql).all(...params);
+      if (rows.length === 0) break;
+      offset += rows.length;
+      for (const row of rows) {
+        scannedEvents++;
+        let event;
+        try {
+          event = JSON.parse(row.payload);
+        } catch {
+          this.diagnostics.invalidLines++;
+          continue;
+        }
+        if (!matches(event, query)) continue;
+        total++;
+        updateSummary(summary, event);
+        if (page.length < limit) {
+          page.push(event);
+          last = { day: row.day, sequence: row.sequence };
+        }
+      }
+      if (rows.length < this.batchSize) break;
+    }
+    page.sort((left, right) => compareEvents(left, right) * (order === "asc" ? 1 : -1));
     const result = {
-      ingestedEvents: 0,
-      ingestedBytes: 0,
-      sourceFiles: 0,
-      invalidLines: 0
+      events: page,
+      total,
+      scannedEvents,
+      sourceFiles: this.diagnostics.sourceFiles,
+      invalidLines: this.diagnostics.invalidLines,
+      summary: finalizeSummary(summary)
     };
-    await withFileLock(this.dbPath, async () => {
-      const files = await findChroniclePartitions(this.directory);
-      const offsets = this.loadOffsets();
-      for (const file of files) {
-        const key = normalizeKey(path9.relative(this.directory, file));
-        const consumed = offsets.get(key) ?? 0;
-        const ingested = await this.ingestFile(file, key, consumed, result);
-        if (ingested) result.sourceFiles++;
-      }
-      this.pruneOffsets(files);
-    });
+    if (total > page.length && last) {
+      return { ...result, nextCursor: encodeCursor2(last) };
+    }
     return result;
   }
-  providerDaily(options = {}) {
-    const clauses = [];
-    const params = [];
-    if (options.from) {
-      clauses.push("day >= ?");
-      params.push(options.from.slice(0, 10));
+  /**
+   * Value counts per facet field.
+   *
+   * Not a SQL `GROUP BY`: `facetValue()` reads fields that live inside the
+   * payload — provider, model, tool call, tag — so grouping in SQL would only
+   * work for the handful that happen to be columns and would need a second,
+   * divergent definition for the rest. The narrowing is still done by SQL; the
+   * counting uses the JSONL engine's own projection.
+   */
+  async facets(fields, query = {}, limit = 100) {
+    const uniqueFields = [...new Set(fields)];
+    if (uniqueFields.length === 0) return {};
+    const counts = new Map(uniqueFields.map((field) => [field, /* @__PURE__ */ new Map()]));
+    for (const event of this.eachMatch(query)) {
+      for (const field of uniqueFields) {
+        const value = facetValue(event, field);
+        if (value === void 0) continue;
+        const fieldCounts = counts.get(field);
+        fieldCounts?.set(value, (fieldCounts.get(value) ?? 0) + 1);
+      }
     }
-    if (options.to) {
-      clauses.push("day <= ?");
-      params.push(options.to.slice(0, 10));
+    const result = {};
+    for (const field of uniqueFields) {
+      result[field] = [...counts.get(field) ?? /* @__PURE__ */ new Map()].map(([value, count]) => ({ value, count })).sort((left, right) => right.count - left.count || left.value.localeCompare(right.value)).slice(0, Math.max(0, limit));
     }
-    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)
-    }));
+    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)
-    }));
+  async facet(field, query = {}, limit = 100) {
+    return (await this.facets([field], query, limit))[field] ?? [];
   }
-  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);
+  /**
+   * Expand explicit and typed correlation edges around a seed set.
+   *
+   * The traversal is the JSONL engine's, moved onto rows: `relationKeys()`
+   * defines the edges, `compareEvents` orders the nodes, and each hop is
+   * another ordered pass. Order is load-bearing rather than cosmetic — both
+   * `maxNodes` truncations stop at whatever they reach first, so a differently
+   * ordered scan would return a different subgraph rather than the same one
+   * shuffled. `ORDER BY day, sequence` reproduces `comparePartitionPaths`
+   * (family, then rotation index) followed by line order within a partition.
+   */
+  async graph(seed = {}, hops = 2, maxNodes = 1e3) {
+    const nodeLimit = Math.max(0, Math.floor(maxNodes));
+    const selected = /* @__PURE__ */ new Map();
+    let seedCount = 0;
+    for (const event of this.eachMatch(seed)) {
+      seedCount++;
+      if (selected.size < nodeLimit) selected.set(event.eventId, event);
     }
-    if (options.boardId) {
-      clauses.push("board_id = ?");
-      params.push(options.boardId);
+    let frontier = [...selected.values()];
+    const depthLimit = Math.max(0, Math.min(hops, 10));
+    for (let depth = 0; depth < depthLimit && frontier.length > 0 && selected.size < nodeLimit; depth++) {
+      const frontierKeys = new Set(
+        frontier.flatMap((event) => relationKeys(event).map((relation) => relation.key))
+      );
+      const next = [];
+      for (const event of this.eachMatch({})) {
+        if (selected.has(event.eventId)) continue;
+        if (!relationKeys(event).some((relation) => frontierKeys.has(relation.key))) continue;
+        selected.set(event.eventId, event);
+        next.push(event);
+        if (selected.size >= nodeLimit) break;
+      }
+      frontier = next;
     }
-    if (options.sessionId) {
-      clauses.push("session_id = ?");
-      params.push(options.sessionId);
+    const nodes = [...selected.values()].sort(compareEvents);
+    const byKey = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      for (const relation of relationKeys(node)) {
+        const related = byKey.get(relation.key) ?? [];
+        related.push(node);
+        byKey.set(relation.key, related);
+      }
     }
-    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 edges = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      for (const relation of relationKeys(node)) {
+        for (const candidate of byKey.get(relation.key) ?? []) {
+          if (candidate.eventId === node.eventId) continue;
+          const [from, to] = compareEvents(node, candidate) <= 0 ? [node, candidate] : [candidate, node];
+          const id = `${from.eventId}:${to.eventId}:${relation.kind}`;
+          if (seen.has(id)) continue;
+          seen.add(id);
+          edges.push({
+            from: from.eventId,
+            to: to.eventId,
+            kind: relation.kind,
+            confidence: relation.confidence
+          });
+        }
+      }
     }
-    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)
+      nodes,
+      edges,
+      truncated: seedCount > nodeLimit || selected.size >= nodeLimit
     };
   }
-  /**
-   * 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);
+  /** Every event satisfying `query`, pulled in batches so a wide scan stays bounded. */
+  *eachMatch(query) {
+    const pushed = pushDown(query);
+    const sql = `SELECT payload FROM events WHERE ${pushed.clause} ORDER BY day, sequence LIMIT ? OFFSET ?`;
+    let offset = 0;
+    for (; ; ) {
+      const rows = this.db.prepare(sql).all(...pushed.params, this.batchSize, offset);
+      if (rows.length === 0) return;
+      offset += rows.length;
+      for (const row of rows) {
+        let event;
+        try {
+          event = JSON.parse(row.payload);
+        } catch {
+          this.diagnostics.invalidLines++;
+          continue;
+        }
+        if (matches(event, query)) yield event;
       }
-      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);
+      if (rows.length < this.batchSize) return;
     }
-    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_VERSION) {
-      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;"
-      );
-    }
-    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_VERSION};
-    `);
-  }
-  loadOffsets() {
-    const rows = this.db.prepare("SELECT file, bytes FROM ingest_state").all();
-    return new Map(rows.map((row) => [row.file, Number(row.bytes)]));
+};
+
+// 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;
   }
-  pruneOffsets(existingFiles) {
-    const keep = new Set(
-      existingFiles.map((file) => normalizeKey(path9.relative(this.directory, file)))
+};
+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
     );
-    for (const row of this.db.prepare("SELECT file FROM ingest_state").all()) {
-      if (!keep.has(row.file))
-        this.db.prepare("DELETE FROM ingest_state WHERE file = ?").run(row.file);
+    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;
+  now;
+  monotonicNow;
+  idFactory;
+  retentionDays;
+  maxEvents;
+  maxBytes;
+  retentionCheckIntervalMs;
+  /** Overshoot allowed above `maxEvents` before eviction runs; see TRIM_SLACK_RATIO. */
+  trimSlack;
+  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.
+   *
+   * `db.prepare` re-parses the SQL every call, and the append path used to
+   * prepare five statements per batch. They are held rather than re-prepared
+   * because the schema cannot change under an open journal.
+   */
+  statements;
+  /**
+   * Cached chain head per day. Cleared wholesale on any write failure so the
+   * next append rebuilds from the database rather than trusting a counter that
+   * may have advanced past what actually committed.
+   */
+  anchors = /* @__PURE__ */ new Map();
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0
+  };
+  lastBatchDurationMs;
+  constructor(options) {
+    this.dbPath = path9.join(path9.resolve(options.directory), CHRONICLE_SQLITE_FILE);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
+    this.idFactory = options.idFactory ?? (() => randomUUID3());
+    if (options.retentionDays !== void 0 && (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0)) {
+      throw new RangeError("retentionDays must be a positive finite number");
+    }
+    if (options.retentionCheckIntervalMs !== void 0 && (!Number.isFinite(options.retentionCheckIntervalMs) || options.retentionCheckIntervalMs <= 0)) {
+      throw new RangeError("retentionCheckIntervalMs must be a positive finite number");
+    }
+    if (options.maxEvents !== void 0 && (!Number.isInteger(options.maxEvents) || options.maxEvents < 1)) {
+      throw new RangeError("maxEvents must be a positive integer");
+    }
+    if (options.maxBytes !== void 0 && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1)) {
+      throw new RangeError("maxBytes must be a positive safe integer");
+    }
+    const minimumQuotaBytes = SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES;
+    if (options.maxBytes !== void 0 && options.maxBytes < minimumQuotaBytes) {
+      throw new RangeError(`maxBytes must be at least ${minimumQuotaBytes}`);
+    }
+    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();
+    this.db = new Database(this.dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    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();
+    if (this.maxEvents !== void 0) {
+      const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
+      this.retainedEventCount = row.count;
+      this.enforceEventLimitAtStartup();
     }
   }
-  /** 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 {
-      handle = await fs6.open(file, "r");
-    } catch {
-      return false;
+  close() {
+    this.db.close();
+  }
+  stats() {
+    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();
+  }
+  async append(input) {
+    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();
+    this.counters.acceptedEvents += inputs.length;
+    this.counters.batches += 1;
+    this.counters.largestBatch = Math.max(this.counters.largestBatch, inputs.length);
+    const instant = this.now().toISOString();
+    const day = instant.slice(0, 10);
+    const events = [];
+    let previous = this.readAnchor(day);
+    for (const input of inputs) {
+      const unhashed = {
+        ...input,
+        occurredAt: input.occurredAt ?? instant,
+        monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
+        schemaVersion: CHRONICLE_SCHEMA_VERSION,
+        eventId: this.idFactory(),
+        observedAt: instant,
+        persistedAt: instant,
+        sequence: previous.sequence + 1,
+        previousHash: previous.hash
+      };
+      const event = { ...unhashed, hash: hashValue(unhashed) };
+      events.push(event);
+      previous = { sequence: event.sequence, hash: event.hash };
     }
+    const payloads = events.map((event) => JSON.stringify(event));
+    let batchBytes = 0;
+    for (const payload of payloads) batchBytes += Buffer.byteLength(payload, "utf8");
+    let retainedCountAfterCommit = this.retainedEventCount;
     try {
-      const size = (await handle.stat()).size;
-      if (size <= consumed) return false;
-      let position = consumed;
-      let remainder = Buffer.alloc(0);
-      let advanced = consumed;
-      this.db.exec("BEGIN");
+      this.db.exec("BEGIN IMMEDIATE");
+      this.assertWithinByteQuota(batchBytes);
+      const { insert } = this.preparedStatements();
+      for (const [index, event] of events.entries()) {
+        const row = projectEvent(event);
+        insert.run(
+          day,
+          event.sequence,
+          event.eventId,
+          event.hash,
+          event.previousHash,
+          row.occurredAt,
+          event.eventType,
+          row.outcome,
+          row.projectId,
+          row.sessionId,
+          row.agentId,
+          row.taskId,
+          row.traceId,
+          row.logicalRequestId,
+          row.resourceKind,
+          row.resourceId,
+          row.resourcePath,
+          row.durationNs,
+          payloads[index]
+        );
+      }
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(
+        this.retainedEventCount + events.length
+      );
+      this.assertActualAllocationWithinQuota();
+      this.db.exec("COMMIT");
+    } catch (error) {
       try {
-        while (position < size) {
-          const length = Math.min(READ_CHUNK_BYTES, size - position);
-          const buffer = Buffer.allocUnsafe(length);
-          const { bytesRead } = await handle.read(buffer, 0, length, position);
-          if (bytesRead <= 0) break;
-          position += bytesRead;
-          const data = remainder.length > 0 ? Buffer.concat([remainder, buffer.subarray(0, bytesRead)]) : buffer.subarray(0, bytesRead);
-          const lastNewline = data.lastIndexOf(10);
-          if (lastNewline < 0) {
-            remainder = Buffer.from(data);
-            continue;
-          }
-          for (const line of data.subarray(0, lastNewline).toString("utf8").split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed) continue;
-            try {
-              this.ingestEvent(JSON.parse(trimmed));
-              result.ingestedEvents++;
-            } catch {
-              result.invalidLines++;
-            }
-          }
-          advanced += lastNewline + 1;
-          remainder = Buffer.from(data.subarray(lastNewline + 1));
-        }
-        this.db.prepare(
-          "INSERT INTO ingest_state (file, bytes) VALUES (?, ?) ON CONFLICT(file) DO UPDATE SET bytes = excluded.bytes"
-        ).run(key, advanced);
-        this.db.exec("COMMIT");
-      } catch (error) {
         this.db.exec("ROLLBACK");
-        throw error;
+      } catch {
+      }
+      this.anchors.clear();
+      this.invalidateQuotaEstimate();
+      this.counters.failedEvents += inputs.length;
+      this.lastBatchDurationMs = performance.now() - started;
+      throw this.normalizeQuotaError(error);
+    }
+    this.anchors.set(day, previous);
+    this.counters.persistedEvents += events.length;
+    this.retainedEventCount = retainedCountAfterCommit;
+    this.bytesSinceQuotaCheck += batchBytes;
+    this.lastBatchDurationMs = performance.now() - started;
+    await this.enforceRetentionIfDue();
+    return events;
+  }
+  async readAll() {
+    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;
+    let lastHash = GENESIS_HASH;
+    for (const day of this.days()) {
+      const checkpoint = this.readCheckpoint(day);
+      let expectedSequence = (checkpoint?.sequence ?? 0) + 1;
+      let previousHash = checkpoint?.hash ?? GENESIS_HASH;
+      const rows = this.db.prepare(
+        "SELECT sequence, hash, previous_hash, payload FROM events WHERE day = ? ORDER BY sequence"
+      ).all(day);
+      for (const row of rows) {
+        if (row.sequence !== expectedSequence) {
+          return {
+            ok: false,
+            entries,
+            brokenAt: entries,
+            reason: `sequence gap in ${day}: expected ${expectedSequence}, found ${row.sequence}`
+          };
+        }
+        if (row.previous_hash !== previousHash) {
+          return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
+        }
+        let event;
+        try {
+          event = JSON.parse(row.payload);
+        } catch {
+          return { ok: false, entries, brokenAt: entries, reason: "invalid payload JSON" };
+        }
+        if (chronicleEventHash(event) !== row.hash) {
+          return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
+        }
+        entries += 1;
+        expectedSequence = row.sequence + 1;
+        previousHash = row.hash;
       }
-      result.ingestedBytes += advanced - consumed;
-      return advanced > consumed;
-    } finally {
-      await handle.close();
+      lastSequence = expectedSequence - 1;
+      lastHash = previousHash;
     }
+    return { ok: true, entries, lastSequence, lastHash };
   }
-  ingestEvent(event) {
-    if (typeof event?.eventType !== "string" || !event.scope) return;
-    this.ingestDailyCounters(event);
-    const type = event.eventType;
-    if (type.startsWith("provider.attempt.") || type === "provider.fallback") {
-      this.ingestProvider(event);
-    } else if (type === "token.accounted") {
-      this.ingestTokenCost(event);
-    } else if (/^(?:sdd|subagent|kanban)\.task[._]/.test(type)) {
-      this.ingestTask(event);
-    } else if (type === "file.event" || /^file\.(?:tool|external)\./.test(type)) {
-      this.ingestFileEvent(event);
+  async enforceRetentionIfDue() {
+    if (this.retentionDays === void 0) return;
+    const now = this.now();
+    if (now.getTime() < this.nextRetentionCheckAt) return;
+    this.nextRetentionCheckAt = now.getTime() + this.retentionCheckIntervalMs;
+    try {
+      await this.purge({ retentionDays: this.retentionDays });
+    } catch {
     }
   }
-  /** 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);
-    const bump = (sql, ...params) => this.db.prepare(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
-    const family = signalFamily(event);
-    const failed = isTerminalFailure(event) ? 1 : 0;
-    this.db.prepare(
-      `INSERT INTO family_daily (day, family, count, failure_count) VALUES (?, ?, 1, ?)
-       ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
-    ).run(day, family, failed);
-    if (failed) bump("failures = failures + 1");
-    if (event.outcome === "cancelled" || event.outcome === "abandoned") bump("cancellations = cancellations + 1");
-    if (family === "agent") bump("agent_events = agent_events + 1");
-    if (event.correlation.logicalRequestId) {
-      this.db.prepare("INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)").run(day, event.correlation.logicalRequestId);
-    }
-    if (event.scope.agentId) {
-      this.db.prepare("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(day, event.scope.agentId);
+  configureByteQuota() {
+    if (this.maxBytes === void 0) {
+      this.db.exec("PRAGMA max_page_count = 2147483646");
+      return;
     }
-    const type = event.eventType;
-    if (type === "decision.requested") bump("decisions = decisions + 1");
-    else if (type === "decision.escalated") bump("escalations = escalations + 1");
-    else if (type === "tool.started") bump("tool_calls = tool_calls + 1");
-    else if (type === "tool.executed" || type === "tool.failed") {
-      const dur = durationMs2(event);
-      const durationCount = dur > 0 ? 1 : 0;
-      bump(
-        `${type === "tool.executed" ? "completed_tools" : "failed_tools"} = ${type === "tool.executed" ? "completed_tools" : "failed_tools"} + 1,
-         tool_duration_ms_total = tool_duration_ms_total + ?, tool_duration_ms_max = MAX(tool_duration_ms_max, ?), tool_duration_count = tool_duration_count + ?`,
-        dur,
-        dur,
-        durationCount
+    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}`
       );
-    } else if (type === "process.started") bump("processes = processes + 1");
-    else if (type === "process.completed" && event.outcome === "failure") bump("failed_processes = failed_processes + 1");
-    if (event.resource?.kind === "file" || type.startsWith("file.")) {
-      bump("file_events_all = file_events_all + 1");
-      if (event.resource?.path) {
-        this.db.prepare("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(day, normalizePathKey(event.resource.path));
-      }
     }
+    const maxPages = Math.max(1, Math.floor(mainBudget / this.pageSizeBytes()));
+    this.db.exec(`PRAGMA max_page_count = ${maxPages}`);
   }
-  ingestProvider(event) {
-    const day = eventDay(event);
-    const providerId = event.runtime?.providerId ?? asString(readPath2(event.attributes ?? {}, "from.providerId")) ?? "";
-    const modelId = event.runtime?.modelId ?? asString(readPath2(event.attributes ?? {}, "from.model")) ?? "";
-    if (!providerId && !modelId) return;
-    this.db.prepare("INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)").run(day, providerId, modelId);
-    const update = (sql, ...params) => this.db.prepare(
-      `UPDATE provider_daily SET ${sql} WHERE day = ? AND provider_id = ? AND model_id = ?`
-    ).run(...params, day, providerId, modelId);
-    const duration = durationMs2(event);
-    switch (event.eventType) {
-      case "provider.attempt.started":
-        update("attempts = attempts + 1");
-        break;
-      case "provider.attempt.completed":
-        update(
-          "completed = completed + 1, input_tokens = input_tokens + ?, output_tokens = output_tokens + ?, cache_read_tokens = cache_read_tokens + ?, cache_write_tokens = cache_write_tokens + ?, duration_ms_total = duration_ms_total + ?, duration_ms_max = MAX(duration_ms_max, ?), duration_count = duration_count + ?",
-          numberAt2(event, "usage.input"),
-          numberAt2(event, "usage.output"),
-          numberAt2(event, "usage.cacheRead"),
-          numberAt2(event, "usage.cacheWrite"),
-          duration,
-          duration,
-          duration > 0 ? 1 : 0
-        );
-        break;
-      case "provider.attempt.failed":
-        update(
-          "failed = failed + 1, retries = retries + ?, duration_ms_total = duration_ms_total + ?, duration_ms_max = MAX(duration_ms_max, ?), duration_count = duration_count + ?",
-          event.attributes?.retryScheduled === true ? 1 : 0,
-          duration,
-          duration,
-          duration > 0 ? 1 : 0
-        );
-        break;
-      case "provider.fallback":
-        update("fallbacks = fallbacks + 1");
-        break;
-      default:
-        break;
+  /**
+   * 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();
   }
-  ingestTokenCost(event) {
-    const cost = readPath2(event.attributes ?? {}, "cost.total");
-    if (typeof cost !== "number" || !Number.isFinite(cost)) return;
-    const scopeKey2 = `${event.scope.projectId ?? ""}\0${event.scope.sessionId ?? ""}\0${event.scope.agentId ?? ""}`;
-    const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare(
-      `INSERT INTO token_cost (scope_key, day, occurred_at, sequence, cost) VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(scope_key) DO UPDATE SET
-         day = excluded.day, occurred_at = excluded.occurred_at,
-         sequence = excluded.sequence, cost = excluded.cost
-       WHERE excluded.occurred_at > token_cost.occurred_at
-          OR (excluded.occurred_at = token_cost.occurred_at AND excluded.sequence > token_cost.sequence)`
-    ).run(scopeKey2, eventDay(event), occurredAt, event.sequence, cost);
+  /** 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();
   }
-  ingestTask(event) {
-    const attributes = event.attributes ?? {};
-    const taskId = event.scope.taskId ?? stringAt(attributes, "taskId");
-    if (!taskId) return;
-    const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
-    const set = (sql, ...params) => this.db.prepare(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
-    const lineage = [
-      ["run_id", stringAt(attributes, "runId")],
-      ["board_id", event.scope.kanbanBoardId ?? stringAt(attributes, "boardId")],
-      ["session_id", event.scope.sessionId],
-      ["agent_id", event.scope.agentId ?? stringAt(attributes, "subagentId")]
-    ];
-    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;
+  /** 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
+    });
   }
-  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")
-    );
+  /**
+   * 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;
   }
-};
-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 fs7 from "node:fs/promises";
-import * as path10 from "node:path";
-var ChronicleImportError = class extends Error {
-  constructor(message, day, sequence) {
-    super(message);
-    this.day = day;
-    this.sequence = sequence;
-    this.name = "ChronicleImportError";
+  recordQuotaHeadroom(currentBytes) {
+    this.quotaHeadroomBytes = Math.max(0, (this.maxBytes ?? 0) - currentBytes);
+    this.bytesSinceQuotaCheck = 0;
   }
-  day;
-  sequence;
-};
-async function discoverFamilies(directory) {
-  let entries;
-  try {
-    entries = await fs7.readdir(directory);
-  } catch {
-    return [];
+  /**
+   * 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;
+    const statements = this.preparedStatements();
+    const boundary = statements.trimBoundary.get(excess - 1);
+    if (!boundary) return count;
+    statements.writeCheckpoint.run(boundary.day, boundary.sequence, boundary.hash);
+    statements.deletePrefix.run(boundary.day, boundary.day, boundary.sequence);
+    statements.deleteCheckpoints.run(boundary.day);
+    for (const day of this.anchors.keys()) {
+      if (day <= boundary.day) this.anchors.delete(day);
+    }
+    return this.maxEvents;
   }
-  const bases = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const match = PARTITION_FILE_PATTERN.exec(entry);
-    if (match?.[1]) bases.add(match[1]);
+  enforceEventLimitAtStartup() {
+    if (this.maxEvents === void 0 || this.retainedEventCount <= this.maxEvents) return;
+    try {
+      this.db.exec("BEGIN IMMEDIATE");
+      const retainedCount = this.enforceEventLimitWithinTransaction(this.retainedEventCount, 0);
+      this.db.exec("COMMIT");
+      this.retainedEventCount = retainedCount;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
   }
-  return [...bases].sort();
-}
-function dayOfFamily(familyBase) {
-  return familyBase.replace(/\.events$/u, "");
-}
-async function importLegacyChronicleJournal(journal, directory) {
-  if (journal.hasImportedLegacyJournal()) {
-    return {
-      alreadyImported: true,
-      families: 0,
-      events: 0,
-      quarantined: journal.quarantinedFamilies()
+  /**
+   * 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,
+      deletedBytes: 0,
+      skippedCount: 0,
+      errors: []
     };
-  }
-  const families = await discoverFamilies(directory);
-  const quarantined = [];
-  let importedEvents = 0;
-  let importedFamilies = 0;
-  for (const familyBase of families) {
-    const day = dayOfFamily(familyBase);
-    const basePath = path10.join(directory, `${familyBase}.jsonl`);
-    let familyEvents = 0;
-    if (journal.hasImportedDay(day)) continue;
+    if (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0) return empty;
+    const cutoff = new Date(this.now().getTime() - options.retentionDays * 864e5).toISOString().slice(0, 10);
+    const count = this.db.prepare("SELECT COUNT(*) AS n FROM events WHERE day < ?").get(cutoff).n;
+    if (count === 0) return empty;
+    if (options.dryRun) {
+      const days = this.db.prepare("SELECT DISTINCT day FROM events WHERE day < ? ORDER BY day").all(cutoff);
+      return { ...empty, deletedCount: count, candidates: days.map((row) => row.day) };
+    }
     try {
-      await journal.runFamilyImport(async (sink) => {
-        familyEvents = 0;
-        const checkpointResult = await readRetentionCheckpoint(basePath);
-        if (checkpointResult.error) {
-          throw new ChronicleImportError(checkpointResult.error, day, 0);
-        }
-        const checkpoint = checkpointResult.checkpoint;
-        if (checkpoint) sink.checkpoint(day, checkpoint.sequence, checkpoint.hash);
-        let expectedSequence = (checkpoint?.sequence ?? 0) + 1;
-        let previousHash = checkpoint?.hash ?? GENESIS_HASH;
-        for (const partition of await collectPartitions(basePath)) {
-          for await (const event of streamEntriesStrict(partition)) {
-            if (event.sequence !== expectedSequence) {
-              throw new ChronicleImportError(
-                `sequence gap in ${day}: expected ${expectedSequence}, found ${event.sequence}`,
-                day,
-                event.sequence
-              );
-            }
-            if (event.previousHash !== previousHash) {
-              throw new ChronicleImportError(
-                `previous hash mismatch in ${day} at sequence ${event.sequence}`,
-                day,
-                event.sequence
-              );
-            }
-            if (chronicleEventHash(event) !== event.hash) {
-              throw new ChronicleImportError(
-                `entry hash mismatch in ${day} at sequence ${event.sequence}`,
-                day,
-                event.sequence
-              );
-            }
-            sink.insert(day, event);
-            familyEvents += 1;
-            expectedSequence = event.sequence + 1;
-            previousHash = event.hash;
+      this.db.exec("BEGIN IMMEDIATE");
+      this.db.prepare("DELETE FROM events WHERE day < ?").run(cutoff);
+      this.db.prepare("DELETE FROM chain_checkpoint WHERE day < ?").run(cutoff);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      return {
+        ...empty,
+        errors: [
+          {
+            file: this.dbPath,
+            reason: error instanceof Error ? error.message : String(error)
           }
+        ]
+      };
+    }
+    this.anchors.clear();
+    this.retainedEventCount = this.countRows();
+    this.invalidateQuotaEstimate();
+    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 (
+         day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
+         project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+         resource_kind, resource_id, resource_path, duration_ns, payload
+       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+    );
+    const checkpoint = this.db.prepare(
+      `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
+         ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
+    );
+    this.db.exec("BEGIN IMMEDIATE");
+    let retainedCountAfterCommit = this.retainedEventCount;
+    try {
+      this.invalidateQuotaEstimate();
+      this.assertWithinByteQuota(0);
+      await load({
+        insert: (day, event) => {
+          const row = projectEvent(event);
+          insert.run(
+            day,
+            event.sequence,
+            event.eventId,
+            event.hash,
+            event.previousHash,
+            row.occurredAt,
+            event.eventType,
+            row.outcome,
+            row.projectId,
+            row.sessionId,
+            row.agentId,
+            row.taskId,
+            row.traceId,
+            row.logicalRequestId,
+            row.resourceKind,
+            row.resourceId,
+            row.resourcePath,
+            row.durationNs,
+            JSON.stringify(event)
+          );
+        },
+        checkpoint: (day, sequence, hash3) => {
+          checkpoint.run(day, sequence, hash3);
         }
       });
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(this.countRows(), 0);
+      this.invalidateQuotaEstimate();
+      this.assertActualAllocationWithinQuota();
+      this.db.exec("COMMIT");
     } catch (error) {
-      if (!(error instanceof ChronicleImportError)) throw error;
-      quarantined.push({ day, sequence: error.sequence, reason: error.message });
-      continue;
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      this.invalidateQuotaEstimate();
+      throw this.normalizeQuotaError(error);
+    } finally {
+      this.anchors.clear();
     }
-    if (familyEvents > 0) importedFamilies += 1;
-    importedEvents += familyEvents;
-  }
-  journal.recordQuarantinedFamilies(quarantined);
-  journal.markLegacyJournalImported();
-  return {
-    alreadyImported: false,
-    families: importedFamilies,
-    events: importedEvents,
-    quarantined
-  };
-}
-
-// src/chronicle/sqlite-journal.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs8 from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import * as path11 from "node:path";
-
-// src/utils/pid.ts
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  if (pid === process.pid) return true;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return true;
-    return false;
-  }
-}
-
-// src/chronicle/sqlite-query.ts
-var MAX_LIMIT = 1e4;
-function encodeCursor2(cursor) {
-  return Buffer.from(`${cursor.day}:${cursor.sequence}`, "utf8").toString("base64url");
-}
-function decodeCursor2(raw) {
-  if (!raw) return void 0;
-  try {
-    const [day, sequence] = Buffer.from(raw, "base64url").toString("utf8").split(":");
-    if (!day || sequence === void 0) return void 0;
-    const parsed = Number(sequence);
-    return Number.isSafeInteger(parsed) ? { day, sequence: parsed } : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function pushDown(query) {
-  const clauses = [];
-  const params = [];
-  const eq = (column, value) => {
-    if (value === void 0) return;
-    clauses.push(`${column} = ?`);
-    params.push(value);
-  };
-  eq("event_id", query.eventId);
-  eq("project_id", query.projectId);
-  eq("session_id", query.sessionId);
-  eq("agent_id", query.agentId);
-  eq("task_id", query.taskId);
-  eq("trace_id", query.traceId);
-  eq("logical_request_id", query.logicalRequestId);
-  eq("resource_kind", query.resourceKind);
-  eq("resource_id", query.resourceId);
-  if (query.eventTypes?.length) {
-    clauses.push(`event_type IN (${query.eventTypes.map(() => "?").join(",")})`);
-    params.push(...query.eventTypes);
-  }
-  if (query.outcomes?.length) {
-    clauses.push(`outcome IN (${query.outcomes.map(() => "?").join(",")})`);
-    params.push(...query.outcomes);
+    this.retainedEventCount = retainedCountAfterCommit;
   }
-  if (query.from) {
-    clauses.push("occurred_at >= ?");
-    params.push(query.from);
+  /**
+   * 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);
   }
-  if (query.to) {
-    clauses.push("occurred_at <= ?");
-    params.push(query.to);
+  /** Has the legacy JSONL import already run? */
+  hasImportedLegacyJournal() {
+    return this.readMeta(LEGACY_JSONL_MIGRATION_KEY) !== void 0;
   }
-  return { clause: clauses.length ? clauses.join(" AND ") : "1=1", params };
-}
-var ChronicleSqliteQueryEngine = class {
-  constructor(db, options = {}) {
-    this.db = db;
-    this.batchSize = Math.max(1, options.batchSize ?? 1e3);
+  markLegacyJournalImported() {
+    this.db.prepare(
+      `INSERT INTO chronicle_meta (key, value) VALUES (?, 'done')
+           ON CONFLICT(key) DO UPDATE SET value = 'done'`
+    ).run(LEGACY_JSONL_MIGRATION_KEY);
   }
-  db;
-  diagnostics = { sourceFiles: 1, invalidLines: 0 };
-  batchSize;
-  async query(query = {}) {
-    const order = query.order ?? "desc";
-    const limit = Math.max(1, Math.min(query.limit ?? 100, MAX_LIMIT));
-    const cursor = decodeCursor2(query.cursor);
-    const pushed = pushDown(query);
-    const direction = order === "asc" ? "ASC" : "DESC";
-    const comparison = order === "asc" ? ">" : "<";
-    const keyset = cursor ? ` AND (day, sequence) ${comparison} (?, ?)` : "";
-    const sql = `SELECT day, sequence, payload FROM events WHERE ${pushed.clause}${keyset} ORDER BY day ${direction}, sequence ${direction} LIMIT ? OFFSET ?`;
-    const summary = createSummaryAccumulator();
-    const page = [];
-    let total = 0;
-    let scannedEvents = 0;
-    let last;
-    let offset = 0;
-    for (; ; ) {
-      const params = [...pushed.params];
-      if (cursor) params.push(cursor.day, cursor.sequence);
-      params.push(this.batchSize, offset);
-      const rows = this.db.prepare(sql).all(...params);
-      if (rows.length === 0) break;
-      offset += rows.length;
-      for (const row of rows) {
-        scannedEvents++;
-        let event;
-        try {
-          event = JSON.parse(row.payload);
-        } catch {
-          this.diagnostics.invalidLines++;
-          continue;
-        }
-        if (!matches(event, query)) continue;
-        total++;
-        updateSummary(summary, event);
-        if (page.length < limit) {
-          page.push(event);
-          last = { day: row.day, sequence: row.sequence };
-        }
-      }
-      if (rows.length < this.batchSize) break;
-    }
-    page.sort((left, right) => compareEvents(left, right) * (order === "asc" ? 1 : -1));
-    const result = {
-      events: page,
-      total,
-      scannedEvents,
-      sourceFiles: this.diagnostics.sourceFiles,
-      invalidLines: this.diagnostics.invalidLines,
-      summary: finalizeSummary(summary)
-    };
-    if (total > page.length && last) {
-      return { ...result, nextCursor: encodeCursor2(last) };
-    }
-    return result;
+  /**
+   * 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(
+      `INSERT INTO chronicle_meta (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(LEGACY_JSONL_QUARANTINE_KEY, JSON.stringify(families));
   }
   /**
-   * Value counts per facet field.
+   * Does this day already hold rows?
    *
-   * Not a SQL `GROUP BY`: `facetValue()` reads fields that live inside the
-   * payload — provider, model, tool call, tag — so grouping in SQL would only
-   * work for the handful that happen to be columns and would need a second,
-   * divergent definition for the rest. The narrowing is still done by SQL; the
-   * counting uses the JSONL engine's own projection.
+   * 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.
    */
-  async facets(fields, query = {}, limit = 100) {
-    const uniqueFields = [...new Set(fields)];
-    if (uniqueFields.length === 0) return {};
-    const counts = new Map(uniqueFields.map((field) => [field, /* @__PURE__ */ new Map()]));
-    for (const event of this.eachMatch(query)) {
-      for (const field of uniqueFields) {
-        const value = facetValue(event, field);
-        if (value === void 0) continue;
-        const fieldCounts = counts.get(field);
-        fieldCounts?.set(value, (fieldCounts.get(value) ?? 0) + 1);
-      }
-    }
-    const result = {};
-    for (const field of uniqueFields) {
-      result[field] = [...counts.get(field) ?? /* @__PURE__ */ new Map()].map(([value, count]) => ({ value, count })).sort((left, right) => right.count - left.count || left.value.localeCompare(right.value)).slice(0, Math.max(0, limit));
+  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 [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
     }
-    return result;
   }
-  async facet(field, query = {}, limit = 100) {
-    return (await this.facets([field], query, limit))[field] ?? [];
+  // ─── internals ────────────────────────────────────────────────────────────
+  preparedStatements() {
+    this.statements ??= {
+      insert: this.db.prepare(
+        `INSERT INTO events (
+           day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
+           project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+           resource_kind, resource_id, resource_path, duration_ns, payload
+         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+      ),
+      trimBoundary: this.db.prepare(
+        "SELECT day, sequence, hash FROM events ORDER BY day, sequence LIMIT 1 OFFSET ?"
+      ),
+      writeCheckpoint: this.db.prepare(
+        `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
+         ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
+      ),
+      deletePrefix: this.db.prepare(
+        "DELETE FROM events WHERE day < ? OR (day = ? AND sequence <= ?)"
+      ),
+      deleteCheckpoints: this.db.prepare("DELETE FROM chain_checkpoint WHERE day < ?")
+    };
+    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;
+  }
+  readMeta(key) {
+    const row = this.db.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(key);
+    return row?.value;
+  }
+  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);
   }
   /**
-   * Expand explicit and typed correlation edges around a seed set.
-   *
-   * The traversal is the JSONL engine's, moved onto rows: `relationKeys()`
-   * defines the edges, `compareEvents` orders the nodes, and each hop is
-   * another ordered pass. Order is load-bearing rather than cosmetic — both
-   * `maxNodes` truncations stop at whatever they reach first, so a differently
-   * ordered scan would return a different subgraph rather than the same one
-   * shuffled. `ORDER BY day, sequence` reproduces `comparePartitionPaths`
-   * (family, then rotation index) followed by line order within a partition.
+   * 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.
    */
-  async graph(seed = {}, hops = 2, maxNodes = 1e3) {
-    const nodeLimit = Math.max(0, Math.floor(maxNodes));
-    const selected = /* @__PURE__ */ new Map();
-    let seedCount = 0;
-    for (const event of this.eachMatch(seed)) {
-      seedCount++;
-      if (selected.size < nodeLimit) selected.set(event.eventId, event);
-    }
-    let frontier = [...selected.values()];
-    const depthLimit = Math.max(0, Math.min(hops, 10));
-    for (let depth = 0; depth < depthLimit && frontier.length > 0 && selected.size < nodeLimit; depth++) {
-      const frontierKeys = new Set(
-        frontier.flatMap((event) => relationKeys(event).map((relation) => relation.key))
+  readAnchor(day) {
+    const cached = this.anchors.get(day);
+    if (cached) return cached;
+    const last = this.db.prepare("SELECT sequence, hash FROM events WHERE day = ? ORDER BY sequence DESC LIMIT 1").get(day);
+    const anchor = last ?? this.readCheckpoint(day) ?? { sequence: 0, hash: GENESIS_HASH };
+    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)
       );
-      const next = [];
-      for (const event of this.eachMatch({})) {
-        if (selected.has(event.eventId)) continue;
-        if (!relationKeys(event).some((relation) => frontierKeys.has(relation.key))) continue;
-        selected.set(event.eventId, event);
-        next.push(event);
-        if (selected.size >= nodeLimit) break;
-      }
-      frontier = next;
-    }
-    const nodes = [...selected.values()].sort(compareEvents);
-    const byKey = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      for (const relation of relationKeys(node)) {
-        const related = byKey.get(relation.key) ?? [];
-        related.push(node);
-        byKey.set(relation.key, related);
-      }
-    }
-    const edges = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const node of nodes) {
-      for (const relation of relationKeys(node)) {
-        for (const candidate of byKey.get(relation.key) ?? []) {
-          if (candidate.eventId === node.eventId) continue;
-          const [from, to] = compareEvents(node, candidate) <= 0 ? [node, candidate] : [candidate, node];
-          const id = `${from.eventId}:${to.eventId}:${relation.kind}`;
-          if (seen.has(id)) continue;
-          seen.add(id);
-          edges.push({
-            from: from.eventId,
-            to: to.eventId,
-            kind: relation.kind,
-            confidence: relation.confidence
-          });
-        }
-      }
+      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");
     }
-    return {
-      nodes,
-      edges,
-      truncated: seedCount > nodeLimit || selected.size >= nodeLimit
-    };
-  }
-  /** Every event satisfying `query`, pulled in batches so a wide scan stays bounded. */
-  *eachMatch(query) {
-    const pushed = pushDown(query);
-    const sql = `SELECT payload FROM events WHERE ${pushed.clause} ORDER BY day, sequence LIMIT ? OFFSET ?`;
-    let offset = 0;
-    for (; ; ) {
-      const rows = this.db.prepare(sql).all(...pushed.params, this.batchSize, offset);
-      if (rows.length === 0) return;
-      offset += rows.length;
-      for (const row of rows) {
-        let event;
-        try {
-          event = JSON.parse(row.payload);
-        } catch {
-          this.diagnostics.invalidLines++;
-          continue;
-        }
-        if (matches(event, query)) yield event;
-      }
-      if (rows.length < this.batchSize) return;
+    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/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_VERSION2 = 1;
-var SQLITE_FIXED_OVERHEAD_BYTES = 16 * 1024 * 1024;
-var MIN_SQLITE_PAGE_BUDGET_BYTES = 64 * 1024;
-var MAX_ROLLBACK_JOURNAL_RESERVE_BYTES = 64 * 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;
-  }
+// src/chronicle/metrics-store.ts
+var SCHEMA_VERSION2 = 3;
+var READ_CHUNK_BYTES = 1024 * 1024;
+var SQLITE_SOURCE_PREFIX = "sqlite:";
+var SQLITE_INGEST_BATCH = 2e3;
+var EMPTY_FAMILIES = {
+  llm: 0,
+  agent: 0,
+  tool: 0,
+  file: 0,
+  memory: 0,
+  task: 0,
+  decision: 0,
+  runtime: 0,
+  finding: 0
 };
 var Ctor2;
 function loadDatabaseSync2() {
@@ -3398,657 +3347,883 @@ function loadDatabaseSync2() {
   } catch (error) {
     Ctor2 = 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))
+      "Chronicle metrics need Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
     );
   }
 }
-var ChronicleSqliteJournal = class {
-  db;
-  dbPath;
-  now;
-  monotonicNow;
-  idFactory;
-  retentionDays;
-  maxEvents;
-  maxBytes;
-  retentionCheckIntervalMs;
-  nextRetentionCheckAt = 0;
-  retainedEventCount = 0;
-  /** Resolved lazily by `pageSizeBytes()`; constant for an open database. */
-  cachedPageSize;
-  /**
-   * Cached chain head per day. Cleared wholesale on any write failure so the
-   * next append rebuilds from the database rather than trusting a counter that
-   * may have advanced past what actually committed.
-   */
-  anchors = /* @__PURE__ */ new Map();
-  counters = {
-    acceptedEvents: 0,
-    persistedEvents: 0,
-    rejectedEvents: 0,
-    failedEvents: 0,
-    batches: 0,
-    maxObservedPending: 0,
-    largestBatch: 0
-  };
-  lastBatchDurationMs;
-  constructor(options) {
-    this.dbPath = path11.join(path11.resolve(options.directory), CHRONICLE_SQLITE_FILE);
-    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-    this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
-    this.idFactory = options.idFactory ?? (() => randomUUID3());
-    if (options.retentionDays !== void 0 && (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0)) {
-      throw new RangeError("retentionDays must be a positive finite number");
-    }
-    if (options.retentionCheckIntervalMs !== void 0 && (!Number.isFinite(options.retentionCheckIntervalMs) || options.retentionCheckIntervalMs <= 0)) {
-      throw new RangeError("retentionCheckIntervalMs must be a positive finite number");
-    }
-    if (options.maxEvents !== void 0 && (!Number.isInteger(options.maxEvents) || options.maxEvents < 1)) {
-      throw new RangeError("maxEvents must be a positive integer");
-    }
-    if (options.maxBytes !== void 0 && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1)) {
-      throw new RangeError("maxBytes must be a positive safe integer");
-    }
-    const minimumQuotaBytes = SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES;
-    if (options.maxBytes !== void 0 && options.maxBytes < minimumQuotaBytes) {
-      throw new RangeError(`maxBytes must be at least ${minimumQuotaBytes}`);
-    }
-    this.retentionDays = options.retentionDays;
-    this.maxEvents = options.maxEvents;
-    this.maxBytes = options.maxBytes;
-    this.retentionCheckIntervalMs = options.retentionCheckIntervalMs ?? 60 * 60 * 1e3;
+function isChronicleMetricsAvailable() {
+  try {
+    loadDatabaseSync2();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ChronicleMetricsStore = class _ChronicleMetricsStore {
+  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 = ${this.maxBytes === void 0 ? "WAL" : "DELETE"}`);
+    this.db.exec("PRAGMA journal_mode = WAL");
     this.ensureSchema();
-    this.configureByteQuota();
-    if (this.maxEvents !== void 0) {
-      const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
-      this.retainedEventCount = row.count;
-      this.enforceEventLimitAtStartup();
-    }
+  }
+  static open(chronicleDirectory) {
+    return new _ChronicleMetricsStore(chronicleDirectory);
   }
   close() {
     this.db.close();
   }
-  stats() {
-    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 } : {}
+  /** 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,
+      ingestedBytes: 0,
+      sourceFiles: 0,
+      invalidLines: 0
     };
+    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++;
+      }
+      this.pruneOffsets(files);
+      this.ingestSqliteJournal(offsets, result);
+    });
+    return result;
   }
-  /**
-   * Writes are synchronous and transactional, so there is nothing buffered to
-   * flush. Kept to satisfy `ChronicleEventSink`.
-   */
-  async flush() {
-    return Promise.resolve();
+  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)
+    }));
   }
-  async append(input) {
-    const [event] = await this.appendBatch([input]);
-    return event;
+  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)
+    }));
   }
-  /**
-   * 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();
-    this.counters.acceptedEvents += inputs.length;
-    this.counters.batches += 1;
-    this.counters.largestBatch = Math.max(this.counters.largestBatch, inputs.length);
-    const instant = this.now().toISOString();
-    const day = instant.slice(0, 10);
-    const events = [];
-    let previous = this.readAnchor(day);
-    for (const input of inputs) {
-      const unhashed = {
-        ...input,
-        occurredAt: input.occurredAt ?? instant,
-        monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
-        schemaVersion: CHRONICLE_SCHEMA_VERSION,
-        eventId: this.idFactory(),
-        observedAt: instant,
-        persistedAt: instant,
-        sequence: previous.sequence + 1,
-        previousHash: previous.hash
-      };
-      const event = { ...unhashed, hash: hashValue(unhashed) };
-      events.push(event);
-      previous = { sequence: event.sequence, hash: event.hash };
+  fileLineage(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.path) {
+      clauses.push("path_key = ?");
+      params.push(normalizePathKey(options.path));
     }
-    let retainedCountAfterCommit = this.retainedEventCount;
-    try {
-      this.db.exec("BEGIN IMMEDIATE");
-      this.assertWithinByteQuota(events);
-      const insert = this.db.prepare(
-        `INSERT INTO events (
-           day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-           project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
-           resource_kind, resource_id, resource_path, duration_ns, payload
-         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
-      );
-      for (const event of events) {
-        const row = projectEvent(event);
-        insert.run(
-          day,
-          event.sequence,
-          event.eventId,
-          event.hash,
-          event.previousHash,
-          row.occurredAt,
-          event.eventType,
-          row.outcome,
-          row.projectId,
-          row.sessionId,
-          row.agentId,
-          row.taskId,
-          row.traceId,
-          row.logicalRequestId,
-          row.resourceKind,
-          row.resourceId,
-          row.resourcePath,
-          row.durationNs,
-          JSON.stringify(event)
-        );
-      }
-      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction();
-      this.assertActualAllocationWithinQuota();
-      this.db.exec("COMMIT");
-    } catch (error) {
-      try {
-        this.db.exec("ROLLBACK");
-      } catch {
-      }
-      this.anchors.clear();
-      this.counters.failedEvents += inputs.length;
-      this.lastBatchDurationMs = performance.now() - started;
-      throw this.normalizeQuotaError(error);
+    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);
     }
-    this.anchors.set(day, previous);
-    this.counters.persistedEvents += events.length;
-    this.retainedEventCount = retainedCountAfterCommit;
-    this.lastBatchDurationMs = performance.now() - started;
-    await this.enforceRetentionIfDue();
-    return events;
+    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
+    }));
   }
-  async readAll() {
-    const rows = this.db.prepare("SELECT payload FROM events ORDER BY day, sequence").all();
-    return rows.map((row) => JSON.parse(row.payload));
+  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)
+    };
   }
   /**
-   * 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.
+   * 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.
    */
-  async verify() {
-    let entries = 0;
-    let lastSequence = 0;
-    let lastHash = GENESIS_HASH;
-    for (const day of this.days()) {
-      const checkpoint = this.readCheckpoint(day);
-      let expectedSequence = (checkpoint?.sequence ?? 0) + 1;
-      let previousHash = checkpoint?.hash ?? GENESIS_HASH;
-      const rows = this.db.prepare(
-        "SELECT sequence, hash, previous_hash, payload FROM events WHERE day = ? ORDER BY sequence"
-      ).all(day);
-      for (const row of rows) {
-        if (row.sequence !== expectedSequence) {
-          return {
-            ok: false,
-            entries,
-            brokenAt: entries,
-            reason: `sequence gap in ${day}: expected ${expectedSequence}, found ${row.sequence}`
-          };
-        }
-        if (row.previous_hash !== previousHash) {
-          return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
-        }
-        let event;
-        try {
-          event = JSON.parse(row.payload);
-        } catch {
-          return { ok: false, entries, brokenAt: entries, reason: "invalid payload JSON" };
-        }
-        if (chronicleEventHash(event) !== row.hash) {
-          return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
-        }
-        entries += 1;
-        expectedSequence = row.sequence + 1;
-        previousHash = row.hash;
+  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);
       }
-      lastSequence = expectedSequence - 1;
-      lastHash = previousHash;
-    }
-    return { ok: true, entries, lastSequence, lastHash };
-  }
-  async enforceRetentionIfDue() {
-    if (this.retentionDays === void 0) return;
-    const now = this.now();
-    if (now.getTime() < this.nextRetentionCheckAt) return;
-    this.nextRetentionCheckAt = now.getTime() + this.retentionCheckIntervalMs;
-    try {
-      await this.purge({ retentionDays: this.retentionDays });
-    } catch {
+      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
+    };
   }
-  configureByteQuota() {
-    if (this.maxBytes === void 0) {
-      this.db.exec("PRAGMA max_page_count = 2147483646");
-      return;
+  // ─── 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;"
+      );
     }
-    const halfSplit = Math.floor((this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES) / 2);
-    const journalReserve = Math.min(MAX_ROLLBACK_JOURNAL_RESERVE_BYTES, halfSplit);
-    const mainBudget = this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES - journalReserve;
-    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}`
+    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
       );
-    }
-    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 += fs8.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
+      -- 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
       );
-    }
-    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
-    });
-  }
-  assertActualAllocationWithinQuota() {
-    if (this.maxBytes === void 0) return;
-    const currentBytes = this.aggregateLiveBytes();
-    if (currentBytes <= this.maxBytes) return;
-    throw new ChronicleStorageQuotaError({
-      currentBytes,
-      batchBytes: 0,
-      maxBytes: this.maxBytes,
-      path: this.dbPath
-    });
-  }
-  assertWithinByteQuota(events) {
-    if (this.maxBytes === void 0) return;
-    const currentBytes = this.aggregateLiveBytes();
-    const batchBytes = Buffer.byteLength(JSON.stringify(events), "utf8");
-    if (currentBytes + batchBytes <= this.maxBytes) return;
-    throw new ChronicleStorageQuotaError({
-      currentBytes,
-      batchBytes,
-      maxBytes: this.maxBytes,
-      path: this.dbPath
-    });
+      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};
+    `);
   }
-  enforceEventLimitWithinTransaction() {
-    const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
-    if (this.maxEvents === void 0 || row.count <= this.maxEvents) return row.count;
-    const excess = row.count - this.maxEvents;
-    const boundary = this.db.prepare("SELECT day, sequence, hash FROM events ORDER BY day, sequence LIMIT 1 OFFSET ?").get(excess - 1);
-    if (!boundary) return row.count;
-    this.db.prepare(
-      `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
-         ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
-    ).run(boundary.day, boundary.sequence, boundary.hash);
-    this.db.prepare("DELETE FROM events WHERE day < ? OR (day = ? AND sequence <= ?)").run(boundary.day, boundary.day, boundary.sequence);
-    this.db.prepare("DELETE FROM chain_checkpoint WHERE day < ?").run(boundary.day);
-    this.anchors.clear();
-    return this.maxEvents;
+  loadOffsets() {
+    const rows = this.db.prepare("SELECT file, bytes FROM ingest_state").all();
+    return new Map(rows.map((row) => [row.file, Number(row.bytes)]));
   }
-  enforceEventLimitAtStartup() {
-    if (this.maxEvents === void 0 || this.retainedEventCount <= this.maxEvents) return;
-    try {
-      this.db.exec("BEGIN IMMEDIATE");
-      const retainedCount = this.enforceEventLimitWithinTransaction();
-      this.db.exec("COMMIT");
-      this.retainedEventCount = retainedCount;
-    } catch (error) {
-      try {
-        this.db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
+  pruneOffsets(existingFiles) {
+    const keep = new Set(
+      existingFiles.map((file) => normalizeKey(path10.relative(this.directory, file)))
+    );
+    for (const row of this.db.prepare("SELECT file FROM ingest_state").all()) {
+      if (row.file.startsWith(SQLITE_SOURCE_PREFIX)) continue;
+      if (!keep.has(row.file))
+        this.db.prepare("DELETE FROM ingest_state WHERE file = ?").run(row.file);
     }
   }
   /**
-   * Drop events older than the retention window.
+   * Fold everything the SQLite journal holds past this store's per-day cursor.
    *
-   * 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.
+   * 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.
    */
-  async purge(options) {
-    const empty = {
-      deletedCount: 0,
-      deletedBytes: 0,
-      skippedCount: 0,
-      errors: []
-    };
-    if (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0) return empty;
-    const cutoff = new Date(this.now().getTime() - options.retentionDays * 864e5).toISOString().slice(0, 10);
-    const count = this.db.prepare("SELECT COUNT(*) AS n FROM events WHERE day < ?").get(cutoff).n;
-    if (count === 0) return empty;
-    if (options.dryRun) {
-      const days = this.db.prepare("SELECT DISTINCT day FROM events WHERE day < ? ORDER BY day").all(cutoff);
-      return { ...empty, deletedCount: count, candidates: days.map((row) => row.day) };
-    }
+  ingestSqliteJournal(offsets, result) {
+    const journalPath = path10.join(this.directory, CHRONICLE_SQLITE_FILE);
+    let source;
     try {
-      this.db.exec("BEGIN IMMEDIATE");
-      this.db.prepare("DELETE FROM events WHERE day < ?").run(cutoff);
-      this.db.prepare("DELETE FROM chain_checkpoint WHERE day < ?").run(cutoff);
-      this.db.exec("COMMIT");
-    } catch (error) {
-      try {
-        this.db.exec("ROLLBACK");
-      } catch {
-      }
-      return {
-        ...empty,
-        errors: [
-          {
-            file: this.dbPath,
-            reason: error instanceof Error ? error.message : String(error)
-          }
-        ]
-      };
+      source = new (loadDatabaseSync2())(journalPath, { readOnly: true });
+    } catch {
+      return;
     }
-    this.anchors.clear();
-    this.retainedEventCount = Math.max(0, this.retainedEventCount - count);
-    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 (
-         day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-         project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
-         resource_kind, resource_id, resource_path, duration_ns, payload
-       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
-    );
-    const checkpoint = this.db.prepare(
-      `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
-         ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
-    );
-    this.db.exec("BEGIN IMMEDIATE");
-    let retainedCountAfterCommit = this.retainedEventCount;
     try {
-      this.assertWithinByteQuota([]);
-      await load({
-        insert: (day, event) => {
-          const row = projectEvent(event);
-          insert.run(
-            day,
-            event.sequence,
-            event.eventId,
-            event.hash,
-            event.previousHash,
-            row.occurredAt,
-            event.eventType,
-            row.outcome,
-            row.projectId,
-            row.sessionId,
-            row.agentId,
-            row.taskId,
-            row.traceId,
-            row.logicalRequestId,
-            row.resourceKind,
-            row.resourceId,
-            row.resourcePath,
-            row.durationNs,
-            JSON.stringify(event)
-          );
-        },
-        checkpoint: (day, sequence, hash3) => {
-          checkpoint.run(day, sequence, hash3);
+      const days = source.prepare("SELECT DISTINCT day FROM events ORDER BY day").all();
+      const read = source.prepare(
+        "SELECT sequence, payload FROM events WHERE day = ? AND sequence > ? ORDER BY sequence LIMIT ?"
+      );
+      const writeCursor = this.db.prepare(
+        "INSERT INTO ingest_state (file, bytes) VALUES (?, ?) ON CONFLICT(file) DO UPDATE SET bytes = excluded.bytes"
+      );
+      for (const { day } of days) {
+        const key = `${SQLITE_SOURCE_PREFIX}${day}`;
+        const from = offsets.get(key) ?? 0;
+        let cursor = from;
+        this.db.exec("BEGIN");
+        try {
+          for (; ; ) {
+            const rows = read.all(day, cursor, SQLITE_INGEST_BATCH);
+            if (rows.length === 0) break;
+            for (const row of rows) {
+              try {
+                this.ingestEvent(JSON.parse(row.payload));
+                result.ingestedEvents++;
+              } catch {
+                result.invalidLines++;
+              }
+              result.ingestedBytes += row.payload.length;
+              cursor = Number(row.sequence);
+            }
+            if (rows.length < SQLITE_INGEST_BATCH) break;
+          }
+          if (cursor > from) writeCursor.run(key, cursor);
+          this.db.exec("COMMIT");
+        } catch (error) {
+          this.db.exec("ROLLBACK");
+          throw error;
         }
-      });
-      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction();
-      this.assertActualAllocationWithinQuota();
-      this.db.exec("COMMIT");
-    } catch (error) {
+        if (cursor > from) result.sourceFiles++;
+      }
+    } catch {
+    } finally {
+      source.close();
+    }
+  }
+  /** 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 {
+      handle = await fs7.open(file, "r");
+    } catch {
+      return false;
+    }
+    try {
+      const size = (await handle.stat()).size;
+      if (size <= consumed) return false;
+      let position = consumed;
+      let remainder = Buffer.alloc(0);
+      let advanced = consumed;
+      this.db.exec("BEGIN");
       try {
+        while (position < size) {
+          const length = Math.min(READ_CHUNK_BYTES, size - position);
+          const buffer = Buffer.allocUnsafe(length);
+          const { bytesRead } = await handle.read(buffer, 0, length, position);
+          if (bytesRead <= 0) break;
+          position += bytesRead;
+          const data = remainder.length > 0 ? Buffer.concat([remainder, buffer.subarray(0, bytesRead)]) : buffer.subarray(0, bytesRead);
+          const lastNewline = data.lastIndexOf(10);
+          if (lastNewline < 0) {
+            remainder = Buffer.from(data);
+            continue;
+          }
+          for (const line of data.subarray(0, lastNewline).toString("utf8").split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+              this.ingestEvent(JSON.parse(trimmed));
+              result.ingestedEvents++;
+            } catch {
+              result.invalidLines++;
+            }
+          }
+          advanced += lastNewline + 1;
+          remainder = Buffer.from(data.subarray(lastNewline + 1));
+        }
+        this.db.prepare(
+          "INSERT INTO ingest_state (file, bytes) VALUES (?, ?) ON CONFLICT(file) DO UPDATE SET bytes = excluded.bytes"
+        ).run(key, advanced);
+        this.db.exec("COMMIT");
+      } catch (error) {
         this.db.exec("ROLLBACK");
-      } catch {
+        throw error;
       }
-      throw this.normalizeQuotaError(error);
+      result.ingestedBytes += advanced - consumed;
+      return advanced > consumed;
     } finally {
-      this.anchors.clear();
+      await handle.close();
     }
-    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;
+  ingestEvent(event) {
+    if (typeof event?.eventType !== "string" || !event.scope) return;
+    this.ingestDailyCounters(event);
+    const type = event.eventType;
+    if (type.startsWith("provider.attempt.") || type === "provider.fallback") {
+      this.ingestProvider(event);
+    } else if (type === "token.accounted") {
+      this.ingestTokenCost(event);
+    } else if (/^(?:sdd|subagent|kanban)\.task[._]/.test(type)) {
+      this.ingestTask(event);
+    } else if (type === "file.event" || /^file\.(?:tool|external)\./.test(type)) {
+      this.ingestFileEvent(event);
+    }
   }
-  markLegacyJournalImported() {
+  /** 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);
+    const bump = (sql, ...params) => this.db.prepare(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
+    const family = signalFamily(event);
+    const failed = isTerminalFailure(event) ? 1 : 0;
     this.db.prepare(
-      `INSERT INTO chronicle_meta (key, value) VALUES (?, 'done')
-           ON CONFLICT(key) DO UPDATE SET value = 'done'`
-    ).run(LEGACY_JSONL_MIGRATION_KEY);
+      `INSERT INTO family_daily (day, family, count, failure_count) VALUES (?, ?, 1, ?)
+       ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
+    ).run(day, family, failed);
+    if (failed) bump("failures = failures + 1");
+    if (event.outcome === "cancelled" || event.outcome === "abandoned") bump("cancellations = cancellations + 1");
+    if (family === "agent") bump("agent_events = agent_events + 1");
+    if (event.correlation.logicalRequestId) {
+      this.db.prepare("INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)").run(day, event.correlation.logicalRequestId);
+    }
+    if (event.scope.agentId) {
+      this.db.prepare("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(day, event.scope.agentId);
+    }
+    const type = event.eventType;
+    if (type === "decision.requested") bump("decisions = decisions + 1");
+    else if (type === "decision.escalated") bump("escalations = escalations + 1");
+    else if (type === "tool.started") bump("tool_calls = tool_calls + 1");
+    else if (type === "tool.executed" || type === "tool.failed") {
+      const dur = durationMs2(event);
+      const durationCount = dur > 0 ? 1 : 0;
+      bump(
+        `${type === "tool.executed" ? "completed_tools" : "failed_tools"} = ${type === "tool.executed" ? "completed_tools" : "failed_tools"} + 1,
+         tool_duration_ms_total = tool_duration_ms_total + ?, tool_duration_ms_max = MAX(tool_duration_ms_max, ?), tool_duration_count = tool_duration_count + ?`,
+        dur,
+        dur,
+        durationCount
+      );
+    } else if (type === "process.started") bump("processes = processes + 1");
+    else if (type === "process.completed" && event.outcome === "failure") bump("failed_processes = failed_processes + 1");
+    if (event.resource?.kind === "file" || type.startsWith("file.")) {
+      bump("file_events_all = file_events_all + 1");
+      if (event.resource?.path) {
+        this.db.prepare("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(day, normalizePathKey(event.resource.path));
+      }
+    }
   }
-  /**
-   * 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(
-      `INSERT INTO chronicle_meta (key, value) VALUES (?, ?)
-           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-    ).run(LEGACY_JSONL_QUARANTINE_KEY, JSON.stringify(families));
+  ingestProvider(event) {
+    const day = eventDay(event);
+    const providerId = event.runtime?.providerId ?? asString(readPath2(event.attributes ?? {}, "from.providerId")) ?? "";
+    const modelId = event.runtime?.modelId ?? asString(readPath2(event.attributes ?? {}, "from.model")) ?? "";
+    if (!providerId && !modelId) return;
+    this.db.prepare("INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)").run(day, providerId, modelId);
+    const update = (sql, ...params) => this.db.prepare(
+      `UPDATE provider_daily SET ${sql} WHERE day = ? AND provider_id = ? AND model_id = ?`
+    ).run(...params, day, providerId, modelId);
+    const duration = durationMs2(event);
+    switch (event.eventType) {
+      case "provider.attempt.started":
+        update("attempts = attempts + 1");
+        break;
+      case "provider.attempt.completed":
+        update(
+          "completed = completed + 1, input_tokens = input_tokens + ?, output_tokens = output_tokens + ?, cache_read_tokens = cache_read_tokens + ?, cache_write_tokens = cache_write_tokens + ?, duration_ms_total = duration_ms_total + ?, duration_ms_max = MAX(duration_ms_max, ?), duration_count = duration_count + ?",
+          numberAt2(event, "usage.input"),
+          numberAt2(event, "usage.output"),
+          numberAt2(event, "usage.cacheRead"),
+          numberAt2(event, "usage.cacheWrite"),
+          duration,
+          duration,
+          duration > 0 ? 1 : 0
+        );
+        break;
+      case "provider.attempt.failed":
+        update(
+          "failed = failed + 1, retries = retries + ?, duration_ms_total = duration_ms_total + ?, duration_ms_max = MAX(duration_ms_max, ?), duration_count = duration_count + ?",
+          event.attributes?.retryScheduled === true ? 1 : 0,
+          duration,
+          duration,
+          duration > 0 ? 1 : 0
+        );
+        break;
+      case "provider.fallback":
+        update("fallbacks = fallbacks + 1");
+        break;
+      default:
+        break;
+    }
   }
-  /**
-   * 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.
-   */
-  hasImportedDay(day) {
-    const row = this.db.prepare("SELECT 1 AS present FROM events WHERE day = ? LIMIT 1").get(day);
-    return row !== void 0;
+  ingestTokenCost(event) {
+    const cost = readPath2(event.attributes ?? {}, "cost.total");
+    if (typeof cost !== "number" || !Number.isFinite(cost)) return;
+    const scopeKey2 = `${event.scope.projectId ?? ""}\0${event.scope.sessionId ?? ""}\0${event.scope.agentId ?? ""}`;
+    const occurredAt = event.occurredAt ?? event.observedAt;
+    this.db.prepare(
+      `INSERT INTO token_cost (scope_key, day, occurred_at, sequence, cost) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(scope_key) DO UPDATE SET
+         day = excluded.day, occurred_at = excluded.occurred_at,
+         sequence = excluded.sequence, cost = excluded.cost
+       WHERE excluded.occurred_at > token_cost.occurred_at
+          OR (excluded.occurred_at = token_cost.occurred_at AND excluded.sequence > token_cost.sequence)`
+    ).run(scopeKey2, eventDay(event), occurredAt, event.sequence, cost);
   }
-  /** Day families the legacy import refused to move, oldest first. */
-  quarantinedFamilies() {
-    const raw = this.readMeta(LEGACY_JSONL_QUARANTINE_KEY);
-    if (!raw) return [];
-    try {
-      const parsed = JSON.parse(raw);
-      return Array.isArray(parsed) ? parsed : [];
-    } catch {
-      return [];
+  ingestTask(event) {
+    const attributes = event.attributes ?? {};
+    const taskId = event.scope.taskId ?? stringAt(attributes, "taskId");
+    if (!taskId) return;
+    const occurredAt = event.occurredAt ?? event.observedAt;
+    this.db.prepare("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
+    const set = (sql, ...params) => this.db.prepare(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
+    const lineage = [
+      ["run_id", stringAt(attributes, "runId")],
+      ["board_id", event.scope.kanbanBoardId ?? stringAt(attributes, "boardId")],
+      ["session_id", event.scope.sessionId],
+      ["agent_id", event.scope.agentId ?? stringAt(attributes, "subagentId")]
+    ];
+    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;
     }
   }
-  // ─── internals ────────────────────────────────────────────────────────────
-  readMeta(key) {
-    const row = this.db.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(key);
-    return row?.value;
+  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")
+    );
   }
-  readCheckpoint(day) {
-    return this.db.prepare("SELECT sequence, hash FROM chain_checkpoint WHERE day = ?").get(day);
+};
+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";
+var ChronicleImportError = class extends Error {
+  constructor(message, day, sequence) {
+    super(message);
+    this.day = day;
+    this.sequence = sequence;
+    this.name = "ChronicleImportError";
   }
-  /** 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);
+  day;
+  sequence;
+};
+async function discoverFamilies(directory) {
+  let entries;
+  try {
+    entries = await fs8.readdir(directory);
+  } catch {
+    return [];
   }
-  /**
-   * 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;
-    const last = this.db.prepare("SELECT sequence, hash FROM events WHERE day = ? ORDER BY sequence DESC LIMIT 1").get(day);
-    const anchor = last ?? this.readCheckpoint(day) ?? { sequence: 0, hash: GENESIS_HASH };
-    this.anchors.set(day, anchor);
-    return anchor;
+  const bases = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const match = PARTITION_FILE_PATTERN.exec(entry);
+    if (match?.[1]) bases.add(match[1]);
   }
-  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 INDEX IF NOT EXISTS events_resource_path ON events(resource_path);
-
-      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 !== SCHEMA_VERSION2) {
-      this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION2}`);
+  return [...bases].sort();
+}
+function dayOfFamily(familyBase) {
+  return familyBase.replace(/\.events$/u, "");
+}
+async function importLegacyChronicleJournal(journal, directory) {
+  if (journal.hasImportedLegacyJournal()) {
+    return {
+      alreadyImported: true,
+      families: 0,
+      events: 0,
+      quarantined: journal.quarantinedFamilies()
+    };
+  }
+  const families = await discoverFamilies(directory);
+  const quarantined = [];
+  let importedEvents = 0;
+  let importedFamilies = 0;
+  for (const familyBase of families) {
+    const day = dayOfFamily(familyBase);
+    const basePath = path11.join(directory, `${familyBase}.jsonl`);
+    let familyEvents = 0;
+    if (journal.hasImportedDay(day)) continue;
+    try {
+      await journal.runFamilyImport(async (sink) => {
+        familyEvents = 0;
+        const checkpointResult = await readRetentionCheckpoint(basePath);
+        if (checkpointResult.error) {
+          throw new ChronicleImportError(checkpointResult.error, day, 0);
+        }
+        const checkpoint = checkpointResult.checkpoint;
+        if (checkpoint) sink.checkpoint(day, checkpoint.sequence, checkpoint.hash);
+        let expectedSequence = (checkpoint?.sequence ?? 0) + 1;
+        let previousHash = checkpoint?.hash ?? GENESIS_HASH;
+        for (const partition of await collectPartitions(basePath)) {
+          for await (const event of streamEntriesStrict(partition)) {
+            if (event.sequence !== expectedSequence) {
+              throw new ChronicleImportError(
+                `sequence gap in ${day}: expected ${expectedSequence}, found ${event.sequence}`,
+                day,
+                event.sequence
+              );
+            }
+            if (event.previousHash !== previousHash) {
+              throw new ChronicleImportError(
+                `previous hash mismatch in ${day} at sequence ${event.sequence}`,
+                day,
+                event.sequence
+              );
+            }
+            if (chronicleEventHash(event) !== event.hash) {
+              throw new ChronicleImportError(
+                `entry hash mismatch in ${day} at sequence ${event.sequence}`,
+                day,
+                event.sequence
+              );
+            }
+            sink.insert(day, event);
+            familyEvents += 1;
+            expectedSequence = event.sequence + 1;
+            previousHash = event.hash;
+          }
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof ChronicleImportError)) throw error;
+      quarantined.push({ day, sequence: error.sequence, reason: error.message });
+      continue;
     }
+    if (familyEvents > 0) importedFamilies += 1;
+    importedEvents += familyEvents;
   }
-};
-function projectEvent(event) {
-  const occurredAt = event.occurredAt ?? event.observedAt;
+  journal.recordQuarantinedFamilies(quarantined);
+  journal.markLegacyJournalImported();
   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
+    alreadyImported: false,
+    families: importedFamilies,
+    events: importedEvents,
+    quarantined
   };
 }
 
@@ -4067,6 +4242,7 @@ import * as path12 from "node:path";
 // src/chronicle/project-server-protocol.ts
 var CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION = 2;
 var CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS = 64 * 1024 * 1024;
+var CHRONICLE_MAX_APPEND_BATCH = 1e4;
 function encodeChronicleProjectServerMessage(message) {
   return `${JSON.stringify(message)}
 `;
@@ -4498,7 +4674,7 @@ var ChronicleRemoteJournal = class {
       this.timer = void 0;
     }
     if (this.pending.length === 0) return;
-    const batch = this.pending.splice(0);
+    const batch = this.pending.splice(0, CHRONICLE_MAX_APPEND_BATCH);
     const started = performance.now();
     this.counters.batches++;
     this.counters.largestBatch = Math.max(this.counters.largestBatch, batch.length);
@@ -5298,7 +5474,17 @@ var SPECIALIZED_RE = /^(?:provider\.attempt\.|tool\.|process\.|brain\.decision_|
 var CODING_SIGNAL_RE = /^(?:(?:agent|subagent|delegate|fleet|session|iteration|context|compaction|checkpoint|in_flight|memory|storage|trust|sdd|worktree|kanban|brain|token|budget|concurrency|provider|mcp|network)\.|file\.event$|error$)/;
 var SENSITIVE_KEY = /(content|text|prompt|question|rationale|reason|detail|summary|description|context|input|output|error|message|secret|token|password|key)$/i;
 var PRESERVE_STRING_KEY = /(^|_)(id|status|state|kind|type|source|model|provider|phase|risk|fallback|path|name|role|sha|branch|mode)$/i;
-var TRUNCATED_ARRAYS = /* @__PURE__ */ new Set(["recentMail", "recentTools", "recentCommands", "activated", "injected"]);
+var TRUNCATED_ARRAYS = /* @__PURE__ */ new Set([
+  "recentMail",
+  "recentTools",
+  "recentCommands",
+  "activated",
+  "injected",
+  // SAGE per-memory rejection evidence — same cap (5) as activated/injected
+  // so the journal stays bounded under burst conditions. Each entry is
+  // ~120 bytes serialized; cap × entry-count = ~600B per injector_run.
+  "rejectedDetail"
+]);
 var TRUNCATED_ARRAY_MAX = 5;
 var DEFAULT_ARRAY_MAX = 20;
 function wireDomainEventsToChronicle(options) {
@@ -5829,9 +6015,11 @@ function aggregateSeverities(findings) {
 // src/chronicle/rollup-adapter.ts
 import { createHash as createHash14 } from "node:crypto";
 var MAX_ROLLUP_RESOURCES = 100;
+var DEFAULT_GAUGE_WINDOW_MS = 12e4;
 function wireRollupsToChronicle(options) {
   const buckets = /* @__PURE__ */ new Map();
   const windowMs = Math.max(1e3, options.windowMs ?? 1e4);
+  const gaugeWindowMs = Math.max(windowMs, options.gaugeWindowMs ?? DEFAULT_GAUGE_WINDOW_MS);
   const bucket = (key, seed) => {
     let value = buckets.get(key);
     if (!value) {
@@ -5893,7 +6081,7 @@ function wireRollupsToChronicle(options) {
     const sessionId = text(event.sessionId);
     const dimensionValue = dimension ? text(event[dimension]) : void 0;
     const key = `${signal}\0${sessionId ?? ""}\0${dimensionValue ?? ""}`;
-    const target = bucket(key, { signal, ...sessionId ? { sessionId } : {}, ...dimensionValue ? { agentId: dimensionValue } : {}, dimensions: dimensionValue && dimension ? { [dimension]: dimensionValue } : {} });
+    const target = bucket(key, { signal, aggregateMs: gaugeWindowMs, ...sessionId ? { sessionId } : {}, ...dimensionValue ? { agentId: dimensionValue } : {}, dimensions: dimensionValue && dimension ? { [dimension]: dimensionValue } : {} });
     sample(target, Object.fromEntries(Object.entries(event).filter(([, value]) => typeof value === "number")));
   };
   const offs = [
@@ -5952,7 +6140,7 @@ function wireRollupsToChronicle(options) {
     // helper can't be reused directly — flatten before sampling).
     options.events.on("runtime.health.sampled", (event) => {
       const key = `runtime.health\0${event.sessionId ?? ""}`;
-      const target = bucket(key, { signal: "runtime.health", ...event.sessionId ? { sessionId: event.sessionId } : {}, dimensions: {} });
+      const target = bucket(key, { signal: "runtime.health", aggregateMs: gaugeWindowMs, ...event.sessionId ? { sessionId: event.sessionId } : {}, dimensions: {} });
       const chronicle = event.chronicle;
       sample(target, {
         "eventLoop.utilization": event.eventLoop.utilization,
@@ -5973,7 +6161,7 @@ function wireRollupsToChronicle(options) {
     // from the domain adapter. Sums preserve the fleet-level metric trail.
     options.events.on("session.agents_updated", (event) => {
       const key = `session.agents\0${event.sessionId ?? ""}`;
-      const target = bucket(key, { signal: "session.agents", ...event.sessionId ? { sessionId: event.sessionId } : {}, dimensions: {} });
+      const target = bucket(key, { signal: "session.agents", aggregateMs: gaugeWindowMs, ...event.sessionId ? { sessionId: event.sessionId } : {}, dimensions: {} });
       const sums = { agents: 0, running: 0, iterations: 0, toolCalls: 0, costUsd: 0, tokensIn: 0, tokensOut: 0 };
       for (const agent of event.agents) {
         sums.agents++;
@@ -6004,8 +6192,11 @@ function wireRollupsToChronicle(options) {
     })
   ];
   const timer = setInterval(() => {
-    const cutoff = Date.now() - windowMs;
-    for (const [key, value] of buckets) if (value.updatedAt <= cutoff) flush(key);
+    const now = Date.now();
+    for (const [key, value] of buckets) {
+      const due = value.aggregateMs === void 0 ? value.updatedAt <= now - windowMs : value.startedAt <= now - value.aggregateMs;
+      if (due) flush(key);
+    }
   }, windowMs);
   timer.unref?.();
   return () => {