@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-NEMIWEXC.js

@@ -0,0 +1,1199 @@
+import {
+  isPidAlive
+} from "./chunk-TRT2HRWZ.js";
+import {
+  withSqliteExperimentalWarningSuppressed
+} from "./chunk-LX5QWLBL.js";
+
+// src/chronicle/sqlite-compaction.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
+var ChronicleCompactionBusyError = class extends Error {
+  constructor(pid) {
+    super(`Chronicle project server is still running (pid ${pid}); stop it before compacting`);
+    this.name = "ChronicleCompactionBusyError";
+  }
+};
+function chronicleSqliteAllocatedBytes(dbPath) {
+  return [dbPath, `${dbPath}-wal`, `${dbPath}-shm`].reduce((total, file) => {
+    try {
+      return total + statSync(file).size;
+    } catch (error) {
+      if (error.code === "ENOENT") return total;
+      throw error;
+    }
+  }, 0);
+}
+function compactChronicleSqlite(options) {
+  assertProjectServerStopped(options.endpointMetadataPath);
+  const beforeBytes = chronicleSqliteAllocatedBytes(options.dbPath);
+  if (!existsSync(options.dbPath)) {
+    return { beforeBytes, afterBytes: beforeBytes, reclaimedBytes: 0 };
+  }
+  const Database = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync);
+  const db = new Database(options.dbPath);
+  try {
+    db.exec("PRAGMA busy_timeout = 1");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    db.exec("VACUUM");
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  } finally {
+    db.close();
+  }
+  const afterBytes = chronicleSqliteAllocatedBytes(options.dbPath);
+  return {
+    beforeBytes,
+    afterBytes,
+    reclaimedBytes: Math.max(0, beforeBytes - afterBytes)
+  };
+}
+function assertProjectServerStopped(endpointMetadataPath) {
+  if (!endpointMetadataPath || !existsSync(endpointMetadataPath)) return;
+  try {
+    const metadata = JSON.parse(readFileSync(endpointMetadataPath, "utf8"));
+    if (typeof metadata.pid === "number" && isPidAlive(metadata.pid)) {
+      throw new ChronicleCompactionBusyError(metadata.pid);
+    }
+  } catch (error) {
+    if (error instanceof ChronicleCompactionBusyError) throw error;
+  }
+}
+
+// src/chronicle/provider-adapter.ts
+function wireProviderAttemptsToChronicle(options) {
+  const seenToolManifests = /* @__PURE__ */ new Set();
+  const unsubs = [
+    options.events.on("provider.attempt.started", (event) => persist(options, event, {
+      eventType: "provider.attempt.started",
+      outcome: "started",
+      occurredAt: event.startedAt
+    }, seenToolManifests)),
+    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, seenToolManifests) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const input = {
+    ...base,
+    scope: {
+      ...context.scope,
+      sessionId: event.sessionId,
+      ...event.agentId ? { agentId: event.agentId } : {},
+      ...event.taskId ? { taskId: event.taskId } : {},
+      ...event.boardId ? { kanbanBoardId: event.boardId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...event.traceId ? { traceId: event.traceId } : {},
+      logicalRequestId: event.logicalRequestId,
+      ...event.promptManifestId ? { promptManifestId: event.promptManifestId } : {},
+      attemptId: event.attemptId
+    },
+    runtime: { providerId: event.providerId, modelId: event.model },
+    attributes: providerAttributes(event, seenToolManifests)
+  };
+  void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+}
+function providerAttributes(event, seenToolManifests) {
+  const {
+    sessionId: _sessionId,
+    traceId: _traceId,
+    agentId: _agentId,
+    providerId: _providerId,
+    model: _model,
+    logicalRequestId: _logicalRequestId,
+    promptManifestId: _promptManifestId,
+    attemptId: _attemptId,
+    ...rest
+  } = event;
+  const attributes = rest;
+  if (seenToolManifests && isManifest(attributes["promptManifest"])) {
+    attributes["promptManifest"] = compactManifest(attributes["promptManifest"], seenToolManifests);
+  }
+  return attributes;
+}
+var MANIFEST_MESSAGE_TAIL = 8;
+var SEEN_TOOL_MANIFEST_CAP = 256;
+function isManifest(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function compactManifest(manifest, seenToolManifests) {
+  const compacted = { ...manifest };
+  const tools = compacted["tools"];
+  if (isManifest(tools) && typeof tools["manifestHash"] === "string") {
+    const manifestHash = tools["manifestHash"];
+    if (seenToolManifests.has(manifestHash)) {
+      const { names: _names, ...toolsWithoutNames } = tools;
+      compacted["tools"] = { ...toolsWithoutNames, namesRef: manifestHash };
+    } else {
+      if (seenToolManifests.size >= SEEN_TOOL_MANIFEST_CAP) seenToolManifests.clear();
+      seenToolManifests.add(manifestHash);
+    }
+  }
+  const messages = compacted["messages"];
+  if (Array.isArray(messages) && messages.length > MANIFEST_MESSAGE_TAIL) {
+    compacted["messages"] = messages.slice(-MANIFEST_MESSAGE_TAIL);
+    compacted["messagesTruncated"] = messages.length - MANIFEST_MESSAGE_TAIL;
+  }
+  return compacted;
+}
+function millisecondsToNanoseconds(durationMs) {
+  return Math.round(durationMs * 1e6).toString();
+}
+
+// src/chronicle/tool-adapter.ts
+import { createHash } from "node:crypto";
+var PREVIEW_MAX_BYTES = 2048;
+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: capPreview(input),
+          inputHash: hashText(input),
+          inputBytes: Buffer.byteLength(input)
+        }
+      });
+    }),
+    options.events.on("permission.evaluated", (event) => {
+      persist2(options, event, {
+        eventType: "permission.evaluated",
+        outcome: event.effectiveDecision === "deny" ? "denied" : "success",
+        attributes: {
+          toolName: event.name,
+          inputHash: event.inputHash,
+          policyDecision: event.policyDecision,
+          effectiveDecision: event.effectiveDecision,
+          decisionSource: event.decisionSource,
+          reason: event.reason ? options.scrubber.scrub(event.reason) : void 0,
+          riskTier: event.riskTier,
+          yoloEnabled: event.yoloEnabled,
+          boundaryDecision: event.boundaryDecision,
+          boundaryReason: event.boundaryReason ? options.scrubber.scrub(event.boundaryReason) : void 0,
+          capabilityDowngraded: event.capabilityDowngraded
+        }
+      });
+    }),
+    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: capPreview(output),
+          outputHash: hashText(output),
+          outputBytes: event.outputBytes,
+          outputTokens: event.outputTokens,
+          outputLines: event.outputLines,
+          metadata: event.metadata
+        }
+      });
+    }),
+    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: capPreview(options.scrubber.scrub(event.event.text ?? "")),
+          data: capPreview(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 } : {},
+      ...event.taskId ? { taskId: event.taskId } : {},
+      ...event.boardId ? { kanbanBoardId: event.boardId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...event.traceId ? { traceId: event.traceId } : {},
+      ...event.logicalRequestId ? { logicalRequestId: event.logicalRequestId } : {},
+      ...event.promptManifestId ? { promptManifestId: event.promptManifestId } : {},
+      ...event.id ? { toolCallId: event.id } : {}
+    },
+    ...event.provider || event.model ? {
+      runtime: {
+        ...event.provider ? { providerId: event.provider } : {},
+        ...event.model ? { modelId: event.model } : {}
+      }
+    } : {}
+  };
+  void options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+}
+function progressResource(event) {
+  if (event.event.type !== "file_changed" || !event.event.path) return void 0;
+  return {
+    kind: "file",
+    id: resourceId("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 resourceId(kind, value) {
+  return `${kind}_${hashText(value).slice(0, 24)}`;
+}
+function hashText(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function capPreview(value) {
+  if (value.length <= PREVIEW_MAX_BYTES) {
+    if (Buffer.byteLength(value, "utf8") <= PREVIEW_MAX_BYTES) return value;
+  }
+  const buf = Buffer.from(value, "utf8");
+  if (buf.length <= PREVIEW_MAX_BYTES) return value;
+  let end = PREVIEW_MAX_BYTES;
+  while (end > 0 && (buf[end] & 192) === 128) end--;
+  return { preview: buf.subarray(0, end).toString("utf8"), truncated: true, totalBytes: buf.length };
+}
+function millisecondsToNanoseconds2(durationMs) {
+  return Math.round(durationMs * 1e6).toString();
+}
+
+// src/chronicle/process-adapter.ts
+import { createHash as createHash2 } 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_${createHash2("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 } 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 = performance.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 = performance.eventLoopUtilization(previousElu);
+    previousElu = performance.eventLoopUtilization();
+    const journalBeforeSample = options.journal.stats();
+    try {
+      options.events.emit("runtime.health.sampled", {
+        sessionId: context.scope.sessionId,
+        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 createHash3 } 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 ? createHash3("sha256").update(value).digest("hex") : void 0;
+}
+
+// src/chronicle/domain-adapter.ts
+import { createHash as createHash4 } from "node:crypto";
+var SPECIALIZED_RE = /^(?: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$|session\.agents_updated$|network\.request\.(?:started|completed)$|runtime\.health\.sampled$|provider\.tool_use_(?:start|stop)$)/;
+var CODING_SIGNAL_RE = /^(?:(?:agent|subagent|delegate|fleet|session|iteration|context|compaction|checkpoint|in_flight|memory|storage|trust|sdd|worktree|kanban|brain|token|budget|concurrency|provider|mcp|network)\.|file\.event$|error$)/;
+var SENSITIVE_KEY = /(content|text|prompt|question|rationale|reason|detail|summary|description|context|input|output|error|message|secret|token|password|key)$/i;
+var PRESERVE_STRING_KEY = /(^|_)(id|status|state|kind|type|source|model|provider|phase|risk|fallback|path|name|role|sha|branch|mode)$/i;
+var TRUNCATED_ARRAYS = /* @__PURE__ */ new Set([
+  "recentMail",
+  "recentTools",
+  "recentCommands",
+  "activated",
+  "injected",
+  // SAGE per-memory rejection evidence — same cap (5) as activated/injected
+  // so the journal stays bounded under burst conditions. Each entry is
+  // ~120 bytes serialized; cap × entry-count = ~600B per injector_run.
+  "rejectedDetail"
+]);
+var TRUNCATED_ARRAY_MAX = 5;
+var DEFAULT_ARRAY_MAX = 20;
+function wireDomainEventsToChronicle(options) {
+  return options.events.onAny((eventName, payload) => {
+    if (SPECIALIZED_RE.test(eventName)) return;
+    if (!CODING_SIGNAL_RE.test(eventName)) return;
+    const record = eventName === "memory.injector_run" ? dedupInjectorTrace(objectPayload(payload)) : objectPayload(payload);
+    if (eventName === "file.event" && record.operation === "read") return;
+    const context = typeof options.context === "function" ? options.context() : options.context;
+    const sessionId = stringField(record, "sessionId");
+    const agentId = stringField(record, "agentId") ?? stringField(record, "subagentId");
+    const taskId = stringField(record, "taskId");
+    const kanbanBoardId = stringField(record, "kanbanBoardId") ?? stringField(record, "boardId");
+    const input = {
+      eventType: eventName,
+      occurredAt: eventTime(record),
+      scope: {
+        ...context.scope,
+        ...sessionId ? { sessionId } : {},
+        ...agentId ? { agentId } : {},
+        ...taskId ? { taskId } : {},
+        ...kanbanBoardId ? { kanbanBoardId } : {}
+      },
+      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") } : {},
+        ...stringField(record, "promptManifestId") ? { promptManifestId: stringField(record, "promptManifestId") } : {}
+      },
+      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, eventName),
+      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 dedupInjectorTrace(record) {
+  const activated = Array.isArray(record.activated) ? record.activated : [];
+  const injected = Array.isArray(record.injected) ? record.injected : [];
+  const activatedIds = new Set(
+    activated.map((item) => item && typeof item === "object" ? item.id : void 0).filter((id) => typeof id === "string")
+  );
+  return {
+    ...record,
+    injected: injected.map((item) => {
+      const id = item && typeof item === "object" ? item.id : void 0;
+      return typeof id === "string" && activatedIds.has(id) ? { id, ref: "activated" } : item;
+    })
+  };
+}
+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, eventName) {
+  if (eventName === "file.event" && typeof payload.filePath === "string" && payload.filePath.length > 0) {
+    return { kind: "file", id: `path:${payload.filePath}`, path: payload.filePath };
+  }
+  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 createHash4("sha256").update(value).digest("hex");
+}
+
+// src/chronicle/stream-adapter.ts
+import { createHash as createHash5 } from "node:crypto";
+var MAX_STATE_AGE_MS = 3e5;
+var STALE_STATE_SWEEP_INTERVAL_MS = Math.round(MAX_STATE_AGE_MS / 6);
+function wireProviderStreamsToChronicle(options) {
+  const states = /* @__PURE__ */ new Map();
+  const key = (sessionId, agentId) => `${sessionId ?? "__default__"}\0${agentId ?? "__leader__"}`;
+  const update = (sessionId, agentId, text2, thinking) => {
+    const now = Date.now();
+    sweepStaleStates(states, flush, now);
+    const k = key(sessionId, agentId);
+    const state = states.get(k);
+    if (!state) return;
+    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: createHash5("sha256"),
+      thinkingHash: createHash5("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"))
+  ];
+  const reaperTimer = setInterval(
+    () => sweepStaleStates(states, flush, Date.now()),
+    STALE_STATE_SWEEP_INTERVAL_MS
+  );
+  if (typeof reaperTimer.unref === "function") reaperTimer.unref();
+  return () => {
+    clearInterval(reaperTimer);
+    for (const state of [...states.values()]) flush(state.sessionId, state.agentId, "failure");
+    offs.forEach((off) => {
+      off();
+    });
+  };
+}
+function sweepStaleStates(states, flushFn, now) {
+  if (states.size === 0) return;
+  for (const s of states.values()) {
+    if (now - s.startedAtMs > MAX_STATE_AGE_MS) {
+      const sid = s.sessionId;
+      const aid = s.agentId;
+      flushFn(sid, aid, "failure");
+    }
+  }
+}
+
+// src/chronicle/review-adapter.ts
+import { createHash as createHash6, randomUUID } from "node:crypto";
+function wireReviewFindingsToChronicle(options) {
+  const unsubscribe = options.events.onPattern(
+    "chimera.review_complete",
+    (_event, raw) => {
+      const payload = raw;
+      if (!payload?.reviewText) return;
+      if (payload.status !== "success") return;
+      const context = typeof options.context === "function" ? options.context() : options.context;
+      const sessionId = payload.sessionId ?? payload.bundle?.cwd;
+      const agentId = payload.bundle?.fileProvenance?.find((e) => e.agentId)?.agentId;
+      const taskId = payload.bundle?.kanbanCard?.id;
+      const provider = payload.bundle?.config?.provider;
+      const model = payload.bundle?.config?.model;
+      const cascadeDepth = payload.bundle?.cascadeDepth ?? 0;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const findings = parseFindings(payload.reviewText);
+      for (const finding of findings) {
+        const eventId = randomUUID();
+        const input = {
+          eventType: `finding.${finding.severity}`,
+          occurredAt: now,
+          scope: {
+            ...context.scope,
+            ...sessionId ? { sessionId } : {},
+            ...agentId ? { agentId } : {},
+            ...taskId ? { taskId } : {}
+          },
+          correlation: context.correlation,
+          resource: finding.file ? {
+            kind: "file",
+            id: `finding:${finding.fingerprint}`,
+            path: finding.file,
+            ...finding.line !== void 0 ? { lineStart: finding.line } : {}
+          } : void 0,
+          outcome: "success",
+          attributes: {
+            findingId: eventId,
+            fingerprint: finding.fingerprint,
+            severity: finding.severity,
+            title: finding.title,
+            file: finding.file,
+            line: finding.line,
+            source: "chimera",
+            model,
+            provider,
+            cascadeDepth
+          },
+          tags: {
+            collector: "review-adapter",
+            family: "finding",
+            severity: finding.severity
+          }
+        };
+        options.journal.append(input).catch((error) => options.onPersistError?.(error, input));
+      }
+      if (findings.length === 0) return;
+      const summaryInput = {
+        eventType: "review.completed",
+        occurredAt: now,
+        scope: {
+          ...context.scope,
+          ...sessionId ? { sessionId } : {},
+          ...agentId ? { agentId } : {},
+          ...taskId ? { taskId } : {}
+        },
+        correlation: context.correlation,
+        outcome: "success",
+        attributes: {
+          totalFindings: findings.length,
+          severityCounts: aggregateSeverities(findings),
+          files: payload.bundle?.files?.map((f) => f.path),
+          model,
+          provider,
+          cascadeDepth,
+          status: payload.status
+        },
+        tags: {
+          collector: "review-adapter",
+          family: "review"
+        }
+      };
+      options.journal.append(summaryInput).catch((error) => options.onPersistError?.(error, summaryInput));
+    }
+  );
+  return unsubscribe;
+}
+var SEVERITY_HEADING = /^###\s+(critical|high|medium|low)\b/i;
+var ITEM_CAPTURE = /^\d+\.\s+(.*)$/;
+var TAG_PREFIX = /^\[(\w+)\]\s*/;
+var FILE_REF = /^(.+?)(?::(\d+))?\s+[—–]\s*(.+)$/;
+var PATH_REF = /^([a-zA-Z_./\\][a-zA-Z0-9_./\\-]*\.\w+)(?::(\d+))?/;
+function parseFindings(reviewText) {
+  const findings = [];
+  let currentSeverity = null;
+  for (const rawLine of reviewText.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const heading = line.match(SEVERITY_HEADING);
+    if (heading) {
+      currentSeverity = heading[1].toLowerCase();
+      continue;
+    }
+    if (!currentSeverity) continue;
+    const item = line.match(ITEM_CAPTURE);
+    if (!item) continue;
+    let remaining = item[1].trim();
+    if (!remaining) continue;
+    const tag = remaining.match(TAG_PREFIX);
+    if (tag) remaining = remaining.slice(tag[0].length).trim();
+    const refMatch = remaining.match(FILE_REF);
+    let file;
+    let lineNum;
+    let desc;
+    if (refMatch) {
+      file = refMatch[1].trim();
+      lineNum = refMatch[2] !== void 0 ? Number.parseInt(refMatch[2], 10) : void 0;
+      desc = refMatch[3].trim();
+    } else {
+      const pathFallback = remaining.match(PATH_REF);
+      if (pathFallback) {
+        file = pathFallback[1].trim();
+        lineNum = pathFallback[2] !== void 0 ? Number.parseInt(pathFallback[2], 10) : void 0;
+        const afterFile = remaining.slice(pathFallback[0].length).trim();
+        desc = afterFile.replace(/^[—–-]\s*/, "").trim() || remaining;
+      } else {
+        desc = remaining;
+      }
+    }
+    if (file && !file.includes("/") && !file.includes("\\") && !file.includes(".")) {
+      file = void 0;
+      desc = remaining;
+    }
+    const title = desc.split(/\.\s/)[0].trim() || desc;
+    const fingerprint = computeFingerprint(file ?? "", lineNum ?? null, title);
+    findings.push({
+      severity: currentSeverity,
+      file,
+      line: lineNum,
+      title,
+      fingerprint
+    });
+  }
+  return findings;
+}
+function computeFingerprint(file, line, title) {
+  const normalizedFile = file.replace(/\\/g, "/").trim().toLowerCase();
+  const lineStr = line != null && line >= 0 ? String(line) : "0";
+  const normalizedTitle = title.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+  const hash2 = createHash6("sha256");
+  hash2.update(`${normalizedFile}:${lineStr}:${normalizedTitle}`);
+  return hash2.digest("hex");
+}
+function aggregateSeverities(findings) {
+  const counts = {
+    critical: 0,
+    high: 0,
+    medium: 0,
+    low: 0
+  };
+  for (const f of findings) {
+    const sev = f.severity;
+    if (sev in counts) counts[sev]++;
+  }
+  return counts;
+}
+
+// src/chronicle/rollup-adapter.ts
+import { createHash as createHash7 } from "node:crypto";
+var MAX_ROLLUP_RESOURCES = 100;
+var DEFAULT_GAUGE_WINDOW_MS = 12e4;
+function wireRollupsToChronicle(options) {
+  const buckets = /* @__PURE__ */ new Map();
+  const windowMs = Math.max(1e3, options.windowMs ?? 1e4);
+  const gaugeWindowMs = Math.max(windowMs, options.gaugeWindowMs ?? DEFAULT_GAUGE_WINDOW_MS);
+  const bucket = (key, seed) => {
+    let value = buckets.get(key);
+    if (!value) {
+      const now = Date.now();
+      value = {
+        ...seed,
+        startedAt: now,
+        updatedAt: now,
+        count: 0,
+        metrics: {},
+        categories: {},
+        digest: createHash7("sha256"),
+        resources: /* @__PURE__ */ new Map()
+      };
+      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 resources = value.resources.size > 0 ? [...value.resources].slice(0, MAX_ROLLUP_RESOURCES).map(([id, r]) => ({ id, kind: r.kind, ...r.path ? { path: r.path } : {} })) : void 0;
+    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,
+        ...resources ? { resources, resourceCount: value.resources.size } : {}
+      }
+    };
+    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,
+      aggregateMs: gaugeWindowMs,
+      ...sessionId ? { sessionId } : {},
+      ...dimensionValue ? { agentId: dimensionValue } : {},
+      dimensions: dimensionValue && dimension ? { [dimension]: dimensionValue } : {}
+    });
+    sample(
+      target,
+      Object.fromEntries(
+        Object.entries(event).filter(([, value]) => typeof value === "number")
+      )
+    );
+  };
+  const offs = [
+    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 ?? ""}`);
+      const metadata = event.metadata;
+      if (!metadata || metadata.files.length === 0 && metadata.symbols.length === 0 && metadata.commands.length === 0)
+        return;
+      const key = `tool.resource\0${event.sessionId ?? ""}\0${event.id ?? ""}`;
+      const target = bucket(key, {
+        signal: "tool.resource.observed",
+        ...event.sessionId ? { sessionId: event.sessionId } : {},
+        ...event.agentId ? { agentId: event.agentId } : {},
+        ...event.id ? { toolCallId: event.id } : {},
+        dimensions: { toolName: event.name }
+      });
+      for (const file of metadata.files) {
+        target.resources.set(resourceId2("file", file), { kind: "file", path: file });
+        sample(target, {}, "file");
+      }
+      for (const symbol of metadata.symbols) {
+        target.resources.set(resourceId2("symbol", symbol), { kind: "symbol" });
+        sample(target, {}, "symbol");
+      }
+      for (const command of metadata.commands) {
+        target.resources.set(resourceId2("command", command), { kind: "process" });
+        sample(target, {}, "command");
+      }
+      flush(key);
+    }),
+    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)),
+    // Periodic self-observation gauge (nested fields, so the flat gauge()
+    // helper can't be reused directly — flatten before sampling).
+    options.events.on("runtime.health.sampled", (event) => {
+      const key = `runtime.health\0${event.sessionId ?? ""}`;
+      const target = bucket(key, {
+        signal: "runtime.health",
+        aggregateMs: gaugeWindowMs,
+        ...event.sessionId ? { sessionId: event.sessionId } : {},
+        dimensions: {}
+      });
+      const chronicle = event.chronicle;
+      sample(target, {
+        "eventLoop.utilization": event.eventLoop.utilization,
+        "eventLoop.delayMeanMs": event.eventLoop.delayMeanMs,
+        "eventLoop.delayP95Ms": event.eventLoop.delayP95Ms,
+        "eventLoop.delayMaxMs": event.eventLoop.delayMaxMs,
+        "cpu.userMicros": event.cpu.userMicros,
+        "cpu.systemMicros": event.cpu.systemMicros,
+        "memory.rssBytes": event.memory.rssBytes,
+        "memory.heapUsedBytes": event.memory.heapUsedBytes,
+        "memory.heapTotalBytes": event.memory.heapTotalBytes,
+        ...typeof chronicle?.pendingEvents === "number" ? { "chronicle.pendingEvents": chronicle.pendingEvents } : {},
+        ...typeof chronicle?.rejectedEvents === "number" ? { "chronicle.rejectedEvents": chronicle.rejectedEvents } : {}
+      });
+    }),
+    // Full-fleet snapshots fired on every agent-state flush (~14KB each) are
+    // reduced to one windowed aggregate per session; the raw event is excluded
+    // from the domain adapter. Sums preserve the fleet-level metric trail.
+    options.events.on("session.agents_updated", (event) => {
+      const key = `session.agents\0${event.sessionId ?? ""}`;
+      const target = bucket(key, {
+        signal: "session.agents",
+        aggregateMs: gaugeWindowMs,
+        ...event.sessionId ? { sessionId: event.sessionId } : {},
+        dimensions: {}
+      });
+      const sums = {
+        agents: 0,
+        running: 0,
+        iterations: 0,
+        toolCalls: 0,
+        costUsd: 0,
+        tokensIn: 0,
+        tokensOut: 0
+      };
+      for (const agent of event.agents) {
+        sums.agents++;
+        if (agent.status === "running") sums.running++;
+        sums.iterations += numeric(agent.iterations);
+        sums.toolCalls += numeric(agent.toolCalls);
+        sums.costUsd += numeric(agent.costUsd);
+        sums.tokensIn += numeric(agent.tokensIn);
+        sums.tokensOut += numeric(agent.tokensOut);
+      }
+      sample(target, sums);
+    }),
+    // Per-request network chatter (started/completed pairs were the 2nd most
+    // frequent raw family) becomes one aggregate per session×initiator×host
+    // window with status-class categories. network.request.failed stays raw.
+    options.events.on("network.request.completed", (event) => {
+      const key = `network.request\0${event.sessionId}\0${event.initiator}\0${event.serverAddress}`;
+      const target = bucket(key, {
+        signal: "network.request",
+        sessionId: event.sessionId,
+        dimensions: { initiator: event.initiator, serverAddress: event.serverAddress }
+      });
+      sample(
+        target,
+        {
+          durationMs: event.durationMs,
+          ...event.requestBytes !== void 0 ? { requestBytes: event.requestBytes } : {},
+          ...event.responseBytes !== void 0 ? { responseBytes: event.responseBytes } : {}
+        },
+        `${Math.floor(event.statusCode / 100)}xx`,
+        event.requestId
+      );
+    })
+  ];
+  const timer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, value] of buckets) {
+      const due = value.aggregateMs === void 0 ? value.updatedAt <= now - windowMs : value.startedAt <= now - value.aggregateMs;
+      if (due) flush(key);
+    }
+  }, windowMs);
+  timer.unref?.();
+  return () => {
+    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 numeric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function safeDigest(value) {
+  try {
+    return createHash7("sha256").update(JSON.stringify(value)).digest("hex");
+  } catch {
+    return "unhashable";
+  }
+}
+function resourceId2(kind, value) {
+  return `${kind}_${createHash7("sha256").update(value).digest("hex").slice(0, 24)}`;
+}
+
+export {
+  ChronicleCompactionBusyError,
+  compactChronicleSqlite,
+  wireProviderAttemptsToChronicle,
+  wireToolsToChronicle,
+  wireProcessesToChronicle,
+  startChronicleHealthMonitor,
+  wireDecisionsToChronicle,
+  wireDomainEventsToChronicle,
+  wireProviderStreamsToChronicle,
+  wireReviewFindingsToChronicle,
+  wireRollupsToChronicle
+};
+//# sourceMappingURL=chunk-NEMIWEXC.js.map