@wrongstack/core 0.287.0 → 0.291.0

package/dist/chronicle/index.js

@@ -0,0 +1,2555 @@
+// src/chronicle/context.ts
+import { randomUUID } from "node:crypto";
+function createChronicleContext(scope, traceId = randomUUID()) {
+  return {
+    scope: { ...scope },
+    correlation: { traceId, spanId: randomUUID() }
+  };
+}
+function childChronicleContext(parent, overrides = {}) {
+  return {
+    scope: { ...parent.scope, ...overrides.scope },
+    correlation: {
+      ...parent.correlation,
+      ...overrides.correlation,
+      traceId: parent.correlation.traceId,
+      parentSpanId: parent.correlation.spanId,
+      spanId: overrides.correlation?.spanId ?? randomUUID()
+    }
+  };
+}
+
+// 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,
+    journalPath: path.join(input.projectDir, "chronicle", `${day}.events.jsonl`)
+  };
+}
+function stableId(prefix, value) {
+  return `${prefix}_${createHash("sha256").update(value).digest("hex").slice(0, 24)}`;
+}
+
+// src/chronicle/file-observer.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path2 from "node:path";
+var DEFAULT_EXCLUDED = [".git", ".wrongstack", "node_modules", "dist", "coverage", ".temp_files"];
+async function startChronicleFileObserver(options) {
+  const root = path2.resolve(options.projectRoot);
+  const excluded = new Set(options.excludedDirectories ?? DEFAULT_EXCLUDED);
+  const debounceMs = options.debounceMs ?? 120;
+  const maxHashBytes = options.maxHashBytes ?? 8 * 1024 * 1024;
+  const known = await scanProject(root, excluded, maxHashBytes, options.onError);
+  const recentToolMutations = /* @__PURE__ */ new Map();
+  const offToolProgress = options.events?.on("tool.progress", (event) => {
+    if (event.event.type !== "file_changed" || !event.event.path) return;
+    const absolute = path2.isAbsolute(event.event.path) ? path2.normalize(event.event.path) : path2.resolve(root, event.event.path);
+    const relative2 = normalizeRelative(path2.relative(root, absolute));
+    if (relative2.startsWith("../") || isExcluded(relative2, excluded)) return;
+    recentToolMutations.set(relative2, {
+      at: Date.now(),
+      toolUseId: event.id,
+      toolName: event.name,
+      agentId: event.agentId
+    });
+  });
+  const pending = /* @__PURE__ */ new Set();
+  let timer;
+  let closed = false;
+  let flushTail = Promise.resolve();
+  const schedule = (filename) => {
+    if (closed) return;
+    if (filename === null) {
+      pending.add("*");
+    } else {
+      const relative2 = normalizeRelative(String(filename));
+      if (!relative2 || isExcluded(relative2, excluded)) return;
+      pending.add(relative2);
+    }
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      const paths = [...pending];
+      pending.clear();
+      flushTail = flushTail.then(() => reconcile(paths)).catch((error) => options.onError?.(error));
+    }, debounceMs);
+  };
+  const reconcile = async (changedPaths) => {
+    const candidates = changedPaths.includes("*") ? unionKeys(known, await scanProject(root, excluded, maxHashBytes, options.onError)) : changedPaths;
+    const changes = [];
+    for (const relative2 of candidates) {
+      const before = known.get(relative2);
+      const after = await fingerprint(path2.join(root, relative2), maxHashBytes);
+      if (sameFingerprint(before, after)) continue;
+      changes.push({ relative: relative2, before, after });
+    }
+    const deleted = changes.filter((change) => change.before && !change.after);
+    const created = changes.filter((change) => !change.before && change.after);
+    const consumed = /* @__PURE__ */ new Set();
+    for (const from of deleted) {
+      const match = created.find(
+        (to) => !consumed.has(to.relative) && from.before?.hash !== void 0 && from.before.hash === to.after?.hash
+      );
+      if (!match) continue;
+      consumed.add(from.relative);
+      consumed.add(match.relative);
+      known.delete(from.relative);
+      known.set(match.relative, match.after);
+      await recordMutation(options, "file.external.renamed", match.relative, match.after, {
+        operation: "rename",
+        previousPath: from.relative,
+        previousResourceId: resourceId(from.relative),
+        actor: "external"
+      }, mutationAttribution(match.relative, recentToolMutations));
+    }
+    for (const change of changes) {
+      if (consumed.has(change.relative)) continue;
+      if (!change.after) {
+        known.delete(change.relative);
+        await recordMutation(options, "file.external.deleted", change.relative, change.before, {
+          operation: "delete",
+          actor: "external",
+          previousHash: change.before?.hash,
+          previousSize: change.before?.size
+        }, mutationAttribution(change.relative, recentToolMutations));
+      } else if (!change.before) {
+        known.set(change.relative, change.after);
+        await recordMutation(options, "file.external.created", change.relative, change.after, {
+          operation: "write",
+          actor: "external"
+        }, mutationAttribution(change.relative, recentToolMutations));
+      } else {
+        known.set(change.relative, change.after);
+        await recordMutation(options, "file.external.modified", change.relative, change.after, {
+          operation: "edit",
+          actor: "external",
+          previousHash: change.before.hash,
+          previousSize: change.before.size
+        }, mutationAttribution(change.relative, recentToolMutations));
+      }
+    }
+  };
+  let watcher;
+  try {
+    watcher = fs.watch(root, { recursive: true, persistent: false }, (_eventType, filename) => schedule(filename));
+  } catch (error) {
+    options.onError?.(error);
+    throw error;
+  }
+  watcher.on("error", (error) => options.onError?.(error));
+  return {
+    get watchedFiles() {
+      return known.size;
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      offToolProgress?.();
+      watcher.close();
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+        const paths = [...pending];
+        pending.clear();
+        if (paths.length > 0) flushTail = flushTail.then(() => reconcile(paths));
+      }
+      await flushTail;
+    }
+  };
+}
+async function recordMutation(options, eventType, relativePath, state, attributes, attribution) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const operation = attributes["operation"];
+  options.events?.emit("file.activity", {
+    filePath: path2.join(options.projectRoot, relativePath),
+    operation,
+    phase: "changed",
+    source: attribution ? "tool" : "external",
+    at: Date.now(),
+    sessionId: context.scope.sessionId,
+    traceId: context.correlation.traceId,
+    agentId: attribution?.agentId ?? context.scope.agentId,
+    ...attribution ? { toolUseId: attribution.toolUseId, toolName: attribution.toolName } : {}
+  });
+  const input = {
+    eventType: attribution ? eventType.replace(".external.", ".tool.") : eventType,
+    scope: context.scope,
+    correlation: {
+      ...context.correlation,
+      ...attribution ? { toolCallId: attribution.toolUseId } : {}
+    },
+    outcome: "success",
+    resource: {
+      kind: "file",
+      id: resourceId(relativePath),
+      path: normalizeRelative(relativePath),
+      ...state?.hash ? { contentHashAfter: state.hash } : {}
+    },
+    attributes: {
+      ...attributes,
+      actor: attribution ? "agent" : attributes["actor"],
+      source: attribution ? "tool" : "external",
+      toolName: attribution?.toolName,
+      size: state?.size,
+      mtimeMs: state?.mtimeMs,
+      observedBy: "fs.watch"
+    }
+  };
+  await options.journal.append(input);
+}
+function mutationAttribution(relativePath, recent) {
+  const value = recent.get(relativePath);
+  if (!value) return void 0;
+  recent.delete(relativePath);
+  return Date.now() - value.at <= 2e3 ? value : void 0;
+}
+async function scanProject(root, excluded, maxHashBytes, onError) {
+  const result = /* @__PURE__ */ new Map();
+  const dirs = [""];
+  while (dirs.length > 0) {
+    const relativeDir = dirs.pop();
+    try {
+      const entries = await fsp.readdir(path2.join(root, relativeDir), { withFileTypes: true });
+      for (const entry of entries) {
+        const relative2 = normalizeRelative(path2.join(relativeDir, entry.name));
+        if (entry.isDirectory()) {
+          if (!excluded.has(entry.name)) dirs.push(relative2);
+        } else if (entry.isFile()) {
+          const value = await fingerprint(path2.join(root, relative2), maxHashBytes);
+          if (value) result.set(relative2, value);
+        }
+      }
+    } catch (error) {
+      onError?.(error);
+    }
+  }
+  return result;
+}
+async function fingerprint(filePath, maxHashBytes) {
+  try {
+    const stat5 = await fsp.stat(filePath);
+    if (!stat5.isFile()) return void 0;
+    const base = { size: stat5.size, mtimeMs: stat5.mtimeMs };
+    if (stat5.size <= maxHashBytes) {
+      base.hash = createHash2("sha256").update(await fsp.readFile(filePath)).digest("hex");
+    }
+    return base;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function sameFingerprint(a, b) {
+  if (!a || !b) return a === b;
+  if (a.hash !== void 0 && b.hash !== void 0) return a.hash === b.hash;
+  return a.size === b.size && a.mtimeMs === b.mtimeMs;
+}
+function isExcluded(relative2, excluded) {
+  return normalizeRelative(relative2).split("/").some((segment) => excluded.has(segment));
+}
+function normalizeRelative(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function resourceId(relativePath) {
+  return `file_${createHash2("sha256").update(normalizeRelative(relativePath)).digest("hex").slice(0, 24)}`;
+}
+function unionKeys(a, b) {
+  return [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])];
+}
+
+// src/chronicle/journal.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import * as fs3 from "node:fs/promises";
+import * as path4 from "node:path";
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "node:crypto";
+import * as fs2 from "node:fs/promises";
+import { watch as watchDir } from "node:fs";
+import * as path3 from "node:path";
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+
+// src/utils/atomic-write.ts
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path3.dirname(targetPath);
+  await fs2.mkdir(dir, { recursive: true });
+  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs2.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs2.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat5 = await fs2.stat(targetPath);
+      mode = stat5.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs2.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+    if (mode !== void 0 && process.platform === "win32") {
+      try {
+        await fs2.chmod(targetPath, mode);
+      } catch {
+      }
+    }
+  } catch (err) {
+    try {
+      await fs2.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fs2.mkdir(dir, { recursive: true });
+}
+async function withFileLock(targetPath, fn, opts = {}) {
+  const dir = path3.dirname(targetPath);
+  await fs2.mkdir(dir, { recursive: true });
+  const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const staleMs = opts.staleMs ?? 3e4;
+  const started = Date.now();
+  let handle;
+  for (; ; ) {
+    try {
+      handle = await fs2.open(lockPath, "wx");
+      await handle.writeFile(`${process.pid}:${Date.now()}`);
+      break;
+    } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {
+        });
+        await fs2.unlink(lockPath).catch(() => {
+        });
+        handle = void 0;
+      }
+      const code = err.code;
+      if (code === "ENOENT") {
+        await fs2.mkdir(dir, { recursive: true });
+        continue;
+      }
+      if (code !== "EEXIST" && code !== "EPERM") throw err;
+      try {
+        const stat5 = await fs2.stat(lockPath);
+        if (Date.now() - stat5.mtimeMs > staleMs) {
+          await fs2.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeoutMs) {
+        throw new FsError({
+          message: `Timed out waiting for file lock: ${targetPath}`,
+          code: "FS_ATOMIC_WRITE_FAILED",
+          path: targetPath,
+          context: { timeoutMs }
+        });
+      }
+      await waitForLockRelease(lockPath, timeoutMs - elapsed);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await fs2.unlink(lockPath);
+    } catch {
+    }
+  }
+}
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path3.dirname(lockPath);
+  const lockName = path3.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve5) => {
+    let settled = false;
+    let watcher = null;
+    const timer = setTimeout(() => {
+      settled = true;
+      watcher?.close();
+      resolve5();
+    }, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (settled) return;
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve5();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        setTimeout(resolve5, Math.min(remainingMs, 25));
+      }
+      return;
+    }
+    fs2.access(lockPath).then(
+      () => {
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve5();
+        }
+      }
+    );
+  });
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs2.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fs2.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve5) => setTimeout(resolve5, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
+// src/chronicle/types.ts
+var CHRONICLE_SCHEMA_VERSION = 1;
+
+// src/chronicle/journal.ts
+var GENESIS_HASH = "0".repeat(64);
+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;
+  lastSequence = 0;
+  lastHash = GENESIS_HASH;
+  lastAutoPurgeAt = 0;
+  constructor(options) {
+    this.basePath = path4.resolve(options.filePath);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
+    this.idFactory = options.idFactory ?? randomUUID2;
+    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((resolve5, reject) => {
+      this.pending.push({ input, resolve: resolve5, 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 = path4.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 = path4.resolve(suppliedPath);
+      if (!isJournalPartition(file, path4.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 fs3.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 fs3.lstat(file);
+            if (!fileStat.isFile() || fileStat.mtimeMs > cutoff) return;
+            const entries = await readEntriesStrict(file);
+            const checkpointResult = await readRetentionCheckpoint(familyBase);
+            if (checkpointResult.error) throw new Error(checkpointResult.error);
+            const checkpoint = checkpointResult.checkpoint;
+            const nextCheckpoint = verifyRetainedPrefix(entries, 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 fs3.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;
+    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 entry = await readLastEntry(latest);
+    const checkpointResult = 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;
+    try {
+      this.partitionStartedAt = (await fs3.stat(latest)).birthtimeMs;
+    } catch {
+      this.partitionStartedAt = Date.now();
+    }
+  }
+  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)) {
+      try {
+        if ((await fs3.stat(this.path)).size >= this.maxPartitionSizeBytes) this.rotate();
+      } catch {
+      }
+    }
+  }
+  rotate() {
+    this.partitionIndex++;
+    this.partitionStartedAt = Date.now();
+    this.counters.partitionRolls++;
+  }
+  async persistBatch(batch) {
+    const started = performance.now();
+    this.counters.batches++;
+    this.counters.largestBatch = Math.max(this.counters.largestBatch, batch.length);
+    try {
+      await ensureDir(path4.dirname(this.basePath));
+      let recorded = [];
+      await withFileLock(this.basePath, async () => {
+        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 ni = removeUndefined(input);
+          const uh = { ...ni, 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;
+        });
+        await fs3.appendFile(cp, recorded.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+      });
+      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.counters.failedEvents += batch.length;
+      batch.forEach((item) => {
+        item.reject(error);
+      });
+    } finally {
+      this.lastBatchDurationMs = performance.now() - started;
+    }
+  }
+};
+function rotatedPath(basePath, index) {
+  const dir = path4.dirname(basePath);
+  const ext = path4.extname(basePath);
+  const base = path4.basename(basePath, ext);
+  return path4.join(dir, `${base}.${String(index).padStart(5, "0")}${ext}`);
+}
+async function collectPartitions(basePath) {
+  const dir = path4.dirname(basePath);
+  const ext = path4.extname(basePath);
+  const base = path4.basename(basePath, ext);
+  const pattern = new RegExp(`^${escapeRegex(base)}(?:\\.\\d{5})?${escapeRegex(ext)}$`);
+  const result = [];
+  try {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) if (entry.isFile() && pattern.test(entry.name)) result.push(path4.join(dir, entry.name));
+  } catch {
+  }
+  const baseFile = path4.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 = path4.dirname(basePath);
+  const result = [];
+  try {
+    const entries = await fs3.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const file = path4.join(directory, entry.name);
+      if (entry.isFile() && isJournalPartition(file, directory, basePath)) result.push(file);
+    }
+  } catch {
+  }
+  return result.sort(compareJournalPartitions);
+}
+function isJournalPartition(filePath, directory, basePath) {
+  if (path4.dirname(path4.resolve(filePath)) !== path4.resolve(directory)) return false;
+  const fileName = path4.basename(filePath);
+  if (!basePath) return false;
+  const baseName = path4.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(path4.resolve(filePath)) === partitionFamilyBase(path4.resolve(basePath));
+}
+function compareJournalPartitions(left, right) {
+  const pattern = /^(.*\.events)(?:\.(\d{5}))?\.jsonl$/;
+  const leftMatch = pattern.exec(path4.basename(left));
+  const rightMatch = pattern.exec(path4.basename(right));
+  const familyOrder = (leftMatch?.[1] ?? left).localeCompare(rightMatch?.[1] ?? right);
+  return familyOrder || Number(leftMatch?.[2] ?? 0) - Number(rightMatch?.[2] ?? 0);
+}
+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`;
+}
+function verifyRetainedPrefix(entries, checkpoint) {
+  if (entries.length === 0) return void 0;
+  let sequence = checkpoint?.sequence ?? 0;
+  let hash3 = checkpoint?.hash ?? GENESIS_HASH;
+  let advanced = false;
+  for (const entry of entries) {
+    if (entry.sequence <= sequence) continue;
+    if (entry.sequence !== sequence + 1 || entry.previousHash !== hash3) return void 0;
+    const { hash: recordedHash, ...content } = entry;
+    if (hashValue(content) !== recordedHash) return void 0;
+    sequence = entry.sequence;
+    hash3 = recordedHash;
+    advanced = true;
+  }
+  if (!advanced) return checkpoint;
+  return { version: RETENTION_CHECKPOINT_VERSION, sequence, hash: hash3 };
+}
+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) {
+    let chunk;
+    try {
+      chunk = await readEntriesStrict(file);
+    } catch (error) {
+      return { ok: false, entries, brokenAt: entries, reason: errorMessage(error) };
+    }
+    for (const entry of chunk) {
+      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;
+    }
+  }
+  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 fs3.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 = path4.basename(filePath).slice(base.length + 1, -ext.length);
+  return suffix ? parseInt(suffix, 10) : 0;
+}
+function partitionIndex(filePath, basePath) {
+  const ext = path4.extname(basePath);
+  return parseIndex(filePath, path4.basename(basePath, ext), ext);
+}
+function escapeRegex(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function readLastEntry(filePath) {
+  let handle;
+  try {
+    handle = await fs3.open(filePath, "r");
+  } catch (error) {
+    if (isNotFound(error)) return void 0;
+    throw error;
+  }
+  try {
+    const size = (await handle.stat()).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 JSON.parse(trimmed);
+        } catch {
+        }
+      }
+      suffix = lines[0] ?? "";
+    }
+    return void 0;
+  } finally {
+    await handle.close();
+  }
+}
+async function readEntriesStrict(filePath) {
+  let raw;
+  try {
+    raw = await fs3.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return [];
+    throw error;
+  }
+  const entries = [];
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+      throw new Error(`invalid JSON at line ${i + 1} in ${path4.basename(filePath)}`);
+    }
+  }
+  return entries;
+}
+function hashValue(value) {
+  return createHash3("sha256").update(stableStringify(value), "utf8").digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function removeUndefined(value) {
+  if (Array.isArray(value)) return value.map((item) => item === void 0 ? null : removeUndefined(item));
+  if (value === null || typeof value !== "object") return value;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) if (item !== void 0) result[key] = removeUndefined(item);
+  return result;
+}
+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/provider-adapter.ts
+function wireProviderAttemptsToChronicle(options) {
+  const unsubs = [
+    options.events.on("provider.attempt.started", (event) => persist(options, event, {
+      eventType: "provider.attempt.started",
+      outcome: "started",
+      occurredAt: event.startedAt
+    })),
+    options.events.on("provider.attempt.completed", (event) => persist(options, event, {
+      eventType: "provider.attempt.completed",
+      outcome: "success",
+      occurredAt: event.endedAt,
+      durationNs: millisecondsToNanoseconds(event.durationMs)
+    })),
+    options.events.on("provider.attempt.failed", (event) => persist(options, event, {
+      eventType: "provider.attempt.failed",
+      outcome: "failure",
+      occurredAt: event.endedAt,
+      durationNs: millisecondsToNanoseconds(event.durationMs)
+    }))
+  ];
+  return () => unsubs.forEach((unsubscribe) => {
+    unsubscribe();
+  });
+}
+function persist(options, event, base) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const input = {
+    ...base,
+    scope: {
+      ...context.scope,
+      sessionId: event.sessionId,
+      ...event.agentId ? { agentId: event.agentId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...event.traceId ? { traceId: event.traceId } : {},
+      logicalRequestId: event.logicalRequestId,
+      attemptId: event.attemptId
+    },
+    runtime: { providerId: event.providerId, modelId: event.model },
+    attributes: providerAttributes(event)
+  };
+  void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+}
+function providerAttributes(event) {
+  const {
+    sessionId: _sessionId,
+    traceId: _traceId,
+    agentId: _agentId,
+    providerId: _providerId,
+    model: _model,
+    logicalRequestId: _logicalRequestId,
+    attemptId: _attemptId,
+    ...attributes
+  } = event;
+  return attributes;
+}
+function millisecondsToNanoseconds(durationMs2) {
+  return Math.round(durationMs2 * 1e6).toString();
+}
+
+// src/chronicle/tool-adapter.ts
+import { createHash as createHash4 } from "node:crypto";
+function wireToolsToChronicle(options) {
+  const unsubs = [
+    options.events.on("tool.started", (event) => {
+      const input = scrubValue(options.scrubber, event.input);
+      persist2(options, event, {
+        eventType: "tool.started",
+        outcome: "started",
+        attributes: {
+          toolName: event.name,
+          input,
+          inputHash: hashText(input)
+        }
+      });
+    }),
+    options.events.on("tool.executed", (event) => {
+      const output = options.scrubber.scrub(event.output ?? "");
+      persist2(options, event, {
+        eventType: "tool.executed",
+        outcome: event.ok ? "success" : "failure",
+        durationNs: millisecondsToNanoseconds2(event.durationMs),
+        attributes: {
+          toolName: event.name,
+          ok: event.ok,
+          outputPreview: output,
+          outputHash: hashText(output),
+          outputBytes: event.outputBytes,
+          outputTokens: event.outputTokens,
+          outputLines: event.outputLines,
+          metadata: event.metadata
+        }
+      });
+      persistEvidenceEdges(options, event);
+    }),
+    options.events.on("tool.failed", (event) => persist2(options, event, {
+      eventType: "tool.failed",
+      outcome: "failure",
+      durationNs: millisecondsToNanoseconds2(event.durationMs),
+      attributes: {
+        toolName: event.name,
+        category: event.category,
+        retryable: event.retryable,
+        detail: event.detail,
+        errorCode: event.errorCode,
+        errorSubsystem: event.errorSubsystem,
+        errorSeverity: event.errorSeverity
+      }
+    })),
+    options.events.on("tool.progress", (event) => {
+      if (event.event.type !== "file_changed") return;
+      const resource = progressResource(event);
+      persist2(options, event, {
+        eventType: "file.mutation.observed",
+        outcome: "started",
+        ...resource ? { resource } : {},
+        attributes: {
+          toolName: event.name,
+          progressType: event.event.type,
+          text: options.scrubber.scrub(event.event.text ?? ""),
+          data: scrubValue(options.scrubber, event.event.data),
+          operation: event.event.operation
+        }
+      });
+    })
+  ];
+  return () => unsubs.forEach((unsubscribe) => {
+    unsubscribe();
+  });
+}
+function persist2(options, event, fields) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const input = {
+    ...fields,
+    scope: {
+      ...context.scope,
+      ...event.sessionId ? { sessionId: event.sessionId } : {},
+      ...event.agentId ? { agentId: event.agentId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...event.traceId ? { traceId: event.traceId } : {},
+      ...event.id ? { toolCallId: event.id } : {}
+    }
+  };
+  void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+}
+function persistEvidenceEdges(options, event) {
+  const metadata = event.metadata;
+  if (!metadata) return;
+  for (const file of metadata.files) {
+    persist2(options, event, {
+      eventType: "tool.resource.observed",
+      outcome: event.ok ? "success" : "failure",
+      resource: { kind: "file", id: resourceId2("file", file), path: file },
+      attributes: { relation: "observed", toolName: event.name, evidenceStatus: metadata.status }
+    });
+  }
+  for (const symbol of metadata.symbols) {
+    persist2(options, event, {
+      eventType: "tool.resource.observed",
+      outcome: event.ok ? "success" : "failure",
+      resource: { kind: "symbol", id: resourceId2("symbol", symbol) },
+      attributes: { relation: "observed", toolName: event.name, symbol }
+    });
+  }
+  for (const command of metadata.commands) {
+    persist2(options, event, {
+      eventType: "tool.resource.observed",
+      outcome: event.ok ? "success" : "failure",
+      resource: { kind: "process", id: resourceId2("command", command) },
+      attributes: { relation: "invoked", toolName: event.name, command: options.scrubber.scrub(command) }
+    });
+  }
+}
+function progressResource(event) {
+  if (event.event.type !== "file_changed" || !event.event.path) return void 0;
+  return {
+    kind: "file",
+    id: resourceId2("file", event.event.path),
+    path: event.event.path,
+    ...event.event.line !== void 0 ? { lineStart: event.event.line } : {},
+    ...event.event.endLine !== void 0 ? { lineEnd: event.event.endLine } : {}
+  };
+}
+function scrubValue(scrubber, value) {
+  if (value === void 0) return "";
+  try {
+    return scrubber.scrub(JSON.stringify(value));
+  } catch {
+    return scrubber.scrub(String(value));
+  }
+}
+function resourceId2(kind, value) {
+  return `${kind}_${hashText(value).slice(0, 24)}`;
+}
+function hashText(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
+function millisecondsToNanoseconds2(durationMs2) {
+  return Math.round(durationMs2 * 1e6).toString();
+}
+
+// src/chronicle/process-adapter.ts
+import { createHash as createHash5 } from "node:crypto";
+function wireProcessesToChronicle(options) {
+  const unsubs = [
+    options.events.on("process.started", (event) => persist3(options, event, {
+      eventType: "process.started",
+      outcome: "started",
+      occurredAt: event.startedAt,
+      attributes: {
+        command: options.scrubber.scrub(event.command),
+        args: event.args.map((arg) => options.scrubber.scrub(arg)),
+        cwd: event.cwd,
+        parentPid: event.parentPid,
+        background: event.background
+      }
+    })),
+    options.events.on("process.completed", (event) => persist3(options, event, {
+      eventType: "process.completed",
+      outcome: event.exitCode === 0 ? "success" : event.timedOut ? "cancelled" : "failure",
+      occurredAt: event.endedAt,
+      durationNs: Math.round(event.durationMs * 1e6).toString(),
+      attributes: {
+        exitCode: event.exitCode,
+        signal: event.signal,
+        stdoutBytes: event.stdoutBytes,
+        stderrBytes: event.stderrBytes,
+        timedOut: event.timedOut
+      }
+    }))
+  ];
+  return () => unsubs.forEach((unsubscribe) => {
+    unsubscribe();
+  });
+}
+function persist3(options, event, fields) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const processKey = `${event.sessionId}\0${event.pid ?? "unknown"}\0${event.toolCallId}`;
+  const input = {
+    ...fields,
+    scope: {
+      ...context.scope,
+      sessionId: event.sessionId,
+      ...event.agentId ? { agentId: event.agentId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...event.traceId ? { traceId: event.traceId } : {},
+      toolCallId: event.toolCallId
+    },
+    runtime: {
+      ...event.pid !== void 0 ? { processId: event.pid } : {},
+      ..."parentPid" in event ? { parentProcessId: event.parentPid } : {}
+    },
+    resource: {
+      kind: "process",
+      id: `process_${createHash5("sha256").update(processKey).digest("hex").slice(0, 24)}`
+    }
+  };
+  void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+}
+
+// src/chronicle/health-monitor.ts
+import { monitorEventLoopDelay, performance as performance2 } from "node:perf_hooks";
+function startChronicleHealthMonitor(options) {
+  const intervalMs = Math.max(5e3, options.intervalMs ?? 3e4);
+  const delay = monitorEventLoopDelay({ resolution: 20 });
+  delay.enable();
+  let previousCpu = process.cpuUsage();
+  let previousElu = performance2.eventLoopUtilization();
+  const sample = () => {
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const memory = process.memoryUsage();
+    const cpu = process.cpuUsage(previousCpu);
+    previousCpu = process.cpuUsage();
+    const elu = performance2.eventLoopUtilization(previousElu);
+    previousElu = performance2.eventLoopUtilization();
+    const journalBeforeSample = options.journal.stats();
+    void options.journal.append({
+      eventType: "runtime.health.sampled",
+      scope: context.scope,
+      correlation: context.correlation,
+      runtime: { processId: process.pid, parentProcessId: process.ppid },
+      outcome: "success",
+      resource: { kind: "process", id: `process:${process.pid}` },
+      attributes: {
+        uptimeSeconds: process.uptime(),
+        eventLoop: {
+          utilization: elu.utilization,
+          activeMs: elu.active,
+          idleMs: elu.idle,
+          delayMeanMs: Number(delay.mean) / 1e6,
+          delayP95Ms: Number(delay.percentile(95)) / 1e6,
+          delayMaxMs: Number(delay.max) / 1e6
+        },
+        cpu: { userMicros: cpu.user, systemMicros: cpu.system },
+        memory: {
+          rssBytes: memory.rss,
+          heapTotalBytes: memory.heapTotal,
+          heapUsedBytes: memory.heapUsed,
+          externalBytes: memory.external,
+          arrayBuffersBytes: memory.arrayBuffers
+        },
+        chronicle: journalBeforeSample
+      }
+    }).catch((error) => options.onPersistError?.(error));
+    delay.reset();
+  };
+  const timer = setInterval(sample, intervalMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+    delay.disable();
+  };
+}
+
+// src/chronicle/decision-adapter.ts
+import { createHash as createHash6 } from "node:crypto";
+function wireDecisionsToChronicle(options) {
+  const write = (eventType, at, sessionId, requestId, attributes, outcome) => {
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const input = {
+      eventType,
+      occurredAt: new Date(at).toISOString(),
+      outcome,
+      scope: { ...context.scope, ...sessionId ? { sessionId } : {} },
+      correlation: context.correlation,
+      resource: { kind: "other", id: `decision:${requestId}` },
+      attributes: { decisionId: requestId, ...attributes }
+    };
+    void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+  };
+  const requestAttrs = (request) => ({
+    source: request.source,
+    risk: request.risk,
+    fallback: request.fallback,
+    questionHash: hash(request.question),
+    contextHash: hash(request.context),
+    optionCount: request.options?.length ?? 0,
+    options: request.options?.map((option) => ({
+      id: option.id,
+      risk: option.risk,
+      recommended: option.recommended ?? false,
+      labelHash: hash(option.label),
+      consequenceHash: hash(option.consequence)
+    }))
+  });
+  const decisionAttrs = (decision) => ({
+    type: decision.type,
+    ..."optionId" in decision && decision.optionId ? { optionId: decision.optionId } : {},
+    contentHash: hash("text" in decision ? decision.text : "prompt" in decision ? decision.prompt : decision.reason),
+    rationaleHash: hash("rationale" in decision ? decision.rationale : void 0)
+  });
+  const offs = [
+    options.events.on("brain.decision_requested", (e) => write("decision.requested", e.at, e.sessionId, e.request.id, requestAttrs(e.request), "started")),
+    options.events.on("brain.decision_answered", (e) => write("decision.resolved", e.at, e.sessionId, e.request.id, { ...requestAttrs(e.request), ...decisionAttrs(e.decision), resolver: "brain" }, "success")),
+    options.events.on("brain.decision_ask_human", (e) => write("decision.escalated", e.at, e.sessionId, e.request.id, { ...requestAttrs(e.request), ...decisionAttrs(e.decision) }, "started")),
+    options.events.on("brain.decision_denied", (e) => write("decision.denied", e.at, e.sessionId, e.request.id, { ...requestAttrs(e.request), ...decisionAttrs(e.decision) }, "denied")),
+    options.events.on("brain.human_answered", (e) => write("decision.human_answered", e.at, e.sessionId, e.id, { resolver: "human", optionId: e.optionId, denied: e.deny ?? false, answerHash: hash(e.text) }, e.deny ? "denied" : "success")),
+    options.events.on("brain.outcome", (e) => write("decision.outcome_observed", e.at, e.sessionId, e.requestId, { observedOutcome: e.outcome, detailHash: hash(e.detail) }, e.outcome))
+  ];
+  return () => offs.forEach((off) => {
+    off();
+  });
+}
+function hash(value) {
+  return value ? createHash6("sha256").update(value).digest("hex") : void 0;
+}
+
+// src/chronicle/domain-adapter.ts
+import { createHash as createHash7 } from "node:crypto";
+var SPECIALIZED = [
+  /^provider\.attempt\./,
+  /^tool\./,
+  /^process\./,
+  /^brain\.decision_/,
+  /^brain\.human_answered$/,
+  /^brain\.outcome$/,
+  /^file\.activity$/,
+  /^provider\.(?:text_delta|thinking_delta)$/,
+  /^(?:ctx\.pct|subagent\.ctx_pct|countdown\.tick|coordinator\.stats)$/
+];
+var CODING_SIGNAL = [
+  /^(?:agent|subagent|delegate|fleet)\./,
+  /^(?:session|iteration|context|compaction|checkpoint|in_flight)\./,
+  /^(?:memory|storage|trust)\./,
+  /^(?:sdd|worktree)\./,
+  /^(?:brain|token|budget|concurrency)\./,
+  /^(?:provider|mcp|network)\./,
+  /^error$/
+];
+var SENSITIVE_KEY = /(content|text|prompt|question|rationale|reason|detail|summary|description|context|input|output|error|message|secret|token|password|key)$/i;
+var PRESERVE_STRING_KEY = /(^|_)(id|status|state|kind|type|source|model|provider|phase|risk|fallback|path|name|role|sha|branch|mode)$/i;
+var TRUNCATED_ARRAYS = /* @__PURE__ */ new Set(["recentMail", "recentTools", "recentCommands"]);
+var TRUNCATED_ARRAY_MAX = 5;
+var DEFAULT_ARRAY_MAX = 20;
+function wireDomainEventsToChronicle(options) {
+  return options.events.onAny((eventName, payload) => {
+    if (SPECIALIZED.some((pattern) => pattern.test(eventName))) return;
+    if (!CODING_SIGNAL.some((pattern) => pattern.test(eventName))) return;
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const record = objectPayload(payload);
+    const sessionId = stringField(record, "sessionId");
+    const agentId = stringField(record, "agentId") ?? stringField(record, "subagentId");
+    const taskId = stringField(record, "taskId");
+    const input = {
+      eventType: eventName,
+      occurredAt: eventTime(record),
+      scope: { ...context.scope, ...sessionId ? { sessionId } : {}, ...agentId ? { agentId } : {}, ...taskId ? { taskId } : {} },
+      correlation: {
+        ...context.correlation,
+        ...stringField(record, "traceId") ? { traceId: stringField(record, "traceId") } : {},
+        ...stringField(record, "toolCallId") ? { toolCallId: stringField(record, "toolCallId") } : {},
+        ...stringField(record, "attemptId") ? { attemptId: stringField(record, "attemptId") } : {},
+        ...stringField(record, "logicalRequestId") ? { logicalRequestId: stringField(record, "logicalRequestId") } : {}
+      },
+      outcome: inferOutcome(eventName, record),
+      runtime: {
+        ...stringField(record, "providerId") ?? stringField(record, "provider") ? { providerId: stringField(record, "providerId") ?? stringField(record, "provider") } : {},
+        ...stringField(record, "modelId") ?? stringField(record, "model") ? { modelId: stringField(record, "modelId") ?? stringField(record, "model") } : {}
+      },
+      resource: inferResource(record),
+      attributes: sanitize(record),
+      tags: { collector: "eventbus-domain", family: eventName.split(".")[0] ?? "unknown" }
+    };
+    void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+  });
+}
+function objectPayload(value) {
+  return value && typeof value === "object" ? value : { value };
+}
+function stringField(value, key) {
+  return typeof value[key] === "string" ? value[key] : void 0;
+}
+function eventTime(value) {
+  const raw = value.at ?? value.ts ?? value.timestamp;
+  if (typeof raw === "number" && Number.isFinite(raw)) return new Date(raw).toISOString();
+  if (typeof raw === "string" && Number.isFinite(Date.parse(raw))) return new Date(raw).toISOString();
+  return void 0;
+}
+function inferOutcome(name, payload) {
+  if (payload.ok === false || /(?:failed|error|damaged|conflict|deadlock|denied|rejected|blocked)$/.test(name)) return "failure";
+  if (/(?:started|starting|retrying|threshold_reached)$/.test(name)) return "started";
+  if (/(?:cancelled|aborted)$/.test(name)) return "cancelled";
+  if (/(?:completed|finished|committed|merged|written|persisted|accepted|recovered|verified|connected|success)$/.test(name) || payload.ok === true) return "success";
+  return "unknown";
+}
+function inferResource(payload) {
+  const candidates = [
+    ["memory", "memoryId", payload.memoryId],
+    ["task", "taskId", payload.taskId],
+    ["kanban", "boardId", payload.boardId ?? payload.runId],
+    ["artifact", "worktreeId", payload.worktreeId ?? payload.handleId],
+    ["file", "path", payload.filePath ?? payload.path],
+    ["other", "agentId", payload.agentId ?? payload.subagentId],
+    ["network", "serverAddress", payload.serverAddress],
+    ["other", "sessionId", payload.sessionId]
+  ];
+  const found = candidates.find(([, , value2]) => typeof value2 === "string" && value2.length > 0);
+  if (!found) return void 0;
+  const [kind, label, value] = found;
+  return { kind, id: `${label}:${value}`, ...kind === "file" ? { path: value } : {} };
+}
+function sanitize(value, key = "", depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "function") return { type: "function" };
+  if (typeof value === "string") {
+    if (PRESERVE_STRING_KEY.test(key) && !SENSITIVE_KEY.test(key)) return value.slice(0, 512);
+    if (SENSITIVE_KEY.test(key)) return { hash: digest(value), length: value.length, redacted: true };
+    return value.length <= 256 ? value : { hash: digest(value), length: value.length, truncated: true };
+  }
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return { circular: true };
+  if (depth >= 5) return { hash: digest(safeString(value)), depthLimited: true };
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const cap = TRUNCATED_ARRAYS.has(key) ? TRUNCATED_ARRAY_MAX : DEFAULT_ARRAY_MAX;
+    const items = value.slice(0, cap).map((item) => sanitize(item, key, depth + 1, seen));
+    return value.length > cap ? { items, total: value.length, truncated: true } : items;
+  }
+  const output = {};
+  const entries = Object.entries(value);
+  for (const [childKey, child] of entries.slice(0, 100)) {
+    if (childKey === "ctx" || childKey === "provider" || childKey === "resolve" || childKey === "extend" || childKey === "deny") continue;
+    output[childKey] = sanitize(child, childKey, depth + 1, seen);
+  }
+  if (entries.length > 100) output._truncatedKeys = entries.length - 100;
+  return output;
+}
+function safeString(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function digest(value) {
+  return createHash7("sha256").update(value).digest("hex");
+}
+
+// src/chronicle/stream-adapter.ts
+import { createHash as createHash8 } from "node:crypto";
+function wireProviderStreamsToChronicle(options) {
+  const states = /* @__PURE__ */ new Map();
+  const key = (sessionId, agentId) => `${sessionId ?? "__default__"}\0${agentId ?? "__leader__"}`;
+  const update = (sessionId, agentId, text2, thinking) => {
+    const state = states.get(key(sessionId, agentId));
+    if (!state) return;
+    const now = Date.now();
+    const bytes = Buffer.byteLength(text2);
+    state.firstChunkAtMs ??= now;
+    state.lastChunkAtMs = now;
+    if (thinking) {
+      state.thinkingChunks++;
+      state.thinkingBytes += bytes;
+      state.thinkingHash.update(text2);
+    } else {
+      state.textChunks++;
+      state.textBytes += bytes;
+      state.textHash.update(text2);
+    }
+  };
+  const flush = (sessionId, agentId, outcome) => {
+    const state = states.get(key(sessionId, agentId));
+    if (!state) return;
+    states.delete(key(sessionId, agentId));
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const endedAtMs = Date.now();
+    const input = {
+      eventType: "provider.stream.summarized",
+      outcome,
+      scope: { ...context.scope, ...state.sessionId ? { sessionId: state.sessionId } : {}, ...state.agentId ? { agentId: state.agentId } : {} },
+      correlation: { ...context.correlation, attemptId: state.attemptId, logicalRequestId: state.logicalRequestId },
+      runtime: { providerId: state.providerId, modelId: state.model },
+      durationNs: String(Math.max(0, endedAtMs - state.startedAtMs) * 1e6),
+      attributes: {
+        textChunks: state.textChunks,
+        textBytes: state.textBytes,
+        thinkingChunks: state.thinkingChunks,
+        thinkingBytes: state.thinkingBytes,
+        textHash: state.textHash.digest("hex"),
+        thinkingHash: state.thinkingHash.digest("hex"),
+        firstChunkLatencyMs: state.firstChunkAtMs === void 0 ? void 0 : state.firstChunkAtMs - state.startedAtMs,
+        streamActiveMs: state.firstChunkAtMs === void 0 || state.lastChunkAtMs === void 0 ? 0 : state.lastChunkAtMs - state.firstChunkAtMs
+      }
+    };
+    void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+  };
+  const offs = [
+    options.events.on("provider.attempt.started", (event) => states.set(key(event.sessionId, event.agentId), {
+      sessionId: event.sessionId,
+      ...event.agentId ? { agentId: event.agentId } : {},
+      attemptId: event.attemptId,
+      logicalRequestId: event.logicalRequestId,
+      providerId: event.providerId,
+      model: event.model,
+      startedAtMs: Date.parse(event.startedAt),
+      textChunks: 0,
+      textBytes: 0,
+      thinkingChunks: 0,
+      thinkingBytes: 0,
+      textHash: createHash8("sha256"),
+      thinkingHash: createHash8("sha256")
+    })),
+    options.events.on("provider.text_delta", (event) => update(event.sessionId, event.ctx.agentId, event.text, false)),
+    options.events.on("provider.thinking_delta", (event) => update(event.sessionId, event.ctx.agentId, event.text, true)),
+    options.events.on("provider.attempt.completed", (event) => flush(event.sessionId, event.agentId, "success")),
+    options.events.on("provider.attempt.failed", (event) => flush(event.sessionId, event.agentId, "failure"))
+  ];
+  return () => {
+    for (const state of [...states.values()]) flush(state.sessionId, state.agentId, "failure");
+    offs.forEach((off) => {
+      off();
+    });
+  };
+}
+
+// src/chronicle/prompt-manifest.ts
+import { createHash as createHash9 } from "node:crypto";
+function createChroniclePromptManifest(request) {
+  const roleCounts = {}, blockCounts = {};
+  const messages = request.messages.map((message, index) => messageSummary(message, index, roleCounts, blockCounts));
+  const systemText = (request.system ?? []).map((block) => block.text).join("\n");
+  const toolRecords = (request.tools ?? []).map((tool) => ({
+    name: tool.name,
+    schemaHash: hash2(stable(tool.inputSchema)),
+    permission: tool.permission,
+    mutating: tool.mutating,
+    riskTier: tool.riskTier,
+    capabilities: tool.capabilities,
+    estimatedTokens: tool._estDefTokens ?? 0
+  }));
+  const core = {
+    systemHash: hash2(systemText),
+    messages: messages.map(({ hash: contentHash, ...rest }) => ({ ...rest, contentHash })),
+    tools: toolRecords,
+    model: request.model,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    topK: request.topK,
+    seed: request.seed,
+    toolChoice: request.toolChoice,
+    reasoning: request.reasoning,
+    cache: request.cache,
+    responseFormat: request.responseFormat?.type
+  };
+  return {
+    manifestId: `prompt_${hash2(stable(core))}`,
+    messageCount: messages.length,
+    estimatedMessageTokens: messages.reduce((sum, message) => sum + (message.estimatedTokens ?? 0), 0),
+    contentBytes: messages.reduce((sum, message) => sum + message.bytes, 0) + Buffer.byteLength(systemText),
+    roleCounts,
+    blockCounts,
+    system: { blockCount: request.system?.length ?? 0, bytes: Buffer.byteLength(systemText), hash: hash2(systemText) },
+    messages,
+    tools: {
+      count: toolRecords.length,
+      estimatedDefinitionTokens: toolRecords.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
+      manifestHash: hash2(stable(toolRecords)),
+      names: toolRecords.map((tool) => tool.name),
+      mutating: toolRecords.filter((tool) => tool.mutating).length,
+      destructive: toolRecords.filter((tool) => tool.riskTier === "destructive").length
+    },
+    request: {
+      maxTokens: request.maxTokens,
+      temperature: request.temperature,
+      topP: request.topP,
+      topK: request.topK,
+      frequencyPenalty: request.frequencyPenalty,
+      presencePenalty: request.presencePenalty,
+      seed: request.seed,
+      candidateCount: request.candidateCount,
+      logprobs: request.logprobs,
+      topLogprobs: request.topLogprobs,
+      stopSequenceCount: request.stopSequences?.length ?? 0,
+      toolChoice: request.toolChoice,
+      reasoning: request.reasoning,
+      cache: request.cache,
+      responseFormat: request.responseFormat?.type,
+      safetySettingCount: request.safetySettings?.length ?? 0,
+      userHash: request.user ? hash2(request.user) : void 0
+    }
+  };
+}
+function messageSummary(message, index, roles, totals) {
+  roles[message.role] = (roles[message.role] ?? 0) + 1;
+  const blocks = typeof message.content === "string" ? { text: 1 } : countBlocks(message.content);
+  for (const [type, count] of Object.entries(blocks)) totals[type] = (totals[type] ?? 0) + count;
+  const content = contentIdentity(message.content);
+  return {
+    index,
+    role: message.role,
+    bytes: content.bytes,
+    ...message._estTokens !== void 0 ? { estimatedTokens: message._estTokens } : {},
+    hash: content.hash,
+    blocks
+  };
+}
+function countBlocks(blocks) {
+  const counts = {};
+  for (const block of blocks) counts[block.type] = (counts[block.type] ?? 0) + 1;
+  return counts;
+}
+function hash2(value) {
+  return createHash9("sha256").update(value).digest("hex");
+}
+function contentIdentity(content) {
+  if (typeof content === "string") return { hash: hash2(content), bytes: Buffer.byteLength(content) };
+  const digest2 = createHash9("sha256");
+  let bytes = 0;
+  const add = (value) => {
+    if (!value) return;
+    digest2.update(value);
+    bytes += Buffer.byteLength(value);
+  };
+  for (const block of content) {
+    add(block.type);
+    if (block.type === "text") add(block.text);
+    else if (block.type === "thinking") {
+      add(block.thinking);
+      add(block.signature);
+    } else if (block.type === "tool_use") {
+      add(block.id);
+      add(block.name);
+      add(stable(block.input));
+    } else if (block.type === "tool_result") {
+      add(block.tool_use_id);
+      add(block.name);
+      add(block.content);
+      add(String(block.is_error ?? false));
+    } else if (block.type === "image") {
+      add(block.source.type);
+      add(block.source.media_type);
+      add(block.source.url);
+      add(block.source.data);
+    }
+  }
+  return { hash: digest2.digest("hex"), bytes };
+}
+function stable(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
+}
+
+// src/chronicle/rollup-adapter.ts
+import { createHash as createHash10 } from "node:crypto";
+function wireRollupsToChronicle(options) {
+  const buckets = /* @__PURE__ */ new Map();
+  const windowMs = Math.max(1e3, options.windowMs ?? 1e4);
+  const bucket = (key, seed) => {
+    let value = buckets.get(key);
+    if (!value) {
+      const now = Date.now();
+      value = {
+        ...seed,
+        startedAt: now,
+        updatedAt: now,
+        count: 0,
+        metrics: {},
+        categories: {},
+        digest: createHash10("sha256")
+      };
+      buckets.set(key, value);
+    }
+    return value;
+  };
+  const sample = (target, values, category, digest2) => {
+    target.count++;
+    target.updatedAt = Date.now();
+    for (const [name, value] of Object.entries(values)) {
+      const metric = target.metrics[name];
+      target.metrics[name] = metric ? { sum: metric.sum + value, min: Math.min(metric.min, value), max: Math.max(metric.max, value), last: value } : { sum: value, min: value, max: value, last: value };
+    }
+    if (category) target.categories[category] = (target.categories[category] ?? 0) + 1;
+    if (digest2) target.digest.update(digest2);
+  };
+  const flush = (key) => {
+    const value = buckets.get(key);
+    if (!value || value.count === 0) return;
+    buckets.delete(key);
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const stats = Object.fromEntries(Object.entries(value.metrics).map(([name, metric]) => [name, { ...metric, avg: metric.sum / value.count }]));
+    const input = {
+      eventType: "metrics.rollup",
+      outcome: "success",
+      occurredAt: new Date(value.updatedAt).toISOString(),
+      scope: { ...context.scope, ...value.sessionId ? { sessionId: value.sessionId } : {}, ...value.agentId ? { agentId: value.agentId } : {} },
+      correlation: { ...context.correlation, ...value.toolCallId ? { toolCallId: value.toolCallId } : {} },
+      durationNs: String(Math.max(0, value.updatedAt - value.startedAt) * 1e6),
+      attributes: {
+        signal: value.signal,
+        windowStart: new Date(value.startedAt).toISOString(),
+        windowEnd: new Date(value.updatedAt).toISOString(),
+        samples: value.count,
+        dimensions: value.dimensions,
+        stats,
+        categories: value.categories,
+        digest: value.digest.digest("hex"),
+        rawEventsRetained: false
+      }
+    };
+    void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+  };
+  const gauge = (signal, event, dimension) => {
+    const sessionId = text(event.sessionId);
+    const dimensionValue = dimension ? text(event[dimension]) : void 0;
+    const key = `${signal}\0${sessionId ?? ""}\0${dimensionValue ?? ""}`;
+    const target = bucket(key, { signal, ...sessionId ? { sessionId } : {}, ...dimensionValue ? { agentId: dimensionValue } : {}, dimensions: dimensionValue && dimension ? { [dimension]: dimensionValue } : {} });
+    sample(target, Object.fromEntries(Object.entries(event).filter(([, value]) => typeof value === "number")));
+  };
+  const offs = [
+    options.events.on("process.output", (event) => {
+      const key = `process.output\0${event.sessionId}\0${event.toolCallId}\0${event.pid ?? ""}\0${event.stream}`;
+      const target = bucket(key, {
+        signal: "process.output",
+        sessionId: event.sessionId,
+        ...event.agentId ? { agentId: event.agentId } : {},
+        toolCallId: event.toolCallId,
+        dimensions: { stream: event.stream, toolName: event.toolName, pid: String(event.pid ?? "") }
+      });
+      sample(target, { bytes: event.bytes }, event.stream, event.chunkHash);
+    }),
+    options.events.on("process.completed", (event) => {
+      for (const key of [...buckets.keys()]) if (key.startsWith(`process.output\0${event.sessionId}\0${event.toolCallId}\0`)) flush(key);
+    }),
+    options.events.on("tool.progress", (event) => {
+      if (event.event.type === "file_changed") return;
+      const key = `tool.progress\0${event.sessionId ?? ""}\0${event.id}`;
+      const target = bucket(key, { signal: "tool.progress", ...event.sessionId ? { sessionId: event.sessionId } : {}, ...event.agentId ? { agentId: event.agentId } : {}, toolCallId: event.id, dimensions: { toolName: event.name } });
+      sample(target, { textBytes: Buffer.byteLength(event.event.text ?? "") }, event.event.type, safeDigest(event.event));
+    }),
+    options.events.on("tool.executed", (event) => flush(`tool.progress\0${event.sessionId ?? ""}\0${event.id ?? ""}`)),
+    options.events.on("tool.failed", (event) => flush(`tool.progress\0${event.sessionId}\0${event.id}`)),
+    options.events.on("ctx.pct", (event) => gauge("ctx.pct", event)),
+    options.events.on("subagent.ctx_pct", (event) => gauge("subagent.ctx_pct", event, "subagentId")),
+    options.events.on("countdown.tick", (event) => gauge("countdown.tick", event)),
+    options.events.on("coordinator.stats", (event) => gauge("coordinator.stats", event))
+  ];
+  const timer = setInterval(() => {
+    const cutoff = Date.now() - windowMs;
+    for (const [key, value] of buckets) if (value.updatedAt <= cutoff) flush(key);
+  }, windowMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+    for (const key of [...buckets.keys()]) flush(key);
+    offs.forEach((off) => {
+      off();
+    });
+  };
+}
+function text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function safeDigest(value) {
+  try {
+    return createHash10("sha256").update(JSON.stringify(value)).digest("hex");
+  } catch {
+    return "unhashable";
+  }
+}
+
+// src/chronicle/query.ts
+import { createHash as createHash11 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fs4 from "node:fs/promises";
+import * as path5 from "node:path";
+import { createInterface } from "node:readline";
+var MAX_CURSOR_SNAPSHOT_ENTRIES = 1e4;
+function streamLines(filePath, maxBytes) {
+  const stream = createReadStream(filePath, {
+    encoding: "utf8",
+    highWaterMark: 256 * 1024,
+    ...maxBytes !== void 0 ? { end: maxBytes - 1 } : {}
+  });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  return rl[Symbol.asyncIterator]();
+}
+var ChronicleQueryEngine = class _ChronicleQueryEngine {
+  constructor(files, diagnostics) {
+    this.diagnostics = diagnostics;
+    this.partitionFiles = files;
+  }
+  diagnostics;
+  partitionFiles;
+  static async fromDirectory(directory) {
+    const files = await findPartitions(path5.resolve(directory));
+    return new _ChronicleQueryEngine(files, { sourceFiles: files.length, invalidLines: 0 });
+  }
+  static async fromFiles(files) {
+    return new _ChronicleQueryEngine(files, { sourceFiles: files.length, invalidLines: 0 });
+  }
+  /** 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;
+        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);
+    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 and compute facet value counts. */
+  async facet(field, query = {}, limit = 100) {
+    const counts = /* @__PURE__ */ new Map();
+    let invalidLines = 0;
+    for (const file of this.partitionFiles) {
+      try {
+        for await (const line of streamLines(file)) {
+          if (!line.trim()) continue;
+          let event;
+          try {
+            event = JSON.parse(line);
+            if (!isChronicleEvent(event)) {
+              invalidLines++;
+              continue;
+            }
+          } catch {
+            invalidLines++;
+            continue;
+          }
+          if (!matches(event, query)) continue;
+          const value = facetValue(event, field);
+          if (value !== void 0) counts.set(value, (counts.get(value) ?? 0) + 1);
+        }
+      } catch {
+      }
+    }
+    this.diagnostics.invalidLines = invalidLines;
+    return [...counts].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count || a.value.localeCompare(b.value)).slice(0, Math.max(0, limit));
+  }
+  /** 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 fs4.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 },
+    failuresByFamily: { llm: 0, agent: 0, tool: 0, file: 0, memory: 0, task: 0, decision: 0, runtime: 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 findPartitions(root) {
+  const result = [];
+  const partitionName = /^(.*\.events)(?:\.(\d{5}))?\.jsonl$/;
+  const visit = async (directory) => {
+    let entries;
+    try {
+      entries = await fs4.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() && partitionName.test(entry.name)) result.push(full);
+    }
+  };
+  await visit(root);
+  return result.sort((left, right) => {
+    const leftMatch = partitionName.exec(path5.basename(left));
+    const rightMatch = partitionName.exec(path5.basename(right));
+    const leftGroup = path5.join(path5.dirname(left), leftMatch?.[1] ?? left);
+    const rightGroup = path5.join(path5.dirname(right), rightMatch?.[1] ?? right);
+    const groupOrder = leftGroup.localeCompare(rightGroup);
+    if (groupOrder !== 0) return groupOrder;
+    return Number(leftMatch?.[2] ?? 0) - Number(rightMatch?.[2] ?? 0);
+  });
+}
+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 (event.eventType.startsWith("decision.") || event.eventType.startsWith("brain.")) 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";
+  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.attributes?.promptManifest?.manifestId, "explicit");
+  add("resource_lineage", event.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.attemptId, event.correlation.attemptId) || !equal(query.toolCallId, event.correlation.toolCallId)) return false;
+  if (!equal(query.resourceKind, event.resource?.kind) || !equal(query.resourceId, event.resource?.id)) return false;
+  if (query.path && normalize2(event.resource?.path) !== normalize2(query.path)) return false;
+  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 normalize2(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 createHash11("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 fs4.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 fs4.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 createHash11("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",
+    "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];
+}
+export {
+  CHRONICLE_SCHEMA_VERSION,
+  ChronicleJournal,
+  ChronicleQueryEngine,
+  GENESIS_HASH,
+  childChronicleContext,
+  createChronicleContext,
+  createChroniclePromptManifest,
+  resolveChronicleRuntimeLocation,
+  startChronicleFileObserver,
+  startChronicleHealthMonitor,
+  wireDecisionsToChronicle,
+  wireDomainEventsToChronicle,
+  wireProcessesToChronicle,
+  wireProviderAttemptsToChronicle,
+  wireProviderStreamsToChronicle,
+  wireRollupsToChronicle,
+  wireToolsToChronicle
+};
+//# sourceMappingURL=index.js.map