@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-AT4V4XGI.js

@@ -0,0 +1,3522 @@
+import {
+  SECRET_FILE_MODE
+} from "./chunk-H5E77KUJ.js";
+import {
+  withSqliteExperimentalWarningSuppressed
+} from "./chunk-LX5QWLBL.js";
+import {
+  atomicWrite,
+  withFileLock
+} from "./chunk-7ZHZE5EO.js";
+
+// src/chronicle/identity.ts
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+function resolveChronicleRuntimeLocation(input) {
+  const day = (input.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return {
+    installationId: stableId("installation", path.resolve(input.globalRoot)),
+    machineId: stableId("machine", `${os.hostname()}\0${os.platform()}\0${os.arch()}`),
+    projectId: input.projectId,
+    chronicleDirectory: path.join(input.projectDir, "chronicle"),
+    day
+  };
+}
+function stableId(prefix, value) {
+  return `${prefix}_${createHash("sha256").update(value).digest("hex").slice(0, 24)}`;
+}
+
+// src/chronicle/event-hash.ts
+import { createHash as createHash2 } from "node:crypto";
+var GENESIS_HASH = "0".repeat(64);
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => item === void 0 ? "null" : stableStringify(item)).join(",")}]`;
+  }
+  const obj = value;
+  return `{${Object.keys(obj).sort().filter((key) => obj[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+}
+function hashValue(value) {
+  return createHash2("sha256").update(stableStringify(value), "utf8").digest("hex");
+}
+function chronicleEventHash(event) {
+  const { hash: _hash, ...unhashed } = event;
+  return hashValue(unhashed);
+}
+
+// src/chronicle/types.ts
+var CHRONICLE_SCHEMA_VERSION = 1;
+
+// src/chronicle/journal.ts
+import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path3 from "node:path";
+import { createInterface } from "node:readline";
+
+// src/chronicle/partition-filename.ts
+import * as path2 from "node:path";
+var PARTITION_FILE_PATTERN = /^(.*\.events)(?:\.(\d{5}))?\.jsonl$/;
+function partitionFamily(filePath) {
+  const match = PARTITION_FILE_PATTERN.exec(path2.basename(filePath));
+  return path2.join(path2.dirname(filePath), match?.[1] ?? path2.basename(filePath));
+}
+function partitionSequence(filePath) {
+  const match = PARTITION_FILE_PATTERN.exec(path2.basename(filePath));
+  return Number(match?.[2] ?? 0);
+}
+function comparePartitionPaths(left, right) {
+  const familyOrder = partitionFamily(left).localeCompare(partitionFamily(right));
+  return familyOrder || partitionSequence(left) - partitionSequence(right);
+}
+
+// src/chronicle/journal.ts
+var DEFAULT_MAX_PARTITION_BYTES = 100 * 1024 * 1024;
+var DEFAULT_ROTATION_WINDOW_MS = 60 * 60 * 1e3;
+var RETENTION_CHECKPOINT_VERSION = 1;
+var ChronicleJournal = class {
+  basePath;
+  now;
+  monotonicNow;
+  idFactory;
+  maxPending;
+  batchWindowMs;
+  maxPartitionSizeBytes;
+  rotationWindowMs;
+  retentionDays;
+  autoPurgeIntervalMs;
+  pending = [];
+  drainPromise;
+  drainScheduled = false;
+  drainTimer;
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0,
+    partitionRolls: 0
+  };
+  lastBatchDurationMs;
+  partitionIndex = 0;
+  partitionStartedAt;
+  partitionSizeBytes = 0;
+  stateInitialized = false;
+  lastSequence = 0;
+  lastHash = GENESIS_HASH;
+  lastAutoPurgeAt = 0;
+  constructor(options) {
+    this.basePath = path3.resolve(options.filePath);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
+    this.idFactory = options.idFactory ?? randomUUID;
+    this.maxPending = Math.max(1, options.maxPending ?? 1e5);
+    this.batchWindowMs = Math.max(0, options.batchWindowMs ?? 5);
+    this.maxPartitionSizeBytes = options.maxPartitionSizeBytes ?? DEFAULT_MAX_PARTITION_BYTES;
+    this.rotationWindowMs = options.rotationWindowMs ?? DEFAULT_ROTATION_WINDOW_MS;
+    this.retentionDays = options.retentionDays && Number.isFinite(options.retentionDays) && options.retentionDays > 0 ? options.retentionDays : 0;
+    this.autoPurgeIntervalMs = Math.max(0, options.autoPurgeIntervalMs ?? 36e5);
+    this.partitionStartedAt = Date.now();
+  }
+  get path() {
+    return this.partitionIndex === 0 ? this.basePath : rotatedPath(this.basePath, this.partitionIndex);
+  }
+  stats() {
+    return {
+      ...this.counters,
+      pendingEvents: this.pending.length,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
+  }
+  append(input) {
+    if (this.pending.length >= this.maxPending) {
+      this.counters.rejectedEvents++;
+      return Promise.reject(
+        new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`)
+      );
+    }
+    const promise = new Promise((resolve7, reject) => {
+      this.pending.push({ input, resolve: resolve7, reject });
+    });
+    this.counters.acceptedEvents++;
+    this.counters.maxObservedPending = Math.max(
+      this.counters.maxObservedPending,
+      this.pending.length
+    );
+    this.scheduleDrain();
+    return promise;
+  }
+  async readAll() {
+    await this.flush();
+    const files = await collectPartitions(this.basePath);
+    const entries = [];
+    for (const file of files) entries.push(...await readEntriesStrict(file));
+    return entries;
+  }
+  async flush() {
+    if (this.drainTimer) {
+      clearTimeout(this.drainTimer);
+      this.drainTimer = void 0;
+      this.drainScheduled = false;
+    }
+    while (this.pending.length > 0 || this.drainPromise) {
+      if (this.pending.length > 0 && !this.drainPromise) this.startDrain();
+      await this.drainPromise;
+    }
+  }
+  async verify() {
+    await this.flush();
+    const files = await collectPartitions(this.basePath);
+    const checkpointResult = await readRetentionCheckpoint(this.basePath);
+    if (checkpointResult.error)
+      return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
+    return verifyPartitionFiles(files, checkpointResult.checkpoint);
+  }
+  async purge(options) {
+    await this.flush();
+    if (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0) {
+      throw new TypeError("Chronicle retentionDays must be a positive finite number");
+    }
+    await this.refreshStateFromDisk();
+    const cutoff = Date.now() - options.retentionDays * 864e5;
+    const activePath = path3.resolve(this.path);
+    const errors = [];
+    let dc = 0, db = 0, sc = 0;
+    const suppliedFiles = options.files === void 0 ? await collectJournalPartitions(this.basePath) : [...options.files];
+    const eligible = /* @__PURE__ */ new Set();
+    for (const suppliedPath of new Set(suppliedFiles)) {
+      const file = path3.resolve(suppliedPath);
+      if (!isJournalPartition(file, path3.dirname(this.basePath), this.basePath)) {
+        errors.push({
+          file: suppliedPath,
+          reason: "not a Chronicle journal partition in this journal directory"
+        });
+        sc++;
+        continue;
+      }
+      if (file === activePath) {
+        sc++;
+        continue;
+      }
+      let mtimeMs;
+      try {
+        const fileStat = await fs.lstat(file);
+        if (!fileStat.isFile()) {
+          sc++;
+          continue;
+        }
+        mtimeMs = fileStat.mtimeMs;
+      } catch (error) {
+        if (isNotFound(error)) continue;
+        errors.push({ file, reason: errorMessage(error) });
+        sc++;
+        continue;
+      }
+      if (mtimeMs > cutoff) {
+        sc++;
+        continue;
+      }
+      eligible.add(file);
+    }
+    const candidates = [];
+    const allPartitions = await collectJournalPartitions(this.basePath);
+    for (const family of groupPartitionsByFamily(allPartitions).values()) {
+      for (const file of family) {
+        if (file === activePath || !eligible.has(file)) break;
+        candidates.push(file);
+        eligible.delete(file);
+      }
+    }
+    sc += eligible.size;
+    if (!options.dryRun) {
+      for (const file of candidates) {
+        try {
+          const familyBase = partitionFamilyBase(file);
+          let deletedBytes;
+          await withFileLock(familyBase, async () => {
+            const fileStat = await fs.lstat(file);
+            if (!fileStat.isFile() || fileStat.mtimeMs > cutoff) return;
+            const checkpointResult = await readRetentionCheckpoint(familyBase);
+            if (checkpointResult.error) throw new Error(checkpointResult.error);
+            const checkpoint = checkpointResult.checkpoint;
+            const nextCheckpoint = await verifyRetainedPrefix(
+              streamEntriesStrict(file),
+              checkpoint
+            );
+            if (!nextCheckpoint)
+              throw new Error("partition does not extend the trusted Chronicle chain");
+            if (nextCheckpoint.sequence > (checkpoint?.sequence ?? 0)) {
+              await writeRetentionCheckpoint(familyBase, nextCheckpoint);
+            }
+            deletedBytes = fileStat.size;
+            await fs.unlink(file);
+          });
+          if (deletedBytes === void 0) {
+            sc++;
+            break;
+          }
+          db += deletedBytes;
+          dc++;
+        } catch (error) {
+          errors.push({ file, reason: errorMessage(error) });
+          sc++;
+          break;
+        }
+      }
+    }
+    return {
+      deletedCount: dc,
+      deletedBytes: db,
+      skippedCount: sc,
+      errors,
+      ...options.dryRun ? { candidates } : {}
+    };
+  }
+  async maybeAutoPurge() {
+    if (this.retentionDays <= 0) return;
+    const n = Date.now();
+    if (n - this.lastAutoPurgeAt < this.autoPurgeIntervalMs) return;
+    this.lastAutoPurgeAt = n;
+    try {
+      await this.purge({ retentionDays: this.retentionDays });
+    } catch {
+    }
+  }
+  scheduleDrain() {
+    if (this.drainScheduled || this.drainPromise) return;
+    this.drainScheduled = true;
+    if (this.batchWindowMs === 0) {
+      queueMicrotask(() => {
+        this.drainScheduled = false;
+        this.startDrain();
+      });
+      return;
+    }
+    this.drainTimer = setTimeout(() => {
+      this.drainTimer = void 0;
+      this.drainScheduled = false;
+      this.startDrain();
+    }, this.batchWindowMs);
+  }
+  startDrain() {
+    if (this.drainPromise || this.pending.length === 0) return;
+    const batch = this.pending.splice(0);
+    const drain = this.persistBatch(batch);
+    this.drainPromise = drain.finally(() => {
+      this.drainPromise = void 0;
+      if (this.pending.length > 0) this.scheduleDrain();
+    });
+  }
+  async refreshStateFromDisk() {
+    const files = await collectPartitions(this.basePath);
+    const latest = files[files.length - 1] ?? this.basePath;
+    this.partitionIndex = partitionIndex(latest, this.basePath);
+    const state = await readLastEntryState(latest);
+    const entry = state.entry;
+    const checkpointResult = entry ? {} : await readRetentionCheckpoint(this.basePath);
+    if (checkpointResult.error) throw new Error(checkpointResult.error);
+    const checkpoint = checkpointResult.checkpoint;
+    this.lastSequence = entry?.sequence ?? checkpoint?.sequence ?? 0;
+    this.lastHash = entry?.hash ?? checkpoint?.hash ?? GENESIS_HASH;
+    this.partitionSizeBytes = state.size;
+    this.partitionStartedAt = state.birthtimeMs ?? Date.now();
+    this.stateInitialized = true;
+  }
+  async canReuseDiskState() {
+    if (!this.stateInitialized) return false;
+    const nextPartition = rotatedPath(this.basePath, this.partitionIndex + 1);
+    const [currentStat, nextExists] = await Promise.all([
+      fs.stat(this.path).catch((error) => {
+        if (isNotFound(error)) return void 0;
+        throw error;
+      }),
+      fs.access(nextPartition).then(
+        () => true,
+        (error) => {
+          if (isNotFound(error)) return false;
+          throw error;
+        }
+      )
+    ]);
+    return currentStat?.isFile() === true && currentStat.size === this.partitionSizeBytes && !nextExists;
+  }
+  async checkRotation() {
+    if (this.partitionIndex === 0 && this.lastSequence === 0) return;
+    if (Number.isFinite(this.rotationWindowMs) && Date.now() - this.partitionStartedAt >= this.rotationWindowMs) {
+      this.rotate();
+      return;
+    }
+    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes)
+      this.rotate();
+  }
+  rotate() {
+    this.partitionIndex++;
+    this.partitionStartedAt = Date.now();
+    this.partitionSizeBytes = 0;
+    this.counters.partitionRolls++;
+  }
+  async persistBatch(batch) {
+    const started = performance.now();
+    this.counters.batches++;
+    this.counters.largestBatch = Math.max(this.counters.largestBatch, batch.length);
+    try {
+      let recorded = [];
+      await withFileLock(this.basePath, async () => {
+        if (!await this.canReuseDiskState()) await this.refreshStateFromDisk();
+        await this.checkRotation();
+        const cp = this.path;
+        let prev = this.lastSequence > 0 ? { sequence: this.lastSequence, hash: this.lastHash } : void 0;
+        recorded = batch.map(({ input }) => {
+          const instant = this.now().toISOString();
+          const uh = {
+            ...input,
+            occurredAt: input.occurredAt ?? instant,
+            monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
+            schemaVersion: CHRONICLE_SCHEMA_VERSION,
+            eventId: this.idFactory(),
+            observedAt: instant,
+            persistedAt: instant,
+            sequence: (prev?.sequence ?? 0) + 1,
+            previousHash: prev?.hash ?? GENESIS_HASH
+          };
+          const event = { ...uh, hash: hashValue(uh) };
+          prev = event;
+          return event;
+        });
+        const serialized = recorded.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        await fs.appendFile(cp, serialized, { encoding: "utf8", mode: SECRET_FILE_MODE });
+        this.partitionSizeBytes += Buffer.byteLength(serialized);
+      });
+      const last = recorded[recorded.length - 1];
+      this.lastSequence = last.sequence;
+      this.lastHash = last.hash;
+      batch.forEach((item, i) => {
+        item.resolve(recorded[i]);
+      });
+      this.counters.persistedEvents += batch.length;
+      void this.maybeAutoPurge();
+    } catch (error) {
+      this.stateInitialized = false;
+      this.counters.failedEvents += batch.length;
+      batch.forEach((item) => {
+        item.reject(error);
+      });
+    } finally {
+      this.lastBatchDurationMs = performance.now() - started;
+    }
+  }
+};
+function rotatedPath(basePath, index) {
+  const dir = path3.dirname(basePath);
+  const ext = path3.extname(basePath);
+  const base = path3.basename(basePath, ext);
+  return path3.join(dir, `${base}.${String(index).padStart(5, "0")}${ext}`);
+}
+async function collectPartitions(basePath) {
+  const dir = path3.dirname(basePath);
+  const ext = path3.extname(basePath);
+  const base = path3.basename(basePath, ext);
+  const pattern = new RegExp(`^${escapeRegex(base)}(?:\\.\\d{5})?${escapeRegex(ext)}$`);
+  const result = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries)
+      if (entry.isFile() && pattern.test(entry.name)) result.push(path3.join(dir, entry.name));
+  } catch {
+  }
+  const baseFile = path3.join(dir, base + ext);
+  const rotated = result.filter((file) => file !== baseFile).sort((left, right) => parseIndex(left, base, ext) - parseIndex(right, base, ext));
+  return [baseFile, ...rotated];
+}
+async function collectJournalPartitions(basePath) {
+  const directory = path3.dirname(basePath);
+  const result = [];
+  try {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const file = path3.join(directory, entry.name);
+      if (entry.isFile() && isJournalPartition(file, directory, basePath)) result.push(file);
+    }
+  } catch {
+  }
+  return result.sort(comparePartitionPaths);
+}
+function isJournalPartition(filePath, directory, basePath) {
+  if (path3.dirname(path3.resolve(filePath)) !== path3.resolve(directory)) return false;
+  const fileName = path3.basename(filePath);
+  if (!basePath) return false;
+  const baseName = path3.basename(basePath);
+  const dailyFamily = /^\d{4}-\d{2}-\d{2}\.events(?:\.\d{5})?\.jsonl$/;
+  if (/^\d{4}-\d{2}-\d{2}\.events\.jsonl$/.test(baseName)) return dailyFamily.test(fileName);
+  return partitionFamilyBase(path3.resolve(filePath)) === partitionFamilyBase(path3.resolve(basePath));
+}
+function groupPartitionsByFamily(files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const family = partitionFamilyBase(file);
+    const group = groups.get(family) ?? [];
+    group.push(file);
+    groups.set(family, group);
+  }
+  return groups;
+}
+function partitionFamilyBase(filePath) {
+  return filePath.replace(/\.\d{5}(?=\.jsonl$)/, "");
+}
+function retentionCheckpointPath(basePath) {
+  return `${partitionFamilyBase(basePath)}.retention.json`;
+}
+async function verifyRetainedPrefix(entries, checkpoint) {
+  let sequence = checkpoint?.sequence ?? 0;
+  let hash = checkpoint?.hash ?? GENESIS_HASH;
+  let advanced = false;
+  let sawEntry = false;
+  for await (const entry of entries) {
+    sawEntry = true;
+    if (entry.sequence <= sequence) continue;
+    if (entry.sequence !== sequence + 1 || entry.previousHash !== hash) return void 0;
+    const { hash: recordedHash, ...content } = entry;
+    if (hashValue(content) !== recordedHash) return void 0;
+    sequence = entry.sequence;
+    hash = recordedHash;
+    advanced = true;
+  }
+  if (!sawEntry) return void 0;
+  if (!advanced) return checkpoint;
+  return { version: RETENTION_CHECKPOINT_VERSION, sequence, hash };
+}
+async function verifyPartitionFiles(files, checkpoint) {
+  const checkpointSequence = checkpoint?.sequence ?? 0;
+  let previousHash = checkpoint?.hash ?? GENESIS_HASH;
+  let entries = 0;
+  let lastSequence = checkpointSequence;
+  let coveredPrevious;
+  for (const file of files) {
+    try {
+      for await (const entry of streamEntriesStrict(file)) {
+        const { hash: recordedHash, ...content } = entry;
+        if (entry.sequence <= checkpointSequence) {
+          if (hashValue(content) !== recordedHash)
+            return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
+          if (coveredPrevious && entry.sequence !== coveredPrevious.sequence + 1) {
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}`
+            };
+          }
+          if (coveredPrevious && entry.previousHash !== coveredPrevious.hash) {
+            return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
+          }
+          if (entry.sequence === checkpointSequence && recordedHash !== checkpoint?.hash) {
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: "retention checkpoint hash mismatch"
+            };
+          }
+          coveredPrevious = entry;
+          continue;
+        }
+        const index = entries++;
+        if (entry.sequence !== lastSequence + 1)
+          return {
+            ok: false,
+            entries,
+            brokenAt: index,
+            reason: `sequence ${entry.sequence} is not ${lastSequence + 1}`
+          };
+        if (entry.previousHash !== previousHash)
+          return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
+        if (hashValue(content) !== recordedHash)
+          return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
+        previousHash = recordedHash;
+        lastSequence = entry.sequence;
+      }
+    } catch (error) {
+      return { ok: false, entries, brokenAt: entries, reason: errorMessage(error) };
+    }
+  }
+  if (coveredPrevious && (coveredPrevious.sequence !== checkpointSequence || coveredPrevious.hash !== checkpoint?.hash)) {
+    return { ok: false, entries, brokenAt: entries, reason: "retention checkpoint hash mismatch" };
+  }
+  return { ok: true, entries, lastSequence, lastHash: previousHash };
+}
+async function readRetentionCheckpoint(basePath) {
+  const checkpointPath = retentionCheckpointPath(basePath);
+  let raw;
+  try {
+    raw = await fs.readFile(checkpointPath, "utf8");
+  } catch (error) {
+    return isNotFound(error) ? {} : { error: `cannot read retention checkpoint: ${errorMessage(error)}` };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== RETENTION_CHECKPOINT_VERSION || !Number.isSafeInteger(parsed.sequence) || (parsed.sequence ?? -1) < 0 || !isHash(parsed.hash)) {
+      return { error: "invalid Chronicle retention checkpoint" };
+    }
+    return { checkpoint: parsed };
+  } catch {
+    return { error: "invalid Chronicle retention checkpoint JSON" };
+  }
+}
+async function writeRetentionCheckpoint(basePath, checkpoint) {
+  await atomicWrite(retentionCheckpointPath(basePath), `${JSON.stringify(checkpoint)}
+`, {
+    mode: 384
+  });
+}
+function isHash(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function parseIndex(filePath, base, ext) {
+  const suffix = path3.basename(filePath).slice(base.length + 1, -ext.length);
+  return suffix ? parseInt(suffix, 10) : 0;
+}
+function partitionIndex(filePath, basePath) {
+  const ext = path3.extname(basePath);
+  return parseIndex(filePath, path3.basename(basePath, ext), ext);
+}
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function readLastEntryState(filePath) {
+  let handle;
+  try {
+    handle = await fs.open(filePath, "r");
+  } catch (error) {
+    if (isNotFound(error)) return { size: 0 };
+    throw error;
+  }
+  try {
+    const stat4 = await handle.stat();
+    const size = stat4.size;
+    let position = size, suffix = "";
+    while (position > 0) {
+      const length = Math.min(65536, position);
+      position -= length;
+      const buf = Buffer.allocUnsafe(length);
+      await handle.read(buf, 0, length, position);
+      suffix = buf.toString("utf8") + suffix;
+      const lines = suffix.split("\n");
+      const start = position === 0 ? 0 : 1;
+      for (let i = lines.length - 1; i >= start; i--) {
+        const trimmed = lines[i].trim();
+        if (!trimmed) continue;
+        try {
+          return {
+            entry: JSON.parse(trimmed),
+            size,
+            birthtimeMs: stat4.birthtimeMs
+          };
+        } catch {
+        }
+      }
+      suffix = lines[0] ?? "";
+    }
+    return { size, birthtimeMs: stat4.birthtimeMs };
+  } finally {
+    await handle.close();
+  }
+}
+async function* streamEntriesStrict(filePath) {
+  let lineNumber = 0;
+  let input;
+  let lines;
+  try {
+    input = createReadStream(filePath, { encoding: "utf8", highWaterMark: 256 * 1024 });
+    lines = createInterface({ input, crlfDelay: Infinity });
+    for await (const line of lines) {
+      lineNumber++;
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        throw new Error(`invalid JSON at line ${lineNumber} in ${path3.basename(filePath)}`);
+      }
+      yield entry;
+    }
+  } catch (error) {
+    if (isNotFound(error)) return;
+    throw error;
+  } finally {
+    lines?.close();
+    input?.destroy();
+  }
+}
+async function readEntriesStrict(filePath) {
+  const entries = [];
+  for await (const entry of streamEntriesStrict(filePath)) entries.push(entry);
+  return entries;
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/chronicle/partition-range-cache.ts
+import * as fs2 from "node:fs/promises";
+import * as path4 from "node:path";
+var CACHE_VERSION = 1;
+function isRange(value) {
+  if (!value || typeof value !== "object") return false;
+  const range = value;
+  return typeof range.size === "number" && (range.minOccurredAt === void 0 || typeof range.minOccurredAt === "string") && (range.maxOccurredAt === void 0 || typeof range.maxOccurredAt === "string") && (range.empty === void 0 || typeof range.empty === "boolean");
+}
+var ChroniclePartitionRangeCache = class {
+  constructor(directory) {
+    this.directory = directory;
+    this.cachePath = path4.join(directory, "range-cache.json");
+  }
+  directory;
+  cachePath;
+  entries;
+  dirty = false;
+  toKey(filePath) {
+    return path4.relative(this.directory, filePath).split(path4.sep).join("/");
+  }
+  async load() {
+    if (this.entries) return this.entries;
+    const entries = /* @__PURE__ */ new Map();
+    try {
+      const raw = await fs2.readFile(this.cachePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === CACHE_VERSION && parsed.entries && typeof parsed.entries === "object") {
+        for (const [key, range] of Object.entries(parsed.entries)) {
+          if (isRange(range)) entries.set(key, range);
+        }
+      }
+    } catch {
+    }
+    this.entries = entries;
+    return entries;
+  }
+  async get(filePath, currentSize) {
+    const entries = await this.load();
+    const range = entries.get(this.toKey(filePath));
+    return range && range.size === currentSize ? range : void 0;
+  }
+  set(filePath, range) {
+    this.entries ??= /* @__PURE__ */ new Map();
+    this.entries.set(this.toKey(filePath), range);
+    this.dirty = true;
+  }
+  /** Drop entries for files no longer present (e.g. removed by retention purge). */
+  prune(existingFiles) {
+    if (!this.entries) return;
+    const keep = new Set(existingFiles.map((file) => this.toKey(file)));
+    for (const key of this.entries.keys()) {
+      if (!keep.has(key)) {
+        this.entries.delete(key);
+        this.dirty = true;
+      }
+    }
+  }
+  async flush() {
+    if (!this.dirty || !this.entries) return;
+    const payload = { version: CACHE_VERSION, entries: Object.fromEntries(this.entries) };
+    try {
+      await withFileLock(this.cachePath, async () => {
+        await atomicWrite(this.cachePath, `${JSON.stringify(payload)}
+`, { mode: 384 });
+      });
+      this.dirty = false;
+    } catch {
+    }
+  }
+};
+
+// src/chronicle/query.ts
+import { createHash as createHash3 } from "node:crypto";
+import { createReadStream as createReadStream2 } from "node:fs";
+import * as fs3 from "node:fs/promises";
+import * as path5 from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
+var CHRONICLE_FACET_FIELDS = /* @__PURE__ */ new Set([
+  "eventType",
+  "outcome",
+  "projectId",
+  "sessionId",
+  "agentId",
+  "taskId",
+  "providerId",
+  "modelId",
+  "resourceKind",
+  "resourcePath",
+  "toolCallId"
+]);
+var MAX_CURSOR_SNAPSHOT_ENTRIES = 1e4;
+async function* streamLines(filePath, maxBytes) {
+  const stream = createReadStream2(filePath, {
+    encoding: "utf8",
+    highWaterMark: 256 * 1024,
+    ...maxBytes !== void 0 ? { end: maxBytes - 1 } : {}
+  });
+  const rl = createInterface2({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      yield line;
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+async function computeOccurredAtRange(file, size) {
+  let min;
+  let max;
+  for await (const line of streamLines(file, size)) {
+    if (!line.trim()) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+      if (!isChronicleEvent(event)) continue;
+    } catch {
+      continue;
+    }
+    const occurredAt = event.occurredAt ?? event.observedAt;
+    if (min === void 0 || occurredAt < min) min = occurredAt;
+    if (max === void 0 || occurredAt > max) max = occurredAt;
+  }
+  return min === void 0 ? void 0 : { min, max };
+}
+function rangeOverlaps(range, query) {
+  if (range.empty) return false;
+  if (query.from && range.maxOccurredAt < query.from) return false;
+  if (query.to && range.minOccurredAt > query.to) return false;
+  return true;
+}
+var ChronicleQueryEngine = class _ChronicleQueryEngine {
+  constructor(files, diagnostics, rangeCache, activeFile) {
+    this.diagnostics = diagnostics;
+    this.partitionFiles = files;
+    this.rangeCache = rangeCache;
+    this.activeFile = activeFile;
+  }
+  diagnostics;
+  partitionFiles;
+  rangeCache;
+  /** The one file (if any) that could still be actively appended to — never cache-checked or skipped. */
+  activeFile;
+  static async fromDirectory(directory, options) {
+    const resolved = path5.resolve(directory);
+    const files = await findPartitions(resolved);
+    const rangeCache = options?.rangeCache ?? new ChroniclePartitionRangeCache(resolved);
+    return new _ChronicleQueryEngine(
+      files,
+      { sourceFiles: files.length, invalidLines: 0 },
+      rangeCache,
+      files.at(-1)
+    );
+  }
+  static async fromFiles(files) {
+    return new _ChronicleQueryEngine(files, { sourceFiles: files.length, invalidLines: 0 });
+  }
+  /**
+   * Returns the file's observed (min, max) `occurredAt` range, computing and
+   * caching it on first use. Only ever called for closed/immutable files
+   * (never `this.activeFile`) — see the skip-check call sites.
+   */
+  async getOrComputeRange(file, size) {
+    const cached = await this.rangeCache.get(file, size);
+    if (cached) return cached;
+    const computed = await computeOccurredAtRange(file, size);
+    const range = computed ? { size, minOccurredAt: computed.min, maxOccurredAt: computed.max } : { size, empty: true };
+    this.rangeCache.set(file, range);
+    return range;
+  }
+  /** True when a closed file's cached range provably cannot contain a match for `query`. */
+  async canSkip(file, size, query) {
+    if (!this.rangeCache || !query.from && !query.to || file === this.activeFile) return false;
+    const range = await this.getOrComputeRange(file, size);
+    return !rangeOverlaps(range, query);
+  }
+  /** Stream all partitions, filter, and return the requested page + summary. */
+  async query(query = {}) {
+    const order = query.order ?? "desc";
+    const limit = Math.max(1, Math.min(query.limit ?? 100, 1e4));
+    const queryHash = hashQuery(query);
+    const cursor = decodeCursor(query.cursor, order, queryHash);
+    const snapshotFiles = cursor ? await resolveSnapshotFiles(this.partitionFiles, cursor.snapshot) : await captureSnapshot(this.partitionFiles);
+    const files = order === "asc" ? snapshotFiles : snapshotFiles.slice().reverse();
+    const summaryAcc = createSummaryAccumulator();
+    const orderedCandidates = [];
+    const pageOrder = (left, right) => compareEvents(left, right) * (order === "asc" ? 1 : -1);
+    let totalCount = 0;
+    let remainingCount = 0;
+    let scannedEvents = 0;
+    let invalidLines = 0;
+    for (const snapshotFile of files) {
+      try {
+        if (snapshotFile.size === 0) continue;
+        if (await this.canSkip(snapshotFile.file, snapshotFile.size, query)) continue;
+        const lines = order === "asc" ? streamLines(snapshotFile.file, snapshotFile.size) : reverseLines(snapshotFile.file, snapshotFile.size);
+        for await (const line of lines) {
+          if (!line.trim()) continue;
+          let event;
+          try {
+            event = JSON.parse(line);
+            if (!isChronicleEvent(event)) {
+              invalidLines++;
+              continue;
+            }
+          } catch {
+            invalidLines++;
+            continue;
+          }
+          scannedEvents++;
+          if (!matches(event, query)) continue;
+          totalCount++;
+          updateSummary(summaryAcc, event);
+          if (cursor && compareEventToKey(event, cursor.after) * (order === "asc" ? 1 : -1) <= 0) {
+            continue;
+          }
+          remainingCount++;
+          const insertionIndex = findInsertionIndex(orderedCandidates, event, pageOrder);
+          if (insertionIndex < limit) {
+            orderedCandidates.splice(insertionIndex, 0, event);
+            if (orderedCandidates.length > limit) orderedCandidates.pop();
+          }
+        }
+      } catch {
+      }
+    }
+    const pageEvents = orderedCandidates;
+    const lastEvent = pageEvents.at(-1);
+    if (this.rangeCache) {
+      this.rangeCache.prune(this.partitionFiles);
+      await this.rangeCache.flush();
+    }
+    return {
+      events: pageEvents,
+      total: totalCount,
+      summary: finalizeSummary(summaryAcc),
+      ...lastEvent && pageEvents.length < remainingCount ? { nextCursor: encodeCursor({
+        version: 1,
+        order,
+        queryHash,
+        after: orderKey(lastEvent),
+        snapshot: snapshotFiles.map(({ id, size }) => ({ id, size }))
+      }) } : {},
+      scannedEvents,
+      sourceFiles: snapshotFiles.length,
+      invalidLines
+    };
+  }
+  /** Stream all partitions once and compute value counts for every requested facet. */
+  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()]));
+    const snapshotFiles = await captureSnapshot(this.partitionFiles);
+    let invalidLines = 0;
+    for (const snapshotFile of snapshotFiles) {
+      try {
+        if (snapshotFile.size === 0) continue;
+        if (await this.canSkip(snapshotFile.file, snapshotFile.size, query)) continue;
+        for await (const line of streamLines(snapshotFile.file, snapshotFile.size)) {
+          if (!line.trim()) continue;
+          let event;
+          try {
+            event = JSON.parse(line);
+            if (!isChronicleEvent(event)) {
+              invalidLines++;
+              continue;
+            }
+          } catch {
+            invalidLines++;
+            continue;
+          }
+          if (!matches(event, query)) continue;
+          for (const field of uniqueFields) {
+            const value = facetValue(event, field);
+            const fieldCounts = counts.get(field);
+            if (value !== void 0) fieldCounts.set(value, (fieldCounts.get(value) ?? 0) + 1);
+          }
+        }
+      } catch {
+      }
+    }
+    this.diagnostics.invalidLines = invalidLines;
+    if (this.rangeCache) {
+      this.rangeCache.prune(this.partitionFiles);
+      await this.rangeCache.flush();
+    }
+    const result = {};
+    for (const field of uniqueFields) {
+      result[field] = [...counts.get(field)].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count || a.value.localeCompare(b.value)).slice(0, Math.max(0, limit));
+    }
+    return result;
+  }
+  /** Stream all partitions and compute one facet's value counts. */
+  async facet(field, query = {}, limit = 100) {
+    return (await this.facets([field], query, limit))[field] ?? [];
+  }
+  /** Expand explicit and typed correlation edges; temporal proximity alone never creates causality. */
+  async graph(seed = {}, hops = 2, maxNodes = 1e3) {
+    const nodeLimit = Math.max(0, Math.floor(maxNodes));
+    const selected = /* @__PURE__ */ new Map();
+    let seedCount = 0;
+    for await (const event of streamEvents(this.partitionFiles)) {
+      if (!matches(event, seed)) continue;
+      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)));
+      const next = [];
+      for await (const event of streamEvents(this.partitionFiles)) {
+        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)) {
+        seen.add(id);
+        edges.push({ from: from.eventId, to: to.eventId, kind: relation.kind, confidence: relation.confidence });
+      }
+    }
+    return { nodes, edges, truncated: seedCount > nodeLimit || selected.size >= nodeLimit };
+  }
+};
+async function* streamEvents(files) {
+  for (const file of files) {
+    try {
+      for await (const line of streamLines(file)) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (isChronicleEvent(event)) yield event;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+async function* reverseLines(filePath, maxBytes) {
+  const CHUNK = 64 * 1024;
+  const NEWLINE = 10;
+  let handle;
+  try {
+    handle = await fs3.open(filePath, "r");
+  } catch {
+    return;
+  }
+  try {
+    const fileSize = (await handle.stat()).size;
+    const size = Math.min(fileSize, maxBytes ?? fileSize);
+    let position = size;
+    let suffix = Buffer.alloc(0);
+    while (position > 0) {
+      const length = Math.min(CHUNK, position);
+      position -= length;
+      const buffer = Buffer.allocUnsafe(length);
+      await handle.read(buffer, 0, length, position);
+      const data = suffix.length === 0 ? buffer : Buffer.concat([buffer, suffix]);
+      let lineEnd = data.length;
+      let firstNewline = -1;
+      for (let index = data.length - 1; index >= 0; index--) {
+        if (data[index] !== NEWLINE) continue;
+        const trimmed2 = data.subarray(index + 1, lineEnd).toString("utf8").trim();
+        if (trimmed2) yield trimmed2;
+        lineEnd = index;
+        firstNewline = index;
+      }
+      suffix = firstNewline >= 0 ? Buffer.from(data.subarray(0, firstNewline)) : data;
+    }
+    const trimmed = suffix.toString("utf8").trim();
+    if (trimmed) yield trimmed;
+  } finally {
+    await handle.close();
+  }
+}
+function createSummaryAccumulator() {
+  return {
+    logicalRequestIds: /* @__PURE__ */ new Set(),
+    modelAttempts: 0,
+    completedAttempts: 0,
+    failedAttempts: 0,
+    scheduledRetries: 0,
+    fallbacks: 0,
+    providers: /* @__PURE__ */ new Set(),
+    models: /* @__PURE__ */ new Set(),
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costByScope: /* @__PURE__ */ new Map(),
+    providerDurations: [],
+    toolCalls: 0,
+    completedTools: 0,
+    failedTools: 0,
+    toolDurations: [],
+    processes: 0,
+    failedProcesses: 0,
+    fileEvents: 0,
+    uniqueFiles: /* @__PURE__ */ new Set(),
+    agentEvents: 0,
+    uniqueAgents: /* @__PURE__ */ new Set(),
+    decisions: 0,
+    escalations: 0,
+    failures: 0,
+    cancellations: 0,
+    families: { llm: 0, agent: 0, tool: 0, file: 0, memory: 0, task: 0, decision: 0, runtime: 0, finding: 0 },
+    failuresByFamily: { llm: 0, agent: 0, tool: 0, file: 0, memory: 0, task: 0, decision: 0, runtime: 0, finding: 0 }
+  };
+}
+function updateSummary(acc, event) {
+  const family = signalFamily(event);
+  acc.families[family]++;
+  if (isTerminalFailure(event)) acc.failuresByFamily[family]++;
+  if (event.correlation.logicalRequestId) acc.logicalRequestIds.add(event.correlation.logicalRequestId);
+  if (event.runtime?.providerId) acc.providers.add(event.runtime.providerId);
+  if (event.runtime?.modelId) acc.models.add(event.runtime.modelId);
+  if (event.eventType === "provider.attempt.started") acc.modelAttempts++;
+  else if (event.eventType === "provider.attempt.completed") {
+    acc.completedAttempts++;
+    acc.inputTokens += numberAt(event, "usage.input");
+    acc.outputTokens += numberAt(event, "usage.output");
+    acc.cacheReadTokens += numberAt(event, "usage.cacheRead");
+    acc.cacheWriteTokens += numberAt(event, "usage.cacheWrite");
+    const dur = durationMs(event);
+    if (dur > 0) acc.providerDurations.push(dur);
+  } else if (event.eventType === "provider.attempt.failed") {
+    acc.failedAttempts++;
+    if (event.attributes?.retryScheduled === true) acc.scheduledRetries++;
+    const dur = durationMs(event);
+    if (dur > 0) acc.providerDurations.push(dur);
+  } else if (event.eventType === "provider.fallback") acc.fallbacks++;
+  else if (event.eventType === "tool.started") acc.toolCalls++;
+  else if (event.eventType === "tool.executed") {
+    acc.completedTools++;
+    const dur = durationMs(event);
+    if (dur > 0) acc.toolDurations.push(dur);
+  } else if (event.eventType === "tool.failed") {
+    acc.failedTools++;
+    const dur = durationMs(event);
+    if (dur > 0) acc.toolDurations.push(dur);
+  } else if (event.eventType === "process.started") acc.processes++;
+  else if (event.eventType === "process.completed" && event.outcome === "failure") acc.failedProcesses++;
+  else if (event.eventType === "decision.requested") acc.decisions++;
+  else if (event.eventType === "decision.escalated") acc.escalations++;
+  if (event.eventType === "token.accounted") {
+    const cost = readPath(event.attributes ?? {}, "cost.total");
+    if (typeof cost === "number" && Number.isFinite(cost)) {
+      const key = scopeKey(event);
+      const existing = acc.costByScope.get(key);
+      if (!existing || compareEvents(event, existing.event) > 0) {
+        acc.costByScope.set(key, { cost, event });
+      }
+    }
+  }
+  if (event.resource?.kind === "file" || event.eventType.startsWith("file.")) {
+    acc.fileEvents++;
+    if (event.resource?.path) acc.uniqueFiles.add(event.resource.path);
+  }
+  if (family === "agent") acc.agentEvents++;
+  if (event.scope.agentId) acc.uniqueAgents.add(event.scope.agentId);
+  if (isTerminalFailure(event)) acc.failures++;
+  if (event.outcome === "cancelled" || event.outcome === "abandoned") acc.cancellations++;
+}
+function finalizeSummary(acc) {
+  const sortedProviderDurations = acc.providerDurations.slice().sort((a, b) => a - b);
+  const sortedToolDurations = acc.toolDurations.slice().sort((a, b) => a - b);
+  const totalCost = [...acc.costByScope.values()].reduce((sum, entry) => sum + entry.cost, 0);
+  return {
+    logicalRequests: acc.logicalRequestIds.size,
+    modelAttempts: acc.modelAttempts,
+    completedAttempts: acc.completedAttempts,
+    failedAttempts: acc.failedAttempts,
+    scheduledRetries: acc.scheduledRetries,
+    fallbacks: acc.fallbacks,
+    providers: acc.providers.size,
+    models: acc.models.size,
+    inputTokens: acc.inputTokens,
+    outputTokens: acc.outputTokens,
+    cacheReadTokens: acc.cacheReadTokens,
+    cacheWriteTokens: acc.cacheWriteTokens,
+    estimatedCostUsd: totalCost,
+    providerAvgDurationMs: average(sortedProviderDurations),
+    providerP95DurationMs: percentile(sortedProviderDurations, 0.95),
+    toolCalls: acc.toolCalls,
+    completedTools: acc.completedTools,
+    failedTools: acc.failedTools,
+    toolAvgDurationMs: average(sortedToolDurations),
+    processes: acc.processes,
+    failedProcesses: acc.failedProcesses,
+    fileEvents: acc.fileEvents,
+    uniqueFiles: acc.uniqueFiles.size,
+    agentEvents: acc.agentEvents,
+    uniqueAgents: acc.uniqueAgents.size,
+    decisions: acc.decisions,
+    escalations: acc.escalations,
+    failures: acc.failures,
+    cancellations: acc.cancellations,
+    families: acc.families,
+    failuresByFamily: acc.failuresByFamily
+  };
+}
+Object.defineProperty(ChronicleQueryEngine.prototype, "partitionFiles", {
+  get() {
+    throw new Error("ChronicleQueryEngine no longer loads events on construction. Use async query().");
+  },
+  set(_val) {
+    Object.defineProperty(this, "partitionFiles", { value: _val, writable: false, configurable: false });
+  }
+});
+async function findChroniclePartitions(root) {
+  return findPartitions(root);
+}
+async function findPartitions(root) {
+  const result = [];
+  const visit = async (directory) => {
+    let entries;
+    try {
+      entries = await fs3.readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path5.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(full);
+      else if (entry.isFile() && PARTITION_FILE_PATTERN.test(entry.name)) result.push(full);
+    }
+  };
+  await visit(root);
+  return result.sort(comparePartitionPaths);
+}
+function numberAt(event, dotPath) {
+  const value = readPath(event.attributes ?? {}, dotPath);
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function durationMs(event) {
+  const value = Number(event.durationNs ?? 0) / 1e6;
+  return Number.isFinite(value) ? value : 0;
+}
+function average(values) {
+  return values.length ? values.reduce((sum, v) => sum + v, 0) / values.length : 0;
+}
+function percentile(sorted, quantile) {
+  return sorted.length ? sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * quantile) - 1))] : 0;
+}
+function scopeKey(event) {
+  return `${event.scope.projectId ?? ""}\0${event.scope.sessionId ?? ""}\0${event.scope.agentId ?? ""}`;
+}
+function signalFamily(event) {
+  if (/^(?:decision|brain|permission)\./.test(event.eventType)) return "decision";
+  if (event.resource?.kind === "file" || event.resource?.kind === "symbol" || /^(?:file|worktree)\./.test(event.eventType)) return "file";
+  if (/^(?:provider|token|context|ctx|compaction)\./.test(event.eventType)) return "llm";
+  if (/^(?:agent|subagent|delegate|fleet|concurrency)\./.test(event.eventType)) return "agent";
+  if (/^(?:tool|process|mcp|network)\./.test(event.eventType)) return "tool";
+  if (/^(?:memory|storage|trust)\./.test(event.eventType)) return "memory";
+  if (/^(?:sdd|task|kanban|checkpoint|session|iteration|in_flight)\./.test(event.eventType)) return "task";
+  if (/^(?:finding|review)\./.test(event.eventType)) return "finding";
+  return "runtime";
+}
+function isTerminalFailure(event) {
+  if (event.eventType === "provider.attempt.failed") return event.attributes?.retryScheduled !== true;
+  return event.eventType === "tool.failed" || event.eventType === "process.completed" && event.outcome === "failure" || /^(?:agent\.run\.error|sdd\.task\.failed|compaction\.failed|network\.request\.failed)$/.test(event.eventType);
+}
+function relationKeys(event) {
+  const result = [];
+  const add = (kind, value, confidence) => {
+    if (typeof value === "string" && value) result.push({ key: `${kind}:${value}`, kind, confidence });
+  };
+  add("trace", event.correlation.traceId, "correlated");
+  add("tool_call", event.correlation.toolCallId, "explicit");
+  add("logical_request", event.correlation.logicalRequestId, "explicit");
+  add("attempt", event.correlation.attemptId, "explicit");
+  add("decision", event.attributes?.decisionId, "explicit");
+  add("network_request", event.attributes?.requestId, "explicit");
+  add(
+    "prompt_manifest",
+    event.correlation.promptManifestId ?? event.attributes?.promptManifest?.manifestId,
+    "explicit"
+  );
+  add("resource_lineage", event.resource?.id, "inferred");
+  if (event.eventType === "metrics.rollup" && event.attributes?.signal === "tool.resource.observed") {
+    const resources = event.attributes.resources;
+    for (const resource of resources ?? []) {
+      if (typeof resource?.id === "string") add("resource_lineage", resource.id, "inferred");
+    }
+  }
+  if (event.correlation.parentSpanId) add("parent_span", event.correlation.parentSpanId, "explicit");
+  add("parent_span", event.correlation.spanId, "explicit");
+  return result;
+}
+function matches(event, query) {
+  if (query.eventId && event.eventId !== query.eventId) return false;
+  if (query.eventTypes && !query.eventTypes.includes(event.eventType)) return false;
+  if (query.outcomes && (!event.outcome || !query.outcomes.includes(event.outcome))) return false;
+  const occurredAt = event.occurredAt ?? event.observedAt;
+  if (query.from && occurredAt < query.from || query.to && occurredAt > query.to) return false;
+  if (!equal(query.projectId, event.scope.projectId) || !equal(query.sessionId, event.scope.sessionId)) return false;
+  if (!equal(query.agentId, event.scope.agentId) || !equal(query.taskId, event.scope.taskId)) return false;
+  if (!equal(query.providerId, event.runtime?.providerId) || !equal(query.modelId, event.runtime?.modelId)) return false;
+  if (!equal(query.traceId, event.correlation.traceId) || !equal(query.logicalRequestId, event.correlation.logicalRequestId)) return false;
+  if (!equal(query.promptManifestId, event.correlation.promptManifestId)) return false;
+  if (!equal(query.attemptId, event.correlation.attemptId) || !equal(query.toolCallId, event.correlation.toolCallId)) return false;
+  if (!equal(query.resourceKind, event.resource?.kind) || !equal(query.resourceId, event.resource?.id)) return false;
+  if (query.path && normalize(event.resource?.path) !== normalize(query.path)) return false;
+  if (query.line !== void 0 && !lineContains(event, query.line)) return false;
+  if (query.tags && !objectContains(event.tags, query.tags)) return false;
+  if (query.attributes && !objectContains(event.attributes, query.attributes)) return false;
+  if (query.text && !JSON.stringify(event).toLocaleLowerCase().includes(query.text.toLocaleLowerCase())) return false;
+  return true;
+}
+function equal(expected, actual) {
+  return expected === void 0 || expected === actual;
+}
+function normalize(value) {
+  return value?.replaceAll("\\", "/").toLocaleLowerCase();
+}
+function lineContains(event, line) {
+  const start = event.resource?.lineStart;
+  const end = event.resource?.lineEnd ?? start;
+  return start !== void 0 && end !== void 0 && line >= start && line <= end;
+}
+function objectContains(actual, expected) {
+  return Boolean(actual && Object.entries(expected).every(([key, value]) => deepEqual(readPath(actual, key), value)));
+}
+function readPath(value, key) {
+  return key.split(".").reduce((current, part) => current && typeof current === "object" ? current[part] : void 0, value);
+}
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function findInsertionIndex(events, event, compare) {
+  let low = 0;
+  let high = events.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (compare(events[middle], event) <= 0) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function compareEvents(a, b) {
+  return compareEventToKey(a, orderKey(b));
+}
+function compareEventToKey(event, key) {
+  return (event.occurredAt ?? event.observedAt).localeCompare(key.occurredAt) || event.persistedAt.localeCompare(key.persistedAt) || event.sequence - key.sequence || event.eventId.localeCompare(key.eventId);
+}
+function orderKey(event) {
+  return {
+    occurredAt: event.occurredAt ?? event.observedAt,
+    persistedAt: event.persistedAt,
+    sequence: event.sequence,
+    eventId: event.eventId
+  };
+}
+function hashQuery(query) {
+  const { cursor: _cursor, limit: _limit, order: _order, ...filters } = query;
+  return createHash3("sha256").update(stableStringify2(filters), "utf8").digest("base64url");
+}
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(encoded, order, queryHash) {
+  if (!encoded) return void 0;
+  if (encoded.length > 1e6) throw new Error("Invalid Chronicle cursor");
+  try {
+    const parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    if (!isCursor(parsed) || parsed.order !== order || parsed.queryHash !== queryHash) {
+      throw new Error("cursor does not match the query");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Invalid Chronicle cursor: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isCursor(value) {
+  if (!value || typeof value !== "object") return false;
+  const cursor = value;
+  const after = cursor.after;
+  if (cursor.version !== 1 || cursor.order !== "asc" && cursor.order !== "desc" || typeof cursor.queryHash !== "string" || !after || typeof after.occurredAt !== "string" || typeof after.persistedAt !== "string" || !Number.isSafeInteger(after.sequence) || typeof after.eventId !== "string" || !Array.isArray(cursor.snapshot) || cursor.snapshot.length > MAX_CURSOR_SNAPSHOT_ENTRIES) return false;
+  const snapshotIds = /* @__PURE__ */ new Set();
+  for (const entry of cursor.snapshot) {
+    if (!entry || typeof entry.id !== "string" || !entry.id || !Number.isSafeInteger(entry.size) || entry.size < 0 || snapshotIds.has(entry.id)) return false;
+    snapshotIds.add(entry.id);
+  }
+  return true;
+}
+async function captureSnapshot(files) {
+  if (files.length > MAX_CURSOR_SNAPSHOT_ENTRIES) {
+    throw new Error("Chronicle snapshot contains too many partitions");
+  }
+  return Promise.all(files.map(async (file) => {
+    let size = 0;
+    try {
+      size = (await fs3.stat(file)).size;
+    } catch {
+    }
+    return { file, id: fileId(file), size };
+  }));
+}
+async function resolveSnapshotFiles(files, snapshot) {
+  const currentFiles = new Map(files.map((file) => [fileId(file), file]));
+  return Promise.all(snapshot.map(async (entry) => {
+    const file = currentFiles.get(entry.id);
+    if (!file) throw new Error("Chronicle cursor snapshot has expired");
+    let currentSize;
+    try {
+      currentSize = (await fs3.stat(file)).size;
+    } catch {
+      throw new Error("Chronicle cursor snapshot has expired");
+    }
+    if (currentSize < entry.size) throw new Error("Chronicle cursor snapshot has expired");
+    return { file, ...entry };
+  }));
+}
+function fileId(file) {
+  return createHash3("sha256").update(path5.resolve(file), "utf8").digest("base64url");
+}
+function stableStringify2(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify2).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify2(object[key])}`).join(",")}}`;
+}
+function isChronicleEvent(value) {
+  if (!isRecord(value) || !isRecord(value.scope) || !isRecord(value.correlation)) return false;
+  return value.schemaVersion === 1 && typeof value.eventId === "string" && typeof value.eventType === "string" && typeof value.occurredAt === "string" && typeof value.observedAt === "string" && typeof value.persistedAt === "string" && Number.isSafeInteger(value.sequence) && value.sequence >= 0 && typeof value.previousHash === "string" && typeof value.hash === "string" && typeof value.scope.installationId === "string" && typeof value.scope.machineId === "string" && optionalStrings(value.scope, [
+    "projectId",
+    "repositoryId",
+    "workspaceId",
+    "worktreeId",
+    "sessionId",
+    "turnId",
+    "iterationId",
+    "agentId",
+    "goalId",
+    "planId",
+    "taskId",
+    "kanbanBoardId"
+  ]) && typeof value.correlation.traceId === "string" && typeof value.correlation.spanId === "string" && optionalStrings(value.correlation, [
+    "parentSpanId",
+    "logicalRequestId",
+    "promptManifestId",
+    "attemptId",
+    "toolCallId"
+  ]) && isRuntime(value.runtime) && isResource(value.resource) && (value.attributes === void 0 || isRecord(value.attributes)) && (value.tags === void 0 || isStringRecord(value.tags));
+}
+function isRuntime(value) {
+  return value === void 0 || isRecord(value) && optionalStrings(value, ["providerId", "modelId", "modelRevision"]) && optionalFiniteNumbers(value, ["processId", "parentProcessId"]);
+}
+function isResource(value) {
+  if (value === void 0) return true;
+  if (!isRecord(value) || ![
+    "file",
+    "symbol",
+    "memory",
+    "task",
+    "kanban",
+    "process",
+    "network",
+    "artifact",
+    "other"
+  ].includes(String(value.kind)) || typeof value.id !== "string") return false;
+  return optionalStrings(value, ["path", "contentHashBefore", "contentHashAfter"]) && optionalFiniteNumbers(value, ["lineStart", "lineEnd"]);
+}
+function optionalStrings(value, keys) {
+  return keys.every((key) => value[key] === void 0 || typeof value[key] === "string");
+}
+function optionalFiniteNumbers(value, keys) {
+  return keys.every((key) => value[key] === void 0 || typeof value[key] === "number" && Number.isFinite(value[key]));
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function facetValue(event, field) {
+  const values = {
+    eventType: event.eventType,
+    outcome: event.outcome,
+    projectId: event.scope.projectId,
+    sessionId: event.scope.sessionId,
+    agentId: event.scope.agentId,
+    taskId: event.scope.taskId,
+    providerId: event.runtime?.providerId,
+    modelId: event.runtime?.modelId,
+    resourceKind: event.resource?.kind,
+    resourcePath: event.resource?.path,
+    toolCallId: event.correlation.toolCallId
+  };
+  return values[field];
+}
+
+// src/chronicle/sqlite-journal-quota.ts
+import * as fs4 from "node:fs";
+var SQLITE_FIXED_OVERHEAD_BYTES = 16 * 1024 * 1024;
+var MIN_SQLITE_PAGE_BUDGET_BYTES = 64 * 1024;
+var MAX_WAL_RESERVE_BYTES = 32 * 1024 * 1024;
+var WAL_AUTOCHECKPOINT_PAGES = 2e3;
+var WAL_SIZE_LIMIT_BYTES = 16 * 1024 * 1024;
+var ChronicleStorageQuotaError = class extends Error {
+  currentBytes;
+  batchBytes;
+  maxBytes;
+  path;
+  constructor(details) {
+    super(
+      `Chronicle SQLite quota exceeded at ${details.path}: ${details.currentBytes} live bytes + ${details.batchBytes} batch bytes exceeds ${details.maxBytes}; lower chronicle retentionDays/maxEvents to shed data (run chronicle compact to return the freed pages to the filesystem)`
+    );
+    this.name = "ChronicleStorageQuotaError";
+    this.currentBytes = details.currentBytes;
+    this.batchBytes = details.batchBytes;
+    this.maxBytes = details.maxBytes;
+    this.path = details.path;
+  }
+};
+var ChronicleQuotaManager = class {
+  constructor(db, dbPath, maxBytes) {
+    this.db = db;
+    this.dbPath = dbPath;
+    this.maxBytes = maxBytes;
+  }
+  db;
+  dbPath;
+  maxBytes;
+  cachedPageSize;
+  quotaHeadroomBytes = 0;
+  bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
+  configure() {
+    if (this.maxBytes === void 0) {
+      this.db.exec("PRAGMA max_page_count = 2147483646");
+      return;
+    }
+    const halfSplit = Math.floor((this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES) / 2);
+    const sidecarReserve = Math.min(MAX_WAL_RESERVE_BYTES, halfSplit);
+    const mainBudget = this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES - sidecarReserve;
+    if (mainBudget < MIN_SQLITE_PAGE_BUDGET_BYTES) {
+      throw new Error(
+        `maxBytes must be at least ${SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES}`
+      );
+    }
+    const maxPages = Math.max(1, Math.floor(mainBudget / this.pageSizeBytes()));
+    this.db.exec(`PRAGMA max_page_count = ${maxPages}`);
+  }
+  pageSizeBytes() {
+    if (this.cachedPageSize === void 0) {
+      this.cachedPageSize = Number(
+        this.db.prepare("PRAGMA page_size").get().page_size
+      );
+    }
+    return this.cachedPageSize;
+  }
+  aggregateLiveBytes() {
+    let total = 0;
+    for (const file of [`${this.dbPath}-journal`, `${this.dbPath}-wal`, `${this.dbPath}-shm`]) {
+      try {
+        total += fs4.statSync(file).size;
+      } catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+      }
+    }
+    return total + this.mainDatabaseLiveBytes();
+  }
+  mainDatabaseLiveBytes() {
+    const pageCount = Number(
+      this.db.prepare("PRAGMA page_count").get().page_count
+    );
+    const freelist = Number(
+      this.db.prepare("PRAGMA freelist_count").get().freelist_count
+    );
+    return Math.max(0, pageCount - freelist) * this.pageSizeBytes();
+  }
+  invalidateEstimate() {
+    this.quotaHeadroomBytes = 0;
+    this.bytesSinceQuotaCheck = Number.POSITIVE_INFINITY;
+  }
+  recordAppendedBytes(bytes) {
+    this.bytesSinceQuotaCheck += bytes;
+  }
+  assertWithinByteQuota(batchBytes) {
+    if (this.maxBytes === void 0) return;
+    if (!this.shouldMeasureQuota(batchBytes)) return;
+    const currentBytes = this.aggregateLiveBytes();
+    this.recordQuotaHeadroom(currentBytes);
+    if (currentBytes + batchBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  assertActualAllocationWithinQuota() {
+    if (this.maxBytes === void 0) return;
+    if (!this.shouldMeasureQuota()) return;
+    const currentBytes = this.aggregateLiveBytes();
+    this.recordQuotaHeadroom(currentBytes);
+    if (currentBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  normalizeQuotaError(error) {
+    if (this.maxBytes === void 0 || !(error instanceof Error)) return error;
+    const sqliteError = error;
+    const quotaExhausted = sqliteError.code === "SQLITE_FULL" || sqliteError.code === 13 || sqliteError.errcode === 13 || /database or disk is full/i.test(sqliteError.message);
+    if (!quotaExhausted) return error;
+    return new ChronicleStorageQuotaError({
+      currentBytes: this.aggregateLiveBytes(),
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  shouldMeasureQuota(batchBytes = 0) {
+    return this.bytesSinceQuotaCheck + batchBytes >= this.quotaHeadroomBytes / 2;
+  }
+  recordQuotaHeadroom(currentBytes) {
+    this.quotaHeadroomBytes = Math.max(0, (this.maxBytes ?? 0) - currentBytes);
+    this.bytesSinceQuotaCheck = 0;
+  }
+};
+
+// src/chronicle/sqlite-journal.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as path6 from "node:path";
+
+// src/chronicle/sqlite-journal-schema.ts
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
+var CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
+var LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
+var LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
+var LEGACY_JSONL_BOUNDARY_KEY = "legacy-jsonl-v1:boundary";
+var SCHEMA_VERSION = 3;
+var Ctor;
+function loadDatabaseSync() {
+  if (Ctor) return Ctor;
+  if (Ctor === null) throw new Error("SQLite is unavailable in this runtime");
+  try {
+    Ctor = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync);
+    return Ctor;
+  } catch (error) {
+    Ctor = null;
+    throw new Error(
+      "The Chronicle journal needs node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+}
+function projectEvent(event) {
+  const occurredAt = event.occurredAt ?? event.observedAt;
+  return {
+    occurredAt,
+    outcome: event.outcome ?? null,
+    projectId: event.scope.projectId ?? null,
+    sessionId: event.scope.sessionId ?? null,
+    agentId: event.scope.agentId ?? null,
+    taskId: event.scope.taskId ?? null,
+    traceId: event.correlation?.traceId ?? null,
+    logicalRequestId: event.correlation?.logicalRequestId ?? null,
+    promptManifestId: event.correlation?.promptManifestId ?? null,
+    resourceKind: event.resource?.kind ?? null,
+    resourceId: event.resource?.id ?? null,
+    resourcePath: event.resource?.path ?? null,
+    durationNs: event.durationNs ?? null
+  };
+}
+function ensureChronicleSchema(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      day                TEXT NOT NULL,
+      sequence           INTEGER NOT NULL,
+      event_id           TEXT NOT NULL UNIQUE,
+      hash               TEXT NOT NULL,
+      previous_hash      TEXT NOT NULL,
+      occurred_at        TEXT NOT NULL,
+      event_type         TEXT NOT NULL,
+      outcome            TEXT,
+      project_id         TEXT,
+      session_id         TEXT,
+      agent_id           TEXT,
+      task_id            TEXT,
+      trace_id           TEXT,
+      logical_request_id TEXT,
+      prompt_manifest_id TEXT,
+      resource_kind      TEXT,
+      resource_id        TEXT,
+      resource_path      TEXT,
+      duration_ns        TEXT,
+      payload            TEXT NOT NULL,
+      PRIMARY KEY (day, sequence)
+    );
+    CREATE INDEX IF NOT EXISTS events_occurred_at ON events(occurred_at);
+    CREATE INDEX IF NOT EXISTS events_type_outcome ON events(event_type, outcome);
+    CREATE INDEX IF NOT EXISTS events_session ON events(session_id, day, sequence);
+    CREATE INDEX IF NOT EXISTS events_trace ON events(trace_id);
+    CREATE INDEX IF NOT EXISTS events_logical_request ON events(logical_request_id);
+
+    CREATE TABLE IF NOT EXISTS chain_checkpoint (
+      day      TEXT PRIMARY KEY,
+      sequence INTEGER NOT NULL,
+      hash     TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS chronicle_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  if (version < 2) {
+    db.exec("DROP INDEX IF EXISTS events_resource_path");
+  }
+  if (version > 0 && version < 3) {
+    db.exec("ALTER TABLE events ADD COLUMN prompt_manifest_id TEXT");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS events_prompt_manifest ON events(prompt_manifest_id)");
+  if (version !== SCHEMA_VERSION) {
+    db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+  }
+}
+
+// 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("prompt_manifest_id", query.promptManifestId);
+  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);
+  }
+  if (query.from) {
+    clauses.push("occurred_at >= ?");
+    params.push(query.from);
+  }
+  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 = {
+      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;
+  }
+  /**
+   * 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);
+      }
+    }
+    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));
+    }
+    return result;
+  }
+  async facet(field, query = {}, limit = 100) {
+    return (await this.facets([field], query, limit))[field] ?? [];
+  }
+  /**
+   * 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);
+    }
+    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;
+    }
+    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
+          });
+        }
+      }
+    }
+    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;
+    }
+  }
+};
+
+// src/chronicle/sqlite-journal.ts
+var TRIM_SLACK_RATIO = 0.02;
+var MAX_TRIM_SLACK_EVENTS = 2e3;
+var ChronicleSqliteJournal = class {
+  db;
+  dbPath;
+  now;
+  monotonicNow;
+  idFactory;
+  retentionDays;
+  maxEvents;
+  retentionCheckIntervalMs;
+  /** Overshoot allowed above `maxEvents` before eviction runs; see TRIM_SLACK_RATIO. */
+  trimSlack;
+  quotaManager;
+  nextRetentionCheckAt = 0;
+  retainedEventCount = 0;
+  /**
+   * 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 = path6.join(path6.resolve(options.directory), CHRONICLE_SQLITE_FILE);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
+    this.idFactory = options.idFactory ?? (() => randomUUID2());
+    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.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}`);
+    ensureChronicleSchema(this.db);
+    this.quotaManager = new ChronicleQuotaManager(this.db, this.dbPath, options.maxBytes);
+    this.quotaManager.configure();
+    if (this.maxEvents !== void 0) {
+      const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
+      this.retainedEventCount = row.count;
+      this.enforceEventLimitAtStartup();
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  stats() {
+    return {
+      ...this.counters,
+      pendingEvents: 0,
+      partitionRolls: 0,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
+  }
+  async flush() {
+    return Promise.resolve();
+  }
+  async append(input) {
+    const [event] = await this.appendBatch([input]);
+    return event;
+  }
+  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 {
+      this.db.exec("BEGIN IMMEDIATE");
+      this.quotaManager.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.promptManifestId,
+          row.resourceKind,
+          row.resourceId,
+          row.resourcePath,
+          row.durationNs,
+          payloads[index]
+        );
+      }
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(
+        this.retainedEventCount + events.length
+      );
+      this.quotaManager.assertActualAllocationWithinQuota();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      this.anchors.clear();
+      this.quotaManager.invalidateEstimate();
+      this.counters.failedEvents += inputs.length;
+      this.lastBatchDurationMs = performance.now() - started;
+      throw this.quotaManager.normalizeQuotaError(error);
+    }
+    this.anchors.set(day, previous);
+    this.counters.persistedEvents += events.length;
+    this.retainedEventCount = retainedCountAfterCommit;
+    this.quotaManager.recordAppendedBytes(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));
+  }
+  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;
+      }
+      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 {
+    }
+  }
+  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;
+  }
+  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;
+    }
+  }
+  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) };
+    }
+    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)
+          }
+        ]
+      };
+    }
+    this.anchors.clear();
+    this.retainedEventCount = this.countRows();
+    this.quotaManager.invalidateEstimate();
+    return { ...empty, deletedCount: count };
+  }
+  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, prompt_manifest_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.quotaManager.invalidateEstimate();
+      this.quotaManager.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.promptManifestId,
+            row.resourceKind,
+            row.resourceId,
+            row.resourcePath,
+            row.durationNs,
+            JSON.stringify(event)
+          );
+        },
+        checkpoint: (day, sequence, hash) => {
+          checkpoint.run(day, sequence, hash);
+        }
+      });
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction(this.countRows(), 0);
+      this.quotaManager.invalidateEstimate();
+      this.quotaManager.assertActualAllocationWithinQuota();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      this.quotaManager.invalidateEstimate();
+      throw this.quotaManager.normalizeQuotaError(error);
+    } finally {
+      this.anchors.clear();
+    }
+    this.retainedEventCount = retainedCountAfterCommit;
+  }
+  queryEngine(options) {
+    return new ChronicleSqliteQueryEngine(this.db, options);
+  }
+  hasImportedLegacyJournal() {
+    return this.readMeta(LEGACY_JSONL_MIGRATION_KEY) !== void 0;
+  }
+  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);
+  }
+  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));
+  }
+  /** Record per-partition-file JSONL byte offsets at import time (merged — the
+   *  import persists per family, so a crash mid-run keeps earlier boundaries).
+   *  The metrics ingester folds only bytes beyond these boundaries after the
+   *  migration, so post-migration appends (the jsonl-store fallback) are
+   *  ingested while the migrated bytes are never re-counted. Files absent from
+   *  the map were quarantined (or created post-migration) — their events live
+   *  only in JSONL. */
+  recordLegacyJsonlBoundary(boundary) {
+    let merged = boundary;
+    try {
+      const row = this.db.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_BOUNDARY_KEY);
+      if (row?.value) {
+        merged = { ...JSON.parse(row.value), ...boundary };
+      }
+    } catch {
+    }
+    this.db.prepare(
+      `INSERT INTO chronicle_meta (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(LEGACY_JSONL_BOUNDARY_KEY, JSON.stringify(merged));
+  }
+  hasImportedDay(day) {
+    const row = this.db.prepare("SELECT 1 AS present FROM events WHERE day = ? LIMIT 1").get(day);
+    return row !== void 0;
+  }
+  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 [];
+    }
+  }
+  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, prompt_manifest_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;
+  }
+  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() {
+    const rows = this.db.prepare("SELECT DISTINCT day FROM events ORDER BY day").all();
+    return rows.map((row) => row.day);
+  }
+  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;
+  }
+};
+
+// src/chronicle/metrics-schema.ts
+import { loadRuntimeDatabaseSync as loadRuntimeDatabaseSync2 } from "@wrongstack/persistence";
+var SCHEMA_VERSION2 = 4;
+var READ_CHUNK_BYTES = 1024 * 1024;
+var SQLITE_SOURCE_PREFIX = "sqlite:";
+var SQLITE_INGEST_BATCH = 2e3;
+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() {
+  if (Ctor2) return Ctor2;
+  if (Ctor2 === null) throw new Error("SQLite is unavailable in this runtime");
+  try {
+    Ctor2 = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync2);
+    return Ctor2;
+  } catch (error) {
+    Ctor2 = null;
+    throw new Error(
+      "Chronicle metrics need node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+}
+function isChronicleMetricsAvailable() {
+  try {
+    loadDatabaseSync2();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureMetricsSchema(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version !== 0 && version !== SCHEMA_VERSION2) {
+    db.exec(
+      "DROP TABLE IF EXISTS ingest_state; DROP TABLE IF EXISTS provider_daily;DROP TABLE IF EXISTS task_outcomes; DROP TABLE IF EXISTS file_lineage;DROP TABLE IF EXISTS token_cost; DROP TABLE IF EXISTS daily_counters;DROP TABLE IF EXISTS family_daily; DROP TABLE IF EXISTS agent_daily;DROP TABLE IF EXISTS logical_request_daily; DROP TABLE IF EXISTS file_seen_daily;"
+    );
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ingest_state (
+      file TEXT PRIMARY KEY,
+      bytes INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS provider_daily (
+      day TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      model_id TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      completed INTEGER NOT NULL DEFAULT 0,
+      failed INTEGER NOT NULL DEFAULT 0,
+      retries INTEGER NOT NULL DEFAULT 0,
+      fallbacks INTEGER NOT NULL DEFAULT 0,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      duration_ms_total REAL NOT NULL DEFAULT 0,
+      duration_ms_max REAL NOT NULL DEFAULT 0,
+      duration_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (day, provider_id, model_id)
+    );
+    CREATE TABLE IF NOT EXISTS task_outcomes (
+      task_id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL DEFAULT '',
+      board_id TEXT NOT NULL DEFAULT '',
+      session_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'started',
+      started_at TEXT,
+      ended_at TEXT,
+      duration_ms REAL,
+      retries INTEGER NOT NULL DEFAULT 0,
+      verification_failures INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS file_lineage (
+      event_id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      path_key TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      session_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      task_id TEXT NOT NULL DEFAULT '',
+      board_id TEXT NOT NULL DEFAULT '',
+      run_id TEXT NOT NULL DEFAULT '',
+      tool_name TEXT NOT NULL DEFAULT '',
+      provider_id TEXT NOT NULL DEFAULT '',
+      model_id TEXT NOT NULL DEFAULT '',
+      logical_request_id TEXT NOT NULL DEFAULT '',
+      prompt_manifest_id TEXT NOT NULL DEFAULT '',
+      provenance_confidence TEXT NOT NULL DEFAULT 'unknown',
+      source TEXT NOT NULL DEFAULT ''
+    );
+    CREATE INDEX IF NOT EXISTS idx_file_lineage_path ON file_lineage(path_key, occurred_at);
+    CREATE INDEX IF NOT EXISTS idx_file_lineage_task ON file_lineage(task_id);
+    CREATE TABLE IF NOT EXISTS token_cost (
+      scope_key TEXT PRIMARY KEY,
+      day TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      cost REAL NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS daily_counters (
+      day TEXT PRIMARY KEY,
+      tool_calls INTEGER NOT NULL DEFAULT 0,
+      completed_tools INTEGER NOT NULL DEFAULT 0,
+      failed_tools INTEGER NOT NULL DEFAULT 0,
+      tool_duration_ms_total REAL NOT NULL DEFAULT 0,
+      tool_duration_ms_max REAL NOT NULL DEFAULT 0,
+      tool_duration_count INTEGER NOT NULL DEFAULT 0,
+      processes INTEGER NOT NULL DEFAULT 0,
+      failed_processes INTEGER NOT NULL DEFAULT 0,
+      file_events_all INTEGER NOT NULL DEFAULT 0,
+      decisions INTEGER NOT NULL DEFAULT 0,
+      escalations INTEGER NOT NULL DEFAULT 0,
+      agent_events INTEGER NOT NULL DEFAULT 0,
+      failures INTEGER NOT NULL DEFAULT 0,
+      cancellations INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS family_daily (
+      day TEXT NOT NULL,
+      family TEXT NOT NULL,
+      count INTEGER NOT NULL DEFAULT 0,
+      failure_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (day, family)
+    );
+    CREATE TABLE IF NOT EXISTS agent_daily (day TEXT NOT NULL, agent_id TEXT NOT NULL, PRIMARY KEY (day, agent_id));
+    CREATE TABLE IF NOT EXISTS logical_request_daily (day TEXT NOT NULL, logical_request_id TEXT NOT NULL, PRIMARY KEY (day, logical_request_id));
+    CREATE TABLE IF NOT EXISTS file_seen_daily (day TEXT NOT NULL, path_key TEXT NOT NULL, PRIMARY KEY (day, path_key));
+    PRAGMA user_version = ${SCHEMA_VERSION2};
+  `);
+}
+function eventDay(event) {
+  return (event.occurredAt ?? event.observedAt).slice(0, 10);
+}
+function durationMs2(event) {
+  const value = Number(event.durationNs ?? 0) / 1e6;
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+function numberOrDuration(event, attributes) {
+  const explicit = attributes.durationMs;
+  if (typeof explicit === "number" && Number.isFinite(explicit)) return explicit;
+  return durationMs2(event);
+}
+function numberAt2(event, dotPath) {
+  const value = readPath2(event.attributes ?? {}, dotPath);
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function readPath2(value, key) {
+  return key.split(".").reduce(
+    (current, part) => current && typeof current === "object" ? current[part] : void 0,
+    value
+  );
+}
+function stringAt(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function clampLimit(limit, fallback) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return fallback;
+  return Math.min(Math.floor(limit), 1e4);
+}
+function normalizeKey(value) {
+  return value.replaceAll("\\", "/");
+}
+function normalizePathKey(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "").toLowerCase();
+}
+
+// src/chronicle/metrics-store.ts
+import * as path8 from "node:path";
+
+// src/chronicle/metrics-ingest.ts
+import * as fs5 from "node:fs/promises";
+import * as path7 from "node:path";
+var REBUILD_MARKER_KEY = `${SQLITE_SOURCE_PREFIX}rebuild_done`;
+var ChronicleMetricsIngester = class {
+  constructor(db, directory, dbPath) {
+    this.db = db;
+    this.directory = directory;
+    this.dbPath = dbPath;
+  }
+  db;
+  directory;
+  dbPath;
+  /**
+   * Prepared-statement cache for the per-event ingest hot paths. Preparing
+   * the same SQL on every event was the dominant ingest cost; node:sqlite
+   * statements are reusable, so each distinct SQL string is prepared once.
+   */
+  stmtCache = /* @__PURE__ */ new Map();
+  stmt(sql) {
+    let s = this.stmtCache.get(sql);
+    if (!s) {
+      s = this.db.prepare(sql);
+      this.stmtCache.set(sql, s);
+    }
+    return s;
+  }
+  async refresh() {
+    const result = {
+      ingestedEvents: 0,
+      ingestedBytes: 0,
+      sourceFiles: 0,
+      invalidLines: 0
+    };
+    await withFileLock(this.dbPath, async () => {
+      const files = await findChroniclePartitions(this.directory);
+      const offsets = this.loadOffsets();
+      const journalPath = path7.join(this.directory, CHRONICLE_SQLITE_FILE);
+      let source = null;
+      try {
+        source = new (loadDatabaseSync2())(journalPath, { readOnly: true });
+      } catch {
+      }
+      try {
+        const migrated = source !== null && this.legacyJsonlConsumed(source);
+        const boundary = migrated && source !== null ? this.loadJsonlBoundary(source) : null;
+        const rebuilt = migrated && this.needsSqliteRebuild(offsets);
+        if (rebuilt && source !== null) {
+          this.rebuildFromSqliteJournal(source, result);
+        }
+        if (!migrated || boundary !== null) {
+          for (const file of files) {
+            const key = normalizeKey(path7.relative(this.directory, file));
+            let base;
+            if (!migrated) {
+              base = offsets.get(key) ?? 0;
+            } else if (boundary?.has(key)) {
+              base = Math.max(offsets.get(key) ?? 0, boundary.get(key));
+            } else {
+              base = rebuilt ? 0 : offsets.get(key) ?? 0;
+            }
+            const ingested = await this.ingestFile(file, key, base, result);
+            if (ingested) result.sourceFiles++;
+          }
+        }
+        this.pruneOffsets(files);
+        if (source !== null && !rebuilt) {
+          this.ingestSqliteJournal(source, offsets, result, false);
+          if (migrated) this.ensureRebuildMarker();
+        }
+      } finally {
+        if (source !== null) source.close();
+      }
+    });
+    return result;
+  }
+  loadOffsets() {
+    const rows = this.db.prepare("SELECT file, bytes FROM ingest_state").all();
+    return new Map(rows.map((row) => [row.file, Number(row.bytes)]));
+  }
+  /** True once the legacy JSONL journal was imported into the SQLite journal
+   *  (`importLegacyChronicleJournal` records the marker in `chronicle_meta`).
+   *  After that point the SQLite `events` table already holds every JSONL
+   *  event, so folding the leftover partition files again would double-count
+   *  every migrated event in the aggregates. `source` is the already-opened
+   *  read-only journal handle (null when no SQLite journal exists yet). */
+  legacyJsonlConsumed(source) {
+    if (source === null) return false;
+    try {
+      const row = source.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_MIGRATION_KEY);
+      return row?.value !== void 0;
+    } catch {
+      return false;
+    }
+  }
+  /** Per-partition-file JSONL byte offsets recorded by
+   *  `importLegacyChronicleJournal` at import time (keyed by the same relative
+   *  path the fold uses). Files absent from the map were quarantined (or
+   *  created after the migration) — their events live only in JSONL. */
+  loadJsonlBoundary(source) {
+    try {
+      const row = source.prepare("SELECT value FROM chronicle_meta WHERE key = ?").get(LEGACY_JSONL_BOUNDARY_KEY);
+      if (!row?.value) return null;
+      const parsed = JSON.parse(row.value);
+      return new Map(Object.entries(parsed));
+    } catch {
+      return null;
+    }
+  }
+  /** Persist the rebuild sentinel idempotently. Its presence makes
+   *  `needsSqliteRebuild` return false, so post-migration jsonl-store offsets
+   *  are never mistaken for pre-migration progress. */
+  ensureRebuildMarker() {
+    this.db.prepare(
+      "INSERT INTO ingest_state (file, bytes) VALUES (?, ?) ON CONFLICT(file) DO UPDATE SET bytes = excluded.bytes"
+    ).run(REBUILD_MARKER_KEY, 1);
+  }
+  /** Upgrade path: `metrics.db` already aggregated the legacy JSONL, then the
+   *  one-shot import copied those same events into the SQLite journal. There
+   *  is no `sqlite:` cursor yet, so a plain incremental fold would replay the
+   *  entire migrated history on top of the existing aggregates. The metrics
+   *  projection is disposable (fully derived from the journal), so rebuild it
+   *  from the SQLite source exactly once — the rebuild writes the cursors and
+   *  subsequent refreshes go back to incremental folding. */
+  needsSqliteRebuild(offsets) {
+    if (offsets.has(REBUILD_MARKER_KEY)) return false;
+    for (const [key, bytes] of offsets) {
+      if (!key.startsWith(SQLITE_SOURCE_PREFIX) && bytes > 0) return true;
+    }
+    return false;
+  }
+  rebuildFromSqliteJournal(source, result) {
+    this.db.exec(
+      "DELETE FROM ingest_state; DELETE FROM provider_daily; DELETE FROM task_outcomes; DELETE FROM file_lineage; DELETE FROM token_cost; DELETE FROM daily_counters; DELETE FROM family_daily; DELETE FROM agent_daily; DELETE FROM logical_request_daily; DELETE FROM file_seen_daily;"
+    );
+    this.ingestSqliteJournal(source, /* @__PURE__ */ new Map(), result, true);
+    this.ensureRebuildMarker();
+  }
+  pruneOffsets(existingFiles) {
+    const keep = new Set(
+      existingFiles.map((file) => normalizeKey(path7.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);
+    }
+  }
+  ingestSqliteJournal(source, offsets, result, propagateErrors) {
+    try {
+      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.ingestEventAtomically(JSON.parse(row.payload), result);
+              } 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;
+        }
+        if (cursor > from) result.sourceFiles++;
+      }
+    } catch (error) {
+      if (propagateErrors) throw error;
+    }
+  }
+  async ingestFile(file, key, consumed, result) {
+    let handle;
+    try {
+      handle = await fs5.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.ingestEventAtomically(JSON.parse(trimmed), result);
+            } 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;
+      }
+      result.ingestedBytes += advanced - consumed;
+      return advanced > consumed;
+    } finally {
+      await handle.close();
+    }
+  }
+  /** Fold one event into the aggregates atomically. `ingestEvent` runs several
+   *  statements; when one throws mid-way (e.g. a malformed resource path), the
+   *  statements before it already mutated the aggregates. The savepoint rolls
+   *  those partial updates back: `ROLLBACK TO` rewinds, `RELEASE` (reached
+   *  before the re-throw) pops the savepoint so the next event in the batch
+   *  starts from a clean stack, and the batch commits only fully-succeeded
+   *  events. Dropping the `RELEASE` would leak the savepoint into the next
+   *  event's stack — the outer transaction ROLLBACK is never reached because
+   *  the per-event catch swallows the error and continues the batch. */
+  ingestEventAtomically(event, result) {
+    this.db.exec("SAVEPOINT ingest_event");
+    try {
+      this.ingestEvent(event);
+      this.db.exec("RELEASE ingest_event");
+      result.ingestedEvents++;
+    } catch (error) {
+      this.db.exec("ROLLBACK TO ingest_event");
+      this.db.exec("RELEASE ingest_event");
+      throw error;
+    }
+  }
+  ingestEvent(event) {
+    if (typeof event?.eventType !== "string" || !event.scope) return;
+    this.ingestDailyCounters(event);
+    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);
+    }
+  }
+  ingestDailyCounters(event) {
+    const day = eventDay(event);
+    this.stmt("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
+    const bump = (sql, ...params) => this.stmt(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
+    const family = signalFamily(event);
+    const failed = isTerminalFailure(event) ? 1 : 0;
+    this.stmt(
+      `INSERT INTO family_daily (day, family, count, failure_count) VALUES (?, ?, 1, ?)
+       ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
+    ).run(day, family, failed);
+    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.stmt(
+        "INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)"
+      ).run(day, event.correlation.logicalRequestId);
+    }
+    if (event.scope.agentId) {
+      this.stmt("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(
+        day,
+        event.scope.agentId
+      );
+    }
+    const type = event.eventType;
+    if (type === "decision.requested") bump("decisions = decisions + 1");
+    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.stmt("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(
+          day,
+          normalizePathKey(event.resource.path)
+        );
+      }
+    }
+  }
+  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.stmt(
+      "INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)"
+    ).run(day, providerId, modelId);
+    const update = (sql, ...params) => this.stmt(
+      `UPDATE provider_daily SET ${sql} WHERE day = ? AND provider_id = ? AND model_id = ?`
+    ).run(...params, day, providerId, modelId);
+    const duration = durationMs2(event);
+    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;
+    }
+  }
+  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.stmt(
+      `INSERT INTO token_cost (scope_key, day, occurred_at, sequence, cost) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(scope_key) DO UPDATE SET
+         day = excluded.day, occurred_at = excluded.occurred_at,
+         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);
+  }
+  ingestTask(event) {
+    const attributes = event.attributes ?? {};
+    const taskId = event.scope.taskId ?? stringAt(attributes, "taskId");
+    if (!taskId) return;
+    const occurredAt = event.occurredAt ?? event.observedAt;
+    this.stmt("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
+    const set = (sql, ...params) => this.stmt(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
+    const lineage = [
+      ["run_id", stringAt(attributes, "runId")],
+      ["board_id", event.scope.kanbanBoardId ?? stringAt(attributes, "boardId")],
+      ["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;
+    }
+  }
+  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.stmt(
+      `INSERT OR IGNORE INTO file_lineage
+        (event_id, path, path_key, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
+         tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+         provenance_confidence, 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") ?? "",
+      event.correlation.logicalRequestId ?? stringAt(attributes, "logicalRequestId") ?? "",
+      event.correlation.promptManifestId ?? stringAt(attributes, "promptManifestId") ?? "",
+      provenanceConfidence(attributes),
+      stringAt(attributes, "source") ?? (event.eventType === "file.event" ? "tool" : "external")
+    );
+  }
+};
+function provenanceConfidence(attributes) {
+  const value = attributes["provenanceConfidence"];
+  return value === "explicit" || value === "correlated" || value === "inferred" ? value : "unknown";
+}
+
+// src/chronicle/metrics-store.ts
+var ChronicleMetricsStore = class _ChronicleMetricsStore {
+  db;
+  directory;
+  dbPath;
+  ingester;
+  constructor(directory) {
+    this.directory = path8.resolve(directory);
+    this.dbPath = path8.join(this.directory, "metrics.db");
+    const Database = loadDatabaseSync2();
+    this.db = new Database(this.dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    ensureMetricsSchema(this.db);
+    this.ingester = new ChronicleMetricsIngester(this.db, this.directory, this.dbPath);
+  }
+  static open(chronicleDirectory) {
+    return new _ChronicleMetricsStore(chronicleDirectory);
+  }
+  close() {
+    this.db.close();
+  }
+  /** Incrementally ingest journal bytes appended since the last refresh.
+   *  Safe across processes: guarded by a file lock on the database path. */
+  async refresh() {
+    return this.ingester.refresh();
+  }
+  providerDaily(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.from) {
+      clauses.push("day >= ?");
+      params.push(options.from.slice(0, 10));
+    }
+    if (options.to) {
+      clauses.push("day <= ?");
+      params.push(options.to.slice(0, 10));
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(
+      `SELECT day, provider_id, model_id, attempts, completed, failed, retries, fallbacks,
+        input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+        duration_ms_total, duration_ms_max, duration_count
+       FROM provider_daily${where} ORDER BY day DESC, provider_id, model_id`
+    ).all(...params);
+    return rows.map((row) => ({
+      day: String(row.day),
+      providerId: String(row.provider_id),
+      modelId: String(row.model_id),
+      attempts: Number(row.attempts),
+      completed: Number(row.completed),
+      failed: Number(row.failed),
+      retries: Number(row.retries),
+      fallbacks: Number(row.fallbacks),
+      inputTokens: Number(row.input_tokens),
+      outputTokens: Number(row.output_tokens),
+      cacheReadTokens: Number(row.cache_read_tokens),
+      cacheWriteTokens: Number(row.cache_write_tokens),
+      avgDurationMs: Number(row.duration_count) > 0 ? Number(row.duration_ms_total) / Number(row.duration_count) : 0,
+      maxDurationMs: Number(row.duration_ms_max)
+    }));
+  }
+  taskOutcomes(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.runId) {
+      clauses.push("t.run_id = ?");
+      params.push(options.runId);
+    }
+    if (options.boardId) {
+      clauses.push("t.board_id = ?");
+      params.push(options.boardId);
+    }
+    if (options.sessionId) {
+      clauses.push("t.session_id = ?");
+      params.push(options.sessionId);
+    }
+    if (options.status) {
+      clauses.push("t.status = ?");
+      params.push(options.status);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    params.push(clampLimit(options.limit, 100));
+    const rows = this.db.prepare(
+      `SELECT t.*, (SELECT COUNT(*) FROM file_lineage f WHERE f.task_id = t.task_id) AS files_touched
+       FROM task_outcomes t${where}
+       ORDER BY COALESCE(t.started_at, '') DESC LIMIT ?`
+    ).all(...params);
+    return rows.map((row) => ({
+      taskId: String(row.task_id),
+      runId: String(row.run_id),
+      boardId: String(row.board_id),
+      sessionId: String(row.session_id),
+      agentId: String(row.agent_id),
+      status: String(row.status),
+      startedAt: row.started_at === null ? null : String(row.started_at),
+      endedAt: row.ended_at === null ? null : String(row.ended_at),
+      durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
+      retries: Number(row.retries),
+      verificationFailures: Number(row.verification_failures),
+      filesTouched: Number(row.files_touched)
+    }));
+  }
+  fileLineage(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.path) {
+      clauses.push("path_key = ?");
+      params.push(normalizePathKey(options.path));
+    }
+    if (options.paths) {
+      const pathKeys = [...new Set(options.paths.map(normalizePathKey))];
+      if (pathKeys.length === 0) return [];
+      clauses.push(`path_key IN (${pathKeys.map(() => "?").join(",")})`);
+      params.push(...pathKeys);
+    }
+    if (options.taskId) {
+      clauses.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (options.boardId) {
+      clauses.push("board_id = ?");
+      params.push(options.boardId);
+    }
+    if (options.sessionId) {
+      clauses.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    params.push(clampLimit(options.limit, 200));
+    const projection = `path, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
+       tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+       provenance_confidence, source`;
+    const sql = options.latestPerPath ? `SELECT ${projection} FROM (
+           SELECT ${projection}, ROW_NUMBER() OVER (
+             PARTITION BY path_key ORDER BY occurred_at DESC, event_id DESC
+           ) 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,
+      logicalRequestId: row.logical_request_id,
+      promptManifestId: row.prompt_manifest_id,
+      provenanceConfidence: row.provenance_confidence,
+      source: row.source
+    }));
+  }
+  summary() {
+    const provider = this.db.prepare(
+      "SELECT COALESCE(SUM(attempts),0) a, COALESCE(SUM(completed),0) c, COALESCE(SUM(failed),0) f FROM provider_daily"
+    ).get();
+    const tasks = {};
+    for (const row of this.db.prepare("SELECT status, COUNT(*) n FROM task_outcomes GROUP BY status").all()) {
+      tasks[row.status] = Number(row.n);
+    }
+    const files = this.db.prepare("SELECT COUNT(*) n, COUNT(DISTINCT path) p FROM file_lineage").get();
+    const cost = this.db.prepare("SELECT COALESCE(SUM(cost),0) c FROM token_cost").get();
+    const terminal = Number(provider.c) + Number(provider.f);
+    return {
+      providers: {
+        attempts: Number(provider.a),
+        completed: Number(provider.c),
+        failed: Number(provider.f),
+        successRate: terminal > 0 ? Number(provider.c) / terminal : 0
+      },
+      tasks,
+      files: { mutations: Number(files.n), uniquePaths: Number(files.p) },
+      estimatedCostUsd: Number(cost.c)
+    };
+  }
+  /**
+   * A `ChronicleSummary` for the default/unfiltered dashboard view — only
+   * `from`/`to` (day-precision) narrow it.
+   */
+  defaultSummary(options = {}) {
+    const fromDay = options.from?.slice(0, 10);
+    const toDay = options.to?.slice(0, 10);
+    const dayFilter = (column) => {
+      const clauses = [];
+      const params = [];
+      if (fromDay) {
+        clauses.push(`${column} >= ?`);
+        params.push(fromDay);
+      }
+      if (toDay) {
+        clauses.push(`${column} <= ?`);
+        params.push(toDay);
+      }
+      return { where: clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "", params };
+    };
+    const providerRange = dayFilter("day");
+    const provider = this.db.prepare(
+      `SELECT COALESCE(SUM(attempts),0) attempts, COALESCE(SUM(completed),0) completed, COALESCE(SUM(failed),0) failed,
+        COALESCE(SUM(retries),0) retries, COALESCE(SUM(fallbacks),0) fallbacks,
+        COUNT(DISTINCT provider_id) providers, COUNT(DISTINCT model_id) models,
+        COALESCE(SUM(input_tokens),0) inputTokens, COALESCE(SUM(output_tokens),0) outputTokens,
+        COALESCE(SUM(cache_read_tokens),0) cacheReadTokens, COALESCE(SUM(cache_write_tokens),0) cacheWriteTokens,
+        COALESCE(SUM(duration_ms_total),0) durationTotal, COALESCE(MAX(duration_ms_max),0) durationMax,
+        COALESCE(SUM(duration_count),0) durationCount
+       FROM provider_daily${providerRange.where}`
+    ).get(...providerRange.params);
+    const counterRange = dayFilter("day");
+    const counters = this.db.prepare(
+      `SELECT COALESCE(SUM(tool_calls),0) toolCalls, COALESCE(SUM(completed_tools),0) completedTools,
+        COALESCE(SUM(failed_tools),0) failedTools, COALESCE(SUM(tool_duration_ms_total),0) toolDurationTotal,
+        COALESCE(SUM(tool_duration_count),0) toolDurationCount, COALESCE(SUM(processes),0) processes,
+        COALESCE(SUM(failed_processes),0) failedProcesses, COALESCE(SUM(file_events_all),0) fileEvents,
+        COALESCE(SUM(decisions),0) decisions, COALESCE(SUM(escalations),0) escalations,
+        COALESCE(SUM(agent_events),0) agentEvents, COALESCE(SUM(failures),0) failures,
+        COALESCE(SUM(cancellations),0) cancellations
+       FROM daily_counters${counterRange.where}`
+    ).get(...counterRange.params);
+    const familyRange = dayFilter("day");
+    const familyRows = this.db.prepare(`SELECT family, count, failure_count FROM family_daily${familyRange.where}`).all(...familyRange.params);
+    const families = { ...EMPTY_FAMILIES };
+    const failuresByFamily = { ...EMPTY_FAMILIES };
+    for (const row of familyRows) {
+      const family = row.family;
+      families[family] = Number(row.count);
+      failuresByFamily[family] = Number(row.failure_count);
+    }
+    const agentRange = dayFilter("day");
+    const uniqueAgents = this.db.prepare(`SELECT COUNT(DISTINCT agent_id) n FROM agent_daily${agentRange.where}`).get(...agentRange.params).n;
+    const requestRange = dayFilter("day");
+    const logicalRequests = this.db.prepare(
+      `SELECT COUNT(DISTINCT logical_request_id) n FROM logical_request_daily${requestRange.where}`
+    ).get(...requestRange.params).n;
+    const fileRange = dayFilter("day");
+    const uniqueFiles = this.db.prepare(`SELECT COUNT(DISTINCT path_key) n FROM file_seen_daily${fileRange.where}`).get(...fileRange.params).n;
+    const costRange = dayFilter("day");
+    const cost = this.db.prepare(`SELECT COALESCE(SUM(cost),0) c FROM token_cost${costRange.where}`).get(...costRange.params).c;
+    return {
+      logicalRequests: Number(logicalRequests),
+      modelAttempts: Number(provider.attempts),
+      completedAttempts: Number(provider.completed),
+      failedAttempts: Number(provider.failed),
+      scheduledRetries: Number(provider.retries),
+      fallbacks: Number(provider.fallbacks),
+      providers: Number(provider.providers),
+      models: Number(provider.models),
+      inputTokens: Number(provider.inputTokens),
+      outputTokens: Number(provider.outputTokens),
+      cacheReadTokens: Number(provider.cacheReadTokens),
+      cacheWriteTokens: Number(provider.cacheWriteTokens),
+      estimatedCostUsd: Number(cost),
+      providerAvgDurationMs: Number(provider.durationCount) > 0 ? Number(provider.durationTotal) / Number(provider.durationCount) : 0,
+      providerP95DurationMs: Number(provider.durationMax),
+      toolCalls: Number(counters.toolCalls),
+      completedTools: Number(counters.completedTools),
+      failedTools: Number(counters.failedTools),
+      toolAvgDurationMs: Number(counters.toolDurationCount) > 0 ? Number(counters.toolDurationTotal) / Number(counters.toolDurationCount) : 0,
+      processes: Number(counters.processes),
+      failedProcesses: Number(counters.failedProcesses),
+      fileEvents: Number(counters.fileEvents),
+      uniqueFiles: Number(uniqueFiles),
+      agentEvents: Number(counters.agentEvents),
+      uniqueAgents: Number(uniqueAgents),
+      decisions: Number(counters.decisions),
+      escalations: Number(counters.escalations),
+      failures: Number(counters.failures),
+      cancellations: Number(counters.cancellations),
+      families,
+      failuresByFamily
+    };
+  }
+};
+
+// src/chronicle/legacy-journal-import.ts
+import * as fs6 from "node:fs/promises";
+import * as path9 from "node:path";
+var ChronicleImportError = class extends Error {
+  constructor(message, day, sequence) {
+    super(message);
+    this.day = day;
+    this.sequence = sequence;
+    this.name = "ChronicleImportError";
+  }
+  day;
+  sequence;
+};
+async function discoverFamilies(directory) {
+  let entries;
+  try {
+    entries = await fs6.readdir(directory);
+  } catch {
+    return [];
+  }
+  const bases = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const match = PARTITION_FILE_PATTERN.exec(entry);
+    if (match?.[1]) bases.add(match[1]);
+  }
+  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 = [];
+  const boundary = {};
+  let importedEvents = 0;
+  let importedFamilies = 0;
+  for (const familyBase of families) {
+    const day = dayOfFamily(familyBase);
+    const basePath = path9.join(directory, `${familyBase}.jsonl`);
+    let familyEvents = 0;
+    const familyBoundary = {};
+    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)) {
+          familyBoundary[path9.relative(directory, partition).replaceAll("\\", "/")] = (await fs6.stat(partition)).size;
+          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;
+    }
+    Object.assign(boundary, familyBoundary);
+    if (familyEvents > 0) importedFamilies += 1;
+    importedEvents += familyEvents;
+    journal.recordLegacyJsonlBoundary(boundary);
+  }
+  journal.recordQuarantinedFamilies(quarantined);
+  journal.recordLegacyJsonlBoundary(boundary);
+  journal.markLegacyJournalImported();
+  return {
+    alreadyImported: false,
+    families: importedFamilies,
+    events: importedEvents,
+    quarantined
+  };
+}
+
+// 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)}
+`;
+}
+
+// src/chronicle/project-server-endpoint.ts
+import { createHash as createHash4 } from "node:crypto";
+import * as os2 from "node:os";
+import * as path10 from "node:path";
+var CHRONICLE_PROJECT_SERVER_METADATA_FILE = "server.json";
+function normalizedPath(value) {
+  const resolved = path10.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function chronicleProjectServerKey(projectDir) {
+  return createHash4("sha256").update(normalizedPath(path10.join(projectDir, "chronicle"))).digest("hex").slice(0, 24);
+}
+function chronicleProjectServerEndpoint(projectDir) {
+  const key = chronicleProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-chronicle-v${CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
+  }
+  return path10.join(
+    os2.tmpdir(),
+    `wsch-v${CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION}`,
+    `${key}.sock`
+  );
+}
+function chronicleProjectServerMetadataPath(projectDir) {
+  return path10.join(projectDir, "chronicle", CHRONICLE_PROJECT_SERVER_METADATA_FILE);
+}
+
+export {
+  resolveChronicleRuntimeLocation,
+  GENESIS_HASH,
+  CHRONICLE_SCHEMA_VERSION,
+  ChronicleJournal,
+  ChroniclePartitionRangeCache,
+  CHRONICLE_FACET_FIELDS,
+  ChronicleQueryEngine,
+  findChroniclePartitions,
+  ChronicleStorageQuotaError,
+  ChronicleSqliteJournal,
+  isChronicleMetricsAvailable,
+  ChronicleMetricsStore,
+  importLegacyChronicleJournal,
+  CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION,
+  CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS,
+  CHRONICLE_MAX_APPEND_BATCH,
+  encodeChronicleProjectServerMessage,
+  chronicleProjectServerKey,
+  chronicleProjectServerEndpoint,
+  chronicleProjectServerMetadataPath
+};
+//# sourceMappingURL=chunk-AT4V4XGI.js.map