opencode-swarm 7.140.3 → 7.140.5

package/dist/cli/index-affh1gtg.js

@@ -0,0 +1,2554 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-k46me75h.js";
+import {
+  resolveHiveEventsPath
+} from "./index-ae75rja9.js";
+import {
+  resolveKnowledgeStoreDir
+} from "./index-vh05t3w5.js";
+import {
+  atomicWriteFile
+} from "./index-p8kk34am.js";
+import {
+  assertProjectRoot
+} from "./index-912qz4y0.js";
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import {
+  loadPluginConfigWithMeta
+} from "./index-nwrwy8eb.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+import {
+  KnowledgeConfigSchema,
+  init_schema
+} from "./index-jm4cpp4n.js";
+import {
+  emit
+} from "./index-epvhf50h.js";
+import {
+  __require,
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/hooks/knowledge-events.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { appendFile, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import * as path2 from "path";
+init_logger();
+
+// src/hooks/knowledge-receipt-ledger.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+init_schema();
+
+// src/hooks/knowledge-receipt-ledger-storage.ts
+import { createHash, randomUUID } from "crypto";
+import * as fs from "fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  stat
+} from "fs/promises";
+import * as path from "path";
+var RECEIPT_SCHEMA_VERSION = 2;
+var RECEIPT_CUTOVER_VERSION = 1;
+var LOCK_RETRY_MS = 25;
+var LOCK_TIMEOUT_MS = 500;
+var UNINITIALIZED_LOCK_STALE_MS = 30000;
+var PROC_STATE_READ_TIMEOUT_MS = 25;
+
+class ReceiptStoreError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ReceiptStoreError";
+  }
+}
+function resolveReceiptLedgerPaths(directory) {
+  assertProjectRoot(directory, undefined, "knowledge receipt state");
+  let root;
+  try {
+    root = fs.realpathSync(directory);
+  } catch {
+    throw new ReceiptStoreError("store_unavailable", "cannot canonicalize project root");
+  }
+  return {
+    root,
+    swarmDir: path.join(root, ".swarm"),
+    journal: validateSwarmPath(root, "knowledge-receipts-v2.jsonl"),
+    snapshot: validateSwarmPath(root, "knowledge-receipts-v2.snapshot.json"),
+    archive: validateSwarmPath(root, "knowledge-receipts-v2-archive.jsonl"),
+    quarantine: validateSwarmPath(root, "knowledge-receipts-v2-quarantine.json"),
+    lockTarget: validateSwarmPath(root, "knowledge-receipts-v2.lock"),
+    legacyEvents: validateSwarmPath(root, "knowledge-events.jsonl"),
+    legacyBaseline: validateSwarmPath(root, "knowledge-counter-baseline.json"),
+    linkPointer: validateSwarmPath(root, "link.json")
+  };
+}
+function validateExistingRegularFile(filePath) {
+  if (!fs.existsSync(filePath))
+    return;
+  const info = fs.lstatSync(filePath);
+  if (info.isSymbolicLink() || !info.isFile()) {
+    throw new ReceiptStoreError("store_unavailable", `receipt artifact is not a regular file: ${path.basename(filePath)}`);
+  }
+}
+async function preparePaths(paths) {
+  await mkdir(paths.swarmDir, { recursive: true });
+  const swarmInfo = fs.lstatSync(paths.swarmDir);
+  if (swarmInfo.isSymbolicLink() || !swarmInfo.isDirectory()) {
+    throw new ReceiptStoreError("store_unavailable", ".swarm is not a real project-local directory");
+  }
+  if (fs.realpathSync(path.dirname(paths.journal)) !== fs.realpathSync(paths.swarmDir)) {
+    throw new ReceiptStoreError("store_unavailable", "receipt artifact parent escaped the project .swarm directory");
+  }
+  for (const artifact of [
+    paths.journal,
+    paths.snapshot,
+    paths.archive,
+    paths.quarantine,
+    paths.lockTarget
+  ]) {
+    validateExistingRegularFile(artifact);
+  }
+}
+function samePath(left, right) {
+  const normalize = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
+  return normalize(left) === normalize(right);
+}
+async function validateMutationParent(filePath, dependencies = { lstat, realpath }) {
+  const parent = path.dirname(path.resolve(filePath));
+  const info = await dependencies.lstat(parent);
+  if (info.isSymbolicLink() || !info.isDirectory()) {
+    throw new ReceiptStoreError("store_unavailable", "receipt artifact parent is not a real directory");
+  }
+  const canonical = await dependencies.realpath(parent);
+  const canonicalInfo = await dependencies.lstat(canonical);
+  if (canonicalInfo.isSymbolicLink() || !canonicalInfo.isDirectory() || !samePath(canonical, parent) && !sameIdentity({ dev: info.dev, ino: info.ino }, { dev: canonicalInfo.dev, ino: canonicalInfo.ino })) {
+    throw new ReceiptStoreError("store_unavailable", "receipt artifact parent identity changed before mutation");
+  }
+  return canonical;
+}
+async function existingFileIdentity(filePath) {
+  try {
+    const info = await lstat(filePath);
+    if (info.isSymbolicLink() || !info.isFile()) {
+      throw new ReceiptStoreError("store_unavailable", `receipt artifact is not a regular file: ${path.basename(filePath)}`);
+    }
+    return { dev: info.dev, ino: info.ino };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+function sameIdentity(left, right) {
+  return left !== null && right !== null && left.dev === right.dev && left.ino === right.ino;
+}
+async function syncParentDirectory(parent) {
+  let handle;
+  try {
+    handle = await open(parent, "r");
+    await handle.sync();
+  } catch (error) {
+    const code = error.code;
+    if (process.platform !== "win32" || code !== "EISDIR" && code !== "EPERM" && code !== "EACCES") {
+      throw error;
+    }
+  } finally {
+    await handle?.close().catch(() => {
+      return;
+    });
+  }
+}
+async function writeAll(handle, content) {
+  const bytes = Buffer.from(content, "utf8");
+  let offset = 0;
+  while (offset < bytes.length) {
+    const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset, null);
+    if (bytesWritten <= 0)
+      throw new Error("receipt write made no progress");
+    offset += bytesWritten;
+  }
+}
+async function readLinuxProcStat(pid, signal) {
+  return await readFile(`/proc/${pid}/stat`, { encoding: "utf8", signal });
+}
+async function isProcessAlive(pid) {
+  try {
+    _internals.killProcess(pid);
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+  if (_internals.platform() !== "linux")
+    return true;
+  const controller = new AbortController;
+  let timer;
+  try {
+    const procRead = _internals.readLinuxProcStat(pid, controller.signal).catch(() => null);
+    const timedOut = new Promise((resolve2) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        resolve2(null);
+      }, _internals.procStateReadTimeoutMs);
+    });
+    const statLine = await Promise.race([procRead, timedOut]);
+    if (statLine === null)
+      return true;
+    const commandEnd = statLine.lastIndexOf(")");
+    if (commandEnd < 0)
+      return true;
+    const state = statLine.slice(commandEnd + 1).trimStart().charAt(0);
+    return state !== "Z";
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+async function readLockOwner(lockPath, expectedRoot) {
+  try {
+    validateExistingRegularFile(lockPath);
+    const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+    if (typeof parsed.owner_token !== "string" || !parsed.owner_token || !Number.isInteger(parsed.pid) || (parsed.pid ?? 0) <= 0 || !Number.isFinite(parsed.created_at_ms) || typeof parsed.root_identity !== "string" || !parsed.root_identity || expectedRoot !== undefined && !samePath(parsed.root_identity, expectedRoot)) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    if (error instanceof SyntaxError)
+      return null;
+    throw error;
+  }
+}
+async function recoverLockIfSafe(paths) {
+  const lockPath = paths.lockTarget;
+  const expectedRoot = paths.root;
+  const recoveryOwner = {
+    owner_token: randomUUID(),
+    pid: process.pid,
+    created_at_ms: Date.now(),
+    root_identity: expectedRoot
+  };
+  const parent = await validateMutationParent(lockPath);
+  let claimedPath;
+  let info;
+  try {
+    info = await stat(lockPath);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  const owner = await readLockOwner(lockPath, expectedRoot);
+  if (owner && await _internals.isProcessAlive(owner.pid))
+    return;
+  if (!owner && Date.now() - info.mtimeMs < UNINITIALIZED_LOCK_STALE_MS)
+    return;
+  claimedPath = `${lockPath}.${recoveryOwner.owner_token}.recovering`;
+  try {
+    await _internals.rename(lockPath, claimedPath);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  await _internals.afterRecoveryRename(paths, claimedPath);
+  const claimedInfo = await stat(claimedPath);
+  const claimedOwner = await readLockOwner(claimedPath, expectedRoot);
+  const sameObservedOwner = owner ? claimedOwner?.owner_token === owner.owner_token : claimedOwner === null;
+  const stillRecoverable = owner ? sameObservedOwner && !await _internals.isProcessAlive(owner.pid) : sameObservedOwner && Date.now() - claimedInfo.mtimeMs >= UNINITIALIZED_LOCK_STALE_MS;
+  if (stillRecoverable) {
+    await _internals.rm(claimedPath, { force: true });
+    claimedPath = undefined;
+    await syncParentDirectory(parent);
+    return;
+  }
+  if (!fs.existsSync(lockPath)) {
+    await _internals.rename(claimedPath, lockPath);
+    claimedPath = undefined;
+    await syncParentDirectory(parent);
+    return;
+  }
+  throw new ReceiptStoreError("store_unavailable", "receipt recovery claim changed while a successor lock exists");
+}
+async function acquireReceiptLock(paths) {
+  const lockPath = paths.lockTarget;
+  const owner = {
+    owner_token: randomUUID(),
+    pid: process.pid,
+    created_at_ms: Date.now(),
+    root_identity: paths.root
+  };
+  const deadline = performance.now() + LOCK_TIMEOUT_MS;
+  for (;; ) {
+    let handle;
+    try {
+      const parent = await validateMutationParent(lockPath);
+      handle = await open(lockPath, "wx");
+      await writeAll(handle, `${JSON.stringify(owner)}
+`);
+      await handle.sync();
+      const info = await handle.stat();
+      if (!info.isFile())
+        throw new Error("receipt lock is not a regular file");
+      await handle.close();
+      handle = undefined;
+      validateExistingRegularFile(lockPath);
+      await syncParentDirectory(parent);
+      return async () => {
+        const current = await readLockOwner(lockPath, paths.root);
+        if (current?.owner_token === owner.owner_token) {
+          await rm(lockPath, { force: true });
+          await syncParentDirectory(parent);
+        }
+      };
+    } catch (error) {
+      await handle?.close().catch(() => {
+        return;
+      });
+      if (error.code !== "EEXIST")
+        throw error;
+      await _internals.recoverLockIfSafe(paths);
+      const remainingMs = deadline - performance.now();
+      if (remainingMs <= 0)
+        break;
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(LOCK_RETRY_MS, remainingMs)));
+    }
+  }
+  throw new ReceiptStoreError("lock_timeout", "receipt correctness lock unavailable before bounded timeout");
+}
+async function withReceiptLedgerLock(directory, action) {
+  const paths = resolveReceiptLedgerPaths(directory);
+  try {
+    await preparePaths(paths);
+    const release = await acquireReceiptLock(paths);
+    try {
+      resolveReceiptLedgerPaths(paths.root);
+      await preparePaths(paths);
+      return await action(paths);
+    } finally {
+      await release().catch(() => {
+        return;
+      });
+    }
+  } catch (error) {
+    if (error instanceof ReceiptStoreError)
+      throw error;
+    throw new ReceiptStoreError("store_unavailable", error instanceof Error ? error.message : String(error));
+  }
+}
+function receiptRecordHash(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+async function readUtf8IfPresent(filePath, maxBytes = 32 * 1024 * 1024) {
+  try {
+    validateExistingRegularFile(filePath);
+    const info = await stat(filePath);
+    if (info.size > maxBytes) {
+      throw new ReceiptStoreError("store_corrupt", `receipt artifact exceeds ${maxBytes} bytes: ${path.basename(filePath)}`);
+    }
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function appendFsynced(filePath, line) {
+  const parent = await validateMutationParent(filePath);
+  const before = await existingFileIdentity(filePath);
+  const handle = await open(filePath, "a");
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile())
+      throw new Error("receipt journal is not a regular file");
+    if (before && (opened.dev !== before.dev || opened.ino !== before.ino)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt journal identity changed before append");
+    }
+    await writeAll(handle, line);
+    await handle.sync();
+    const after = await existingFileIdentity(filePath);
+    if (!after || after.dev !== opened.dev || after.ino !== opened.ino || !samePath(await realpath(path.dirname(filePath)), parent)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt journal identity changed during append");
+    }
+  } finally {
+    await handle.close();
+  }
+  if (!before)
+    await syncParentDirectory(parent);
+}
+async function renameWithRetry(tempPath, targetPath) {
+  let lastError;
+  for (let attempt = 0;attempt < 6; attempt++) {
+    try {
+      await rename(tempPath, targetPath);
+      return;
+    } catch (error) {
+      lastError = error;
+      const code = error.code;
+      if (code !== "EPERM" && code !== "EBUSY" && code !== "EEXIST")
+        throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, 10 * (attempt + 1)));
+    }
+  }
+  throw lastError;
+}
+async function atomicWriteFsynced(targetPath, content) {
+  const parent = await validateMutationParent(targetPath);
+  await existingFileIdentity(targetPath);
+  const tempPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+  const handle = await open(tempPath, "wx");
+  let tempIdentity;
+  try {
+    await writeAll(handle, content);
+    await handle.sync();
+    const info = await handle.stat();
+    if (!info.isFile())
+      throw new Error("receipt temp is not a regular file");
+    tempIdentity = { dev: info.dev, ino: info.ino };
+  } finally {
+    await handle.close();
+  }
+  try {
+    const onDiskTemp = await existingFileIdentity(tempPath);
+    if (!sameIdentity(onDiskTemp, tempIdentity)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt temp identity changed before rename");
+    }
+    if (!samePath(await realpath(path.dirname(targetPath)), parent)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt artifact parent identity changed before rename");
+    }
+    await existingFileIdentity(targetPath);
+    await renameWithRetry(tempPath, targetPath);
+    const targetIdentity = await existingFileIdentity(targetPath);
+    if (!sameIdentity(targetIdentity, tempIdentity)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt target identity changed during rename");
+    }
+    if (!samePath(await realpath(path.dirname(targetPath)), parent)) {
+      throw new ReceiptStoreError("store_unavailable", "receipt artifact parent identity changed after rename");
+    }
+    await syncParentDirectory(parent);
+  } finally {
+    await rm(tempPath, { force: true }).catch(() => {
+      return;
+    });
+  }
+}
+var _internals = {
+  platform: () => process.platform,
+  killProcess: (pid) => {
+    process.kill(pid, 0);
+  },
+  readLinuxProcStat,
+  procStateReadTimeoutMs: PROC_STATE_READ_TIMEOUT_MS,
+  isProcessAlive,
+  rename,
+  rm,
+  afterRecoveryRename: async (_paths, _claimedPath) => {},
+  recoverLockIfSafe,
+  validateMutationParent
+};
+
+// src/hooks/knowledge-receipt-observability.ts
+var TRANSITIONS = new Set([
+  "membership_committed",
+  "empty_retrieval_committed",
+  "terminal_committed",
+  "terminal_attempt_rejected",
+  "terminal_attempt_idempotent",
+  "authorized_transition_committed",
+  "application_marker_committed",
+  "phase_close_intent",
+  "phase_closed",
+  "legacy_imported",
+  "legacy_unverifiable",
+  "cutover_completed",
+  "checkpoint"
+]);
+var REASON_CODES = new Set([
+  "committed",
+  "idempotent",
+  "trace_not_found",
+  "id_not_in_trace",
+  "wrong_session",
+  "wrong_phase",
+  "wrong_task",
+  "duplicate_conflicting_terminal",
+  "event_id_conflict",
+  "invalid_outcome",
+  "empty_receipt",
+  "lock_timeout",
+  "store_unavailable",
+  "store_corrupt",
+  "legacy_unverifiable",
+  "unauthorized_transition"
+]);
+var RECEIPT_OUTCOMES = new Set([
+  "applied",
+  "ignored",
+  "contradicted",
+  "violated",
+  "n_a",
+  "no_relevant"
+]);
+var BOUNDED_CODE = /^[a-z][a-z0-9_-]{0,63}$/;
+function boundedCode(value) {
+  return typeof value === "string" && BOUNDED_CODE.test(value) ? value : undefined;
+}
+function boundedPhase(value) {
+  const code = boundedCode(value);
+  return code && /^phase(?:[_-][a-z0-9_-]+)?$/.test(code) ? code : undefined;
+}
+function addIdentifier(payload, key, value) {
+  if (typeof value === "string" && value.length > 0)
+    payload[key] = value;
+}
+function emitKnowledgeReceiptTransition(observation) {
+  try {
+    if (!TRANSITIONS.has(observation.transition) || !REASON_CODES.has(observation.reasonCode) || !Number.isSafeInteger(observation.schemaVersion) || observation.schemaVersion < 1) {
+      return;
+    }
+    const payload = {
+      transition: observation.transition,
+      reasonCode: observation.reasonCode,
+      schemaVersion: observation.schemaVersion
+    };
+    addIdentifier(payload, "knowledgeTraceId", observation.knowledgeTraceId);
+    addIdentifier(payload, "knowledgeEntryId", observation.knowledgeEntryId);
+    addIdentifier(payload, "sessionId", observation.sessionId);
+    addIdentifier(payload, "taskId", observation.taskId);
+    addIdentifier(payload, "phase", boundedPhase(observation.phase));
+    if (observation.receiptOutcome !== undefined && RECEIPT_OUTCOMES.has(observation.receiptOutcome)) {
+      payload.receiptOutcome = observation.receiptOutcome;
+    }
+    if (typeof observation.receiptSource === "string" && BOUNDED_CODE.test(observation.receiptSource)) {
+      payload.receiptSource = observation.receiptSource;
+    }
+    _internals2.emit("knowledge_receipt_transition", payload);
+  } catch {}
+}
+var _internals2 = { emit };
+
+// src/hooks/knowledge-receipt-ledger.ts
+var GENESIS_HASH = "GENESIS";
+var MAX_JOURNAL_RECORDS = 2000;
+var MAX_AUDIT_TAIL_RECORDS = 256;
+var MAX_JOURNAL_BYTES = 32 * 1024 * 1024;
+var MAX_ARCHIVE_RECORDS = 1e4;
+var MAX_ARCHIVE_BYTES = 16 * 1024 * 1024;
+var MAX_LEGACY_BYTES = 32 * 1024 * 1024;
+var DEFAULT_RECEIPT_GRACE_DAYS = 7;
+var keyOf = (traceId, entryId) => `${traceId.length}:${traceId}${entryId}`;
+var emptyKeyOf = (traceId, sessionId) => `${traceId.length}:${traceId}${sessionId}`;
+var phaseLifecycleKey = (phase, sessionId, taskId) => `${sessionId.length}:${sessionId}${phase.length}:${phase}${taskId === undefined ? "u:" : `s:${taskId.length}:${taskId}`}`;
+function nowIso() {
+  return new Date(_internals3.nowMs()).toISOString();
+}
+function configuredGraceDays(directory) {
+  try {
+    const { config } = loadPluginConfigWithMeta(directory);
+    return KnowledgeConfigSchema.parse(config.knowledge ?? {}).receipt_close_grace_days;
+  } catch {
+    return DEFAULT_RECEIPT_GRACE_DAYS;
+  }
+}
+function emptyState(observations = []) {
+  return {
+    memberships: new Map,
+    traceIds: new Set,
+    emptyTraces: new Map,
+    cutoverCompleted: false,
+    legacyUnverifiable: false,
+    legacyTraceRegistry: new Set,
+    legacyUnverifiableTraceIds: new Set,
+    phaseLifecycle: new Map,
+    auditTail: [],
+    lastSeq: 0,
+    lastHash: GENESIS_HASH,
+    recordCount: 0,
+    observations
+  };
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function hasOnlyKeys(value, allowed) {
+  const allow = new Set(allowed);
+  return Object.keys(value).every((key) => allow.has(key));
+}
+function isOptionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isValidTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function parsePredicateCheck(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, ["predicate", "result", "detail"]) || typeof value.predicate !== "string" || value.result !== "pass" && value.result !== "fail" && value.result !== "error" || typeof value.detail !== "string") {
+    return null;
+  }
+  return {
+    predicate: value.predicate,
+    result: value.result,
+    detail: value.detail
+  };
+}
+function parseAuthorizedTransition(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "actor",
+    "reason",
+    "previous_event_id",
+    "previous_outcome"
+  ]) || value.actor !== "manual-override" && value.actor !== "reviewer-remediation" && value.actor !== "phase-override" || typeof value.reason !== "string" || typeof value.previous_event_id !== "string" || value.previous_outcome !== undefined && !isReceiptOutcome(value.previous_outcome)) {
+    return null;
+  }
+  return {
+    actor: value.actor,
+    reason: value.reason,
+    previous_event_id: value.previous_event_id,
+    previous_outcome: value.previous_outcome
+  };
+}
+function parseTerminal(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "outcome",
+    "source",
+    "reason",
+    "predicate_check",
+    "event_id",
+    "committed_at",
+    "authorized_transition"
+  ]) || !isReceiptOutcome(value.outcome) || typeof value.source !== "string" || !isOptionalString(value.reason) || typeof value.event_id !== "string" || !value.event_id || !isValidTimestamp(value.committed_at)) {
+    return null;
+  }
+  const predicate = value.predicate_check === undefined ? undefined : parsePredicateCheck(value.predicate_check);
+  if (predicate === null)
+    return null;
+  const authorization = value.authorized_transition === undefined ? undefined : parseAuthorizedTransition(value.authorized_transition);
+  if (authorization === null)
+    return null;
+  return {
+    outcome: value.outcome,
+    source: value.source,
+    reason: value.reason,
+    predicate_check: predicate,
+    event_id: value.event_id,
+    committed_at: value.committed_at,
+    authorized_transition: authorization
+  };
+}
+function parseApplicationMarker(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "outcome",
+    "source",
+    "reason",
+    "event_id",
+    "committed_at"
+  ]) || !isReceiptOutcome(value.outcome) || typeof value.source !== "string" || !isOptionalString(value.reason) || typeof value.event_id !== "string" || !value.event_id || !isValidTimestamp(value.committed_at)) {
+    return null;
+  }
+  return {
+    outcome: value.outcome,
+    source: value.source,
+    reason: value.reason,
+    event_id: value.event_id,
+    committed_at: value.committed_at
+  };
+}
+function parseMembership(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "trace_id",
+    "entry_id",
+    "session_id",
+    "phase",
+    "task_id",
+    "agent",
+    "critical",
+    "rank",
+    "score",
+    "committed_at",
+    "membership_event_id",
+    "grace_days",
+    "phase_close_intent_at",
+    "phase_closed_at",
+    "terminal",
+    "terminal_history",
+    "application_marker",
+    "cohort_id",
+    "source_link_id",
+    "exposure_kind",
+    "origin"
+  ]) || typeof value.trace_id !== "string" || !value.trace_id || typeof value.entry_id !== "string" || !value.entry_id || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.phase) || !isOptionalString(value.task_id) || !isOptionalString(value.agent) || typeof value.critical !== "boolean" || value.rank !== undefined && !Number.isFinite(value.rank) || value.score !== undefined && !Number.isFinite(value.score) || !isValidTimestamp(value.committed_at) || typeof value.membership_event_id !== "string" || !value.membership_event_id || !Number.isFinite(value.grace_days) || value.grace_days < 0 || value.phase_close_intent_at !== undefined && !isValidTimestamp(value.phase_close_intent_at) || value.phase_closed_at !== undefined && !isValidTimestamp(value.phase_closed_at) || !isOptionalString(value.cohort_id) || !isOptionalString(value.source_link_id) || !isReceiptExposureKind(value.exposure_kind) || value.origin !== "v2" && value.origin !== "legacy") {
+    return null;
+  }
+  const terminal = value.terminal === undefined ? undefined : parseTerminal(value.terminal);
+  if (terminal === null)
+    return null;
+  let terminalHistory;
+  if (value.terminal_history !== undefined) {
+    if (!Array.isArray(value.terminal_history))
+      return null;
+    terminalHistory = [];
+    for (const item of value.terminal_history) {
+      const parsed = parseTerminal(item);
+      if (!parsed)
+        return null;
+      terminalHistory.push(parsed);
+    }
+  }
+  const marker = value.application_marker === undefined ? undefined : parseApplicationMarker(value.application_marker);
+  if (marker === null)
+    return null;
+  return {
+    trace_id: value.trace_id,
+    entry_id: value.entry_id,
+    session_id: value.session_id,
+    phase: value.phase,
+    task_id: value.task_id,
+    agent: value.agent,
+    critical: value.critical,
+    rank: value.rank,
+    score: value.score,
+    committed_at: value.committed_at,
+    membership_event_id: value.membership_event_id,
+    grace_days: value.grace_days,
+    phase_close_intent_at: value.phase_close_intent_at,
+    phase_closed_at: value.phase_closed_at,
+    terminal,
+    terminal_history: terminalHistory,
+    application_marker: marker,
+    cohort_id: value.cohort_id,
+    source_link_id: value.source_link_id,
+    exposure_kind: value.exposure_kind,
+    origin: value.origin
+  };
+}
+function isReceiptExposureKind(value) {
+  return value === "architect_directive" || value === "delegate_directive" || value === "manual_recall" || value === "legacy_unknown";
+}
+function legacyExposureKind(event) {
+  if (event.retrieval_mode === "auto_injection")
+    return "architect_directive";
+  if (event.retrieval_mode === "delegate_inject")
+    return "delegate_directive";
+  if (event.retrieval_mode === "manual")
+    return "manual_recall";
+  return "legacy_unknown";
+}
+function parseEmptyTrace(value, requireSummaryKind = false) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "trace_id",
+    "session_id",
+    "phase",
+    "task_id",
+    "committed_at",
+    "empty_event_id",
+    "grace_days",
+    "phase_close_intent_at",
+    "phase_closed_at",
+    "terminal_event_id",
+    "summary_kind"
+  ]) || requireSummaryKind && value.summary_kind !== "empty_trace" || !requireSummaryKind && value.summary_kind !== undefined || typeof value.trace_id !== "string" || !value.trace_id || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.phase) || !isOptionalString(value.task_id) || !isValidTimestamp(value.committed_at) || typeof value.empty_event_id !== "string" || !value.empty_event_id || !Number.isFinite(value.grace_days) || value.grace_days < 0 || value.phase_close_intent_at !== undefined && !isValidTimestamp(value.phase_close_intent_at) || value.phase_closed_at !== undefined && !isValidTimestamp(value.phase_closed_at) || !isOptionalString(value.terminal_event_id)) {
+    return null;
+  }
+  const trace = {
+    trace_id: value.trace_id,
+    session_id: value.session_id,
+    phase: value.phase,
+    task_id: value.task_id,
+    committed_at: value.committed_at,
+    empty_event_id: value.empty_event_id,
+    grace_days: value.grace_days,
+    phase_close_intent_at: value.phase_close_intent_at,
+    phase_closed_at: value.phase_closed_at,
+    terminal_event_id: value.terminal_event_id
+  };
+  return requireSummaryKind ? { ...trace, summary_kind: "empty_trace" } : trace;
+}
+function parsePhaseLifecycle(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "phase",
+    "session_id",
+    "task_id",
+    "intent_event_id",
+    "intent_at",
+    "closed_event_id",
+    "closed_at"
+  ]) || typeof value.phase !== "string" || !value.phase || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.task_id) || !isOptionalString(value.intent_event_id) || value.intent_at !== undefined && !isValidTimestamp(value.intent_at) || !isOptionalString(value.closed_event_id) || value.closed_at !== undefined && !isValidTimestamp(value.closed_at)) {
+    return null;
+  }
+  return {
+    phase: value.phase,
+    session_id: value.session_id,
+    task_id: value.task_id,
+    intent_event_id: value.intent_event_id,
+    intent_at: value.intent_at,
+    closed_event_id: value.closed_event_id,
+    closed_at: value.closed_at
+  };
+}
+function parseAuditSummary(value) {
+  if (!isPlainRecord(value))
+    return null;
+  if (!hasOnlyKeys(value, [
+    "original_seq",
+    "original_hash",
+    "event_id",
+    "timestamp",
+    "kind",
+    "trace_id",
+    "phase",
+    "entry_ids",
+    "reason_codes"
+  ]) || !Number.isInteger(value.original_seq) || value.original_seq <= 0 || typeof value.original_hash !== "string" || !value.original_hash || typeof value.event_id !== "string" || !value.event_id || !isValidTimestamp(value.timestamp) || typeof value.kind !== "string" || !isOptionalString(value.trace_id) || !isOptionalString(value.phase) || value.entry_ids !== undefined && (!Array.isArray(value.entry_ids) || !value.entry_ids.every((entryId) => typeof entryId === "string" && !!entryId)) || value.reason_codes !== undefined && (!Array.isArray(value.reason_codes) || !value.reason_codes.every((reason) => typeof reason === "string" && !!reason))) {
+    return null;
+  }
+  const kind = value.kind;
+  if (![
+    "membership_committed",
+    "empty_retrieval_committed",
+    "terminal_committed",
+    "terminal_attempt_rejected",
+    "terminal_attempt_idempotent",
+    "authorized_transition_committed",
+    "application_marker_committed",
+    "phase_close_intent",
+    "phase_closed",
+    "legacy_imported",
+    "legacy_unverifiable",
+    "cutover_completed",
+    "checkpoint"
+  ].includes(kind))
+    return null;
+  return {
+    original_seq: value.original_seq,
+    original_hash: value.original_hash,
+    event_id: value.event_id,
+    timestamp: value.timestamp,
+    kind,
+    trace_id: value.trace_id,
+    phase: value.phase,
+    entry_ids: value.entry_ids,
+    reason_codes: value.reason_codes
+  };
+}
+function summarizeRecord(record) {
+  const payload = record.payload;
+  const entryIds = new Set;
+  for (const collection of [
+    payload.memberships,
+    payload.transitions,
+    payload.markers,
+    payload.rejected
+  ]) {
+    if (!Array.isArray(collection))
+      continue;
+    for (const item of collection) {
+      if (isPlainRecord(item) && typeof item.entry_id === "string") {
+        entryIds.add(item.entry_id);
+      }
+    }
+  }
+  for (const entryId of Array.isArray(payload.entry_ids) ? payload.entry_ids : []) {
+    if (typeof entryId === "string")
+      entryIds.add(entryId);
+  }
+  const reasonCodes = new Set;
+  for (const reason of Array.isArray(payload.reason_codes) ? payload.reason_codes : []) {
+    if (typeof reason === "string")
+      reasonCodes.add(reason);
+  }
+  for (const rejected of Array.isArray(payload.rejected) ? payload.rejected : []) {
+    if (isPlainRecord(rejected) && typeof rejected.reason === "string") {
+      reasonCodes.add(rejected.reason);
+    }
+  }
+  return {
+    original_seq: record.seq,
+    original_hash: record.hash,
+    event_id: record.event_id,
+    timestamp: record.timestamp,
+    kind: record.kind,
+    trace_id: typeof payload.trace_id === "string" ? payload.trace_id : typeof payload.empty_trace_id === "string" ? payload.empty_trace_id : undefined,
+    phase: typeof payload.phase === "string" ? payload.phase : undefined,
+    entry_ids: entryIds.size ? [...entryIds].sort() : undefined,
+    reason_codes: reasonCodes.size ? [...reasonCodes].sort() : undefined
+  };
+}
+function parseArchiveSummary(value) {
+  const membership = parseMembership(value);
+  if (membership)
+    return membership;
+  return parseEmptyTrace(value, true);
+}
+function archiveKey(summary) {
+  return "entry_id" in summary ? `membership:${keyOf(summary.trace_id, summary.entry_id)}` : `empty:${emptyKeyOf(summary.trace_id, summary.session_id)}`;
+}
+function applyRecord(state, record) {
+  const memberships = record.payload.memberships;
+  if (record.kind === "checkpoint") {
+    state.memberships.clear();
+    state.traceIds.clear();
+    state.emptyTraces.clear();
+    state.legacyTraceRegistry.clear();
+    state.legacyUnverifiableTraceIds.clear();
+    state.phaseLifecycle.clear();
+    state.auditTail = [];
+    if (Array.isArray(memberships)) {
+      for (const value of memberships) {
+        const membership = parseMembership(value);
+        if (membership) {
+          state.traceIds.add(membership.trace_id);
+          state.memberships.set(keyOf(membership.trace_id, membership.entry_id), membership);
+        }
+      }
+    }
+    for (const value of Array.isArray(record.payload.empty_traces) ? record.payload.empty_traces : []) {
+      const trace = parseEmptyTrace(value);
+      if (trace && !("summary_kind" in trace)) {
+        state.emptyTraces.set(emptyKeyOf(trace.trace_id, trace.session_id), {
+          ...trace
+        });
+      }
+    }
+    for (const traceId of Array.isArray(record.payload.legacy_trace_registry) ? record.payload.legacy_trace_registry : []) {
+      if (typeof traceId === "string" && traceId) {
+        state.legacyTraceRegistry.add(traceId);
+      }
+    }
+    for (const traceId of Array.isArray(record.payload.legacy_unverifiable_trace_ids) ? record.payload.legacy_unverifiable_trace_ids : []) {
+      if (typeof traceId === "string" && traceId) {
+        state.legacyUnverifiableTraceIds.add(traceId);
+      }
+    }
+    for (const value of Array.isArray(record.payload.phase_lifecycle) ? record.payload.phase_lifecycle : []) {
+      const lifecycle = parsePhaseLifecycle(value);
+      if (lifecycle)
+        state.phaseLifecycle.set(phaseLifecycleKey(lifecycle.phase, lifecycle.session_id, lifecycle.task_id), lifecycle);
+    }
+    for (const value of Array.isArray(record.payload.audit_tail) ? record.payload.audit_tail : []) {
+      const summary = parseAuditSummary(value);
+      if (summary)
+        state.auditTail.push(summary);
+    }
+    state.cutoverCompleted = record.payload.cutover_completed === true;
+    state.legacyUnverifiable = record.payload.legacy_unverifiable === true;
+  } else if (record.kind === "membership_committed" || record.kind === "legacy_imported") {
+    if (Array.isArray(memberships)) {
+      for (const value of memberships) {
+        const membership = parseMembership(value);
+        if (membership) {
+          state.traceIds.add(membership.trace_id);
+          state.memberships.set(keyOf(membership.trace_id, membership.entry_id), membership);
+          if (record.kind === "legacy_imported") {
+            state.legacyTraceRegistry.add(membership.trace_id);
+          }
+        }
+      }
+    }
+  } else if (record.kind === "empty_retrieval_committed") {
+    const trace = parseEmptyTrace(record.payload.trace);
+    if (trace && !("summary_kind" in trace)) {
+      state.emptyTraces.set(emptyKeyOf(trace.trace_id, trace.session_id), {
+        ...trace
+      });
+    }
+  } else if (record.kind === "terminal_committed" || record.kind === "authorized_transition_committed") {
+    for (const value of Array.isArray(record.payload.transitions) ? record.payload.transitions : []) {
+      const transition = value;
+      const membership = state.memberships.get(keyOf(transition.trace_id, transition.entry_id));
+      const terminal = parseTerminal(transition.terminal);
+      if (membership && terminal) {
+        const history = membership.terminal_history ?? [];
+        if (!history.some((item) => item.event_id === terminal.event_id)) {
+          history.push({ ...terminal });
+        }
+        membership.terminal_history = history;
+        membership.terminal = { ...terminal };
+        if (transition.cohort_id !== undefined) {
+          membership.cohort_id = transition.cohort_id;
+        }
+        if (transition.source_link_id !== undefined) {
+          membership.source_link_id = transition.source_link_id;
+        }
+      }
+    }
+    const emptyTraceId = record.payload.empty_trace_id;
+    if (typeof emptyTraceId === "string") {
+      const emptySessionId = record.payload.empty_trace_session_id;
+      const trace = typeof emptySessionId === "string" ? state.emptyTraces.get(emptyKeyOf(emptyTraceId, emptySessionId)) : [...state.emptyTraces.values()].find((candidate) => candidate.trace_id === emptyTraceId);
+      if (trace)
+        trace.terminal_event_id = record.event_id;
+    }
+  } else if (record.kind === "application_marker_committed") {
+    for (const value of Array.isArray(record.payload.transitions) ? record.payload.transitions : []) {
+      const transition = value;
+      const membership = state.memberships.get(keyOf(transition.trace_id, transition.entry_id));
+      const terminal = parseTerminal(transition.terminal);
+      if (membership && terminal) {
+        const history = membership.terminal_history ?? [];
+        if (!history.some((item) => item.event_id === terminal.event_id)) {
+          history.push({ ...terminal });
+        }
+        membership.terminal_history = history;
+        membership.terminal = { ...terminal };
+      }
+    }
+    for (const value of Array.isArray(record.payload.markers) ? record.payload.markers : []) {
+      const transition = value;
+      const membership = state.memberships.get(keyOf(transition.trace_id, transition.entry_id));
+      const marker = parseApplicationMarker(transition.marker);
+      if (membership && marker) {
+        membership.application_marker = { ...marker };
+      }
+    }
+  } else if (record.kind === "phase_close_intent" || record.kind === "phase_closed") {
+    const phase = record.payload.phase;
+    const sessionId = record.payload.session_id;
+    const taskId = record.payload.task_id;
+    if (typeof phase === "string" && typeof sessionId === "string" && isOptionalString(taskId)) {
+      const lifecycleKey = phaseLifecycleKey(phase, sessionId, taskId);
+      const lifecycle = state.phaseLifecycle.get(lifecycleKey) ?? {
+        phase,
+        session_id: sessionId,
+        task_id: taskId
+      };
+      if (record.kind === "phase_close_intent" && !lifecycle.intent_event_id) {
+        lifecycle.intent_event_id = record.event_id;
+        lifecycle.intent_at = record.timestamp;
+      } else if (record.kind === "phase_closed" && !lifecycle.closed_event_id) {
+        lifecycle.closed_event_id = record.event_id;
+        lifecycle.closed_at = record.timestamp;
+      }
+      state.phaseLifecycle.set(lifecycleKey, lifecycle);
+      for (const membership of state.memberships.values()) {
+        if (membership.phase !== phase || membership.session_id !== sessionId || membership.task_id !== taskId)
+          continue;
+        if (record.kind === "phase_close_intent" && !membership.phase_close_intent_at)
+          membership.phase_close_intent_at = record.timestamp;
+        else if (record.kind === "phase_closed" && !membership.phase_closed_at)
+          membership.phase_closed_at = record.timestamp;
+      }
+      for (const trace of state.emptyTraces.values()) {
+        if (trace.phase !== phase || trace.session_id !== sessionId || trace.task_id !== taskId)
+          continue;
+        if (record.kind === "phase_close_intent" && !trace.phase_close_intent_at) {
+          trace.phase_close_intent_at = record.timestamp;
+        } else if (record.kind === "phase_closed" && !trace.phase_closed_at) {
+          trace.phase_closed_at = record.timestamp;
+        }
+      }
+    }
+  } else if (record.kind === "cutover_completed") {
+    state.cutoverCompleted = true;
+    for (const traceId of Array.isArray(record.payload.imported_trace_ids) ? record.payload.imported_trace_ids : []) {
+      if (typeof traceId === "string" && traceId)
+        state.legacyTraceRegistry.add(traceId);
+    }
+  } else if (record.kind === "legacy_unverifiable") {
+    state.legacyUnverifiable = true;
+    for (const traceId of Array.isArray(record.payload.trace_ids) ? record.payload.trace_ids : []) {
+      if (typeof traceId === "string" && traceId) {
+        state.legacyUnverifiableTraceIds.add(traceId);
+      }
+    }
+  }
+  if (record.kind !== "checkpoint") {
+    state.auditTail.push(summarizeRecord(record));
+    if (state.auditTail.length > MAX_AUDIT_TAIL_RECORDS) {
+      state.auditTail.splice(0, state.auditTail.length - MAX_AUDIT_TAIL_RECORDS);
+    }
+  }
+  state.lastSeq = record.seq;
+  state.lastHash = record.hash;
+  state.recordCount++;
+}
+function isTerminalTransition(value) {
+  if (!isPlainRecord(value))
+    return false;
+  return hasOnlyKeys(value, [
+    "trace_id",
+    "entry_id",
+    "terminal",
+    "cohort_id",
+    "source_link_id"
+  ]) && typeof value.trace_id === "string" && !!value.trace_id && typeof value.entry_id === "string" && !!value.entry_id && parseTerminal(value.terminal) !== null && isOptionalString(value.cohort_id) && isOptionalString(value.source_link_id);
+}
+function isMarkerTransition(value) {
+  if (!isPlainRecord(value))
+    return false;
+  return hasOnlyKeys(value, ["trace_id", "entry_id", "marker"]) && typeof value.trace_id === "string" && !!value.trace_id && typeof value.entry_id === "string" && !!value.entry_id && parseApplicationMarker(value.marker) !== null;
+}
+function isAuthorizationPayload(value) {
+  if (!isPlainRecord(value))
+    return false;
+  return hasOnlyKeys(value, [
+    "actor",
+    "reason",
+    "expected_event_id",
+    "expected_outcome"
+  ]) && (value.actor === "manual-override" || value.actor === "reviewer-remediation" || value.actor === "phase-override") && typeof value.reason === "string" && typeof value.expected_event_id === "string" && (value.expected_outcome === undefined || isReceiptOutcome(value.expected_outcome));
+}
+function validateRecordPayload(row) {
+  const payload = row.payload;
+  if (!isPlainRecord(payload))
+    return false;
+  switch (row.kind) {
+    case "membership_committed":
+    case "legacy_imported":
+      return hasOnlyKeys(payload, ["memberships"]) && Array.isArray(payload.memberships) && payload.memberships.length > 0 && payload.memberships.every((item) => parseMembership(item) !== null);
+    case "empty_retrieval_committed":
+      return hasOnlyKeys(payload, ["trace"]) && parseEmptyTrace(payload.trace) !== null;
+    case "terminal_committed":
+    case "authorized_transition_committed": {
+      if (!hasOnlyKeys(payload, [
+        "transitions",
+        "authorization",
+        "empty_trace_id",
+        "empty_trace_session_id"
+      ]))
+        return false;
+      const transitionsValid = payload.transitions === undefined || Array.isArray(payload.transitions) && payload.transitions.every(isTerminalTransition);
+      const emptyValid = payload.empty_trace_id === undefined || typeof payload.empty_trace_id === "string" && !!payload.empty_trace_id && typeof payload.empty_trace_session_id === "string" && !!payload.empty_trace_session_id;
+      const authorizationValid = payload.authorization === undefined || isAuthorizationPayload(payload.authorization);
+      return transitionsValid && emptyValid && authorizationValid && (payload.transitions !== undefined || payload.empty_trace_id !== undefined);
+    }
+    case "application_marker_committed":
+      return hasOnlyKeys(payload, ["markers", "transitions"]) && (payload.markers === undefined || Array.isArray(payload.markers) && payload.markers.every(isMarkerTransition)) && (payload.transitions === undefined || Array.isArray(payload.transitions) && payload.transitions.every(isTerminalTransition)) && (payload.markers !== undefined || payload.transitions !== undefined);
+    case "terminal_attempt_idempotent":
+      return hasOnlyKeys(payload, ["trace_id", "entry_ids"]) && typeof payload.trace_id === "string" && Array.isArray(payload.entry_ids) && payload.entry_ids.every((entryId) => typeof entryId === "string" && !!entryId);
+    case "terminal_attempt_rejected":
+      return hasOnlyKeys(payload, ["trace_id", "rejected"]) && typeof payload.trace_id === "string" && Array.isArray(payload.rejected) && payload.rejected.every((item) => isPlainRecord(item) && hasOnlyKeys(item, ["entry_id", "reason"]) && typeof item.entry_id === "string" && typeof item.reason === "string");
+    case "phase_close_intent":
+    case "phase_closed":
+      return hasOnlyKeys(payload, ["phase", "session_id", "task_id"]) && typeof payload.phase === "string" && !!payload.phase && typeof payload.session_id === "string" && !!payload.session_id && isOptionalString(payload.task_id);
+    case "legacy_unverifiable":
+      return hasOnlyKeys(payload, ["reason_codes", "trace_ids"]) && Array.isArray(payload.reason_codes) && payload.reason_codes.every((reason) => typeof reason === "string" && !!reason) && (payload.trace_ids === undefined || Array.isArray(payload.trace_ids) && payload.trace_ids.every((traceId) => typeof traceId === "string" && !!traceId));
+    case "cutover_completed":
+      return hasOnlyKeys(payload, ["imported_count", "imported_trace_ids"]) && Number.isInteger(payload.imported_count) && payload.imported_count >= 0 && Array.isArray(payload.imported_trace_ids) && payload.imported_trace_ids.every((traceId) => typeof traceId === "string" && !!traceId);
+    case "checkpoint":
+      return hasOnlyKeys(payload, [
+        "memberships",
+        "empty_traces",
+        "cutover_completed",
+        "legacy_unverifiable",
+        "legacy_trace_registry",
+        "legacy_unverifiable_trace_ids",
+        "phase_lifecycle",
+        "audit_tail"
+      ]) && Array.isArray(payload.memberships) && payload.memberships.every((item) => parseMembership(item) !== null) && Array.isArray(payload.empty_traces) && payload.empty_traces.every((item) => parseEmptyTrace(item) !== null) && typeof payload.cutover_completed === "boolean" && typeof payload.legacy_unverifiable === "boolean" && Array.isArray(payload.legacy_trace_registry) && payload.legacy_trace_registry.every((traceId) => typeof traceId === "string" && !!traceId) && Array.isArray(payload.legacy_unverifiable_trace_ids) && payload.legacy_unverifiable_trace_ids.every((traceId) => typeof traceId === "string" && !!traceId) && Array.isArray(payload.phase_lifecycle) && payload.phase_lifecycle.every((item) => parsePhaseLifecycle(item) !== null) && Array.isArray(payload.audit_tail) && payload.audit_tail.length <= MAX_AUDIT_TAIL_RECORDS && payload.audit_tail.every((item) => parseAuditSummary(item) !== null);
+  }
+}
+function validateRecord(value, state) {
+  if (!value || typeof value !== "object")
+    throw new Error("record is not an object");
+  const row = value;
+  if (row.schema_version !== RECEIPT_SCHEMA_VERSION || row.cutover_version !== RECEIPT_CUTOVER_VERSION || row.seq !== state.lastSeq + 1 || row.prev_hash !== state.lastHash || !Number.isInteger(row.seq) || typeof row.event_id !== "string" || !row.event_id || !isValidTimestamp(row.timestamp) || ![
+    "membership_committed",
+    "empty_retrieval_committed",
+    "terminal_committed",
+    "terminal_attempt_rejected",
+    "terminal_attempt_idempotent",
+    "authorized_transition_committed",
+    "application_marker_committed",
+    "phase_close_intent",
+    "phase_closed",
+    "legacy_imported",
+    "legacy_unverifiable",
+    "cutover_completed",
+    "checkpoint"
+  ].includes(row.kind) || typeof row.hash !== "string")
+    throw new Error("record contract or chain mismatch");
+  const { hash, ...withoutHash } = row;
+  if (receiptRecordHash(withoutHash) !== hash)
+    throw new Error("record hash mismatch");
+  if (!validateRecordPayload(row))
+    throw new Error("record payload mismatch");
+  return row;
+}
+async function loadState(paths, observations = []) {
+  const raw = await readUtf8IfPresent(paths.journal, MAX_JOURNAL_BYTES);
+  const state = emptyState(observations);
+  if (!raw)
+    return state;
+  const lines = raw.split(`
+`);
+  const endedWithNewline = raw.endsWith(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    try {
+      applyRecord(state, validateRecord(JSON.parse(line), state));
+    } catch (error) {
+      const isPartialTail = i === lines.length - 1 && !endedWithNewline;
+      if (isPartialTail) {
+        await atomicWriteFsynced(paths.quarantine, `${JSON.stringify({
+          recovered_at: nowIso(),
+          partial_tail: line.slice(0, 1024 * 1024)
+        })}
+`);
+        await atomicWriteFsynced(paths.journal, `${lines.slice(0, i).filter(Boolean).join(`
+`)}
+`);
+        return state;
+      }
+      throw new ReceiptStoreError("store_corrupt", `receipt journal corruption at line ${i + 1}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return state;
+}
+function makeRecord(state, kind, payload, eventId = randomUUID2()) {
+  const withoutHash = {
+    schema_version: RECEIPT_SCHEMA_VERSION,
+    cutover_version: RECEIPT_CUTOVER_VERSION,
+    seq: state.lastSeq + 1,
+    prev_hash: state.lastHash,
+    event_id: eventId,
+    timestamp: nowIso(),
+    kind,
+    payload
+  };
+  return { ...withoutHash, hash: receiptRecordHash(withoutHash) };
+}
+async function appendRecord(paths, state, row) {
+  await appendFsynced(paths.journal, `${JSON.stringify(row)}
+`);
+  applyRecord(state, row);
+  queueRecordObservations(state, row);
+}
+function rejectionReasonCode(value) {
+  switch (value) {
+    case "trace_not_found":
+    case "id_not_in_trace":
+    case "wrong_session":
+    case "wrong_phase":
+    case "wrong_task":
+    case "duplicate_conflicting_terminal":
+    case "event_id_conflict":
+    case "invalid_outcome":
+    case "empty_receipt":
+    case "unauthorized_transition":
+    case "legacy_unverifiable":
+      return value;
+    default:
+      return "store_unavailable";
+  }
+}
+function queueRecordObservations(state, row) {
+  const base = {
+    transition: row.kind,
+    schemaVersion: RECEIPT_SCHEMA_VERSION
+  };
+  if (row.kind === "membership_committed" || row.kind === "legacy_imported") {
+    for (const value of Array.isArray(row.payload.memberships) ? row.payload.memberships : []) {
+      const membership = parseMembership(value);
+      if (!membership)
+        continue;
+      state.observations.push({
+        ...base,
+        reasonCode: "committed",
+        knowledgeTraceId: membership.trace_id,
+        knowledgeEntryId: membership.entry_id,
+        sessionId: membership.session_id,
+        taskId: membership.task_id,
+        phase: membership.phase,
+        receiptOutcome: membership.terminal?.outcome,
+        receiptSource: membership.terminal?.source
+      });
+    }
+    return;
+  }
+  if (row.kind === "empty_retrieval_committed") {
+    const trace = row.payload.trace;
+    if (trace?.trace_id) {
+      state.observations.push({
+        ...base,
+        reasonCode: "committed",
+        knowledgeTraceId: trace.trace_id,
+        sessionId: trace.session_id,
+        taskId: trace.task_id,
+        phase: trace.phase,
+        receiptOutcome: trace.terminal_event_id ? "no_relevant" : undefined
+      });
+    }
+    return;
+  }
+  if (row.kind === "terminal_committed" || row.kind === "authorized_transition_committed" || row.kind === "application_marker_committed") {
+    const values = row.kind === "application_marker_committed" ? row.payload.markers : row.payload.transitions;
+    for (const value of Array.isArray(values) ? values : []) {
+      const transition = value;
+      const outcome = transition.terminal?.outcome ?? transition.marker?.outcome;
+      const source = transition.terminal?.source ?? transition.marker?.source;
+      state.observations.push({
+        ...base,
+        reasonCode: "committed",
+        knowledgeTraceId: transition.trace_id,
+        knowledgeEntryId: transition.entry_id,
+        receiptOutcome: outcome,
+        receiptSource: source
+      });
+    }
+    if (typeof row.payload.empty_trace_id === "string") {
+      state.observations.push({
+        ...base,
+        reasonCode: "committed",
+        knowledgeTraceId: row.payload.empty_trace_id,
+        receiptOutcome: "no_relevant"
+      });
+    }
+    return;
+  }
+  if (row.kind === "terminal_attempt_rejected") {
+    for (const value of Array.isArray(row.payload.rejected) ? row.payload.rejected : []) {
+      const rejected = value;
+      state.observations.push({
+        ...base,
+        reasonCode: rejectionReasonCode(rejected.reason),
+        knowledgeTraceId: typeof row.payload.trace_id === "string" ? row.payload.trace_id : undefined,
+        knowledgeEntryId: rejected.entry_id
+      });
+    }
+    return;
+  }
+  if (row.kind === "terminal_attempt_idempotent") {
+    for (const entryId of Array.isArray(row.payload.entry_ids) ? row.payload.entry_ids : []) {
+      state.observations.push({
+        ...base,
+        reasonCode: "idempotent",
+        knowledgeTraceId: typeof row.payload.trace_id === "string" ? row.payload.trace_id : undefined,
+        knowledgeEntryId: typeof entryId === "string" ? entryId : undefined
+      });
+    }
+    return;
+  }
+  state.observations.push({
+    ...base,
+    reasonCode: row.kind === "legacy_unverifiable" ? "legacy_unverifiable" : "committed",
+    knowledgeTraceId: typeof row.payload.trace_id === "string" ? row.payload.trace_id : undefined,
+    phase: typeof row.payload.phase === "string" ? row.payload.phase : undefined
+  });
+}
+async function writeSnapshot(paths, state) {
+  const snapshot = {
+    schema_version: RECEIPT_SCHEMA_VERSION,
+    cutover_version: RECEIPT_CUTOVER_VERSION,
+    authoritative: false,
+    rebuildable: true,
+    through_seq: state.lastSeq,
+    through_hash: state.lastHash,
+    memberships: [...state.memberships.values()],
+    empty_traces: [...state.emptyTraces.values()],
+    cutover_completed: state.cutoverCompleted,
+    legacy_unverifiable: state.legacyUnverifiable,
+    legacy_trace_registry: [...state.legacyTraceRegistry].sort(),
+    legacy_unverifiable_trace_ids: [...state.legacyUnverifiableTraceIds].sort(),
+    phase_lifecycle: [...state.phaseLifecycle.values()],
+    audit_tail: state.auditTail
+  };
+  await atomicWriteFsynced(paths.snapshot, `${JSON.stringify(snapshot)}
+`);
+}
+function unavailable(error) {
+  if (error instanceof ReceiptStoreError)
+    return {
+      ok: false,
+      code: error.code,
+      detail: error.message,
+      uncertainty: error.message
+    };
+  const detail = error instanceof Error ? error.message : String(error);
+  return { ok: false, code: "store_unavailable", detail, uncertainty: detail };
+}
+async function ensureCutoverLocked(paths, state, graceDays) {
+  if (state.cutoverCompleted)
+    return;
+  const imported = [];
+  const unverifiable = new Set;
+  const unverifiableTraceIds = new Set;
+  if (existsSync2(paths.linkPointer)) {
+    unverifiable.add("linked_legacy_store");
+  } else {
+    let raw = null;
+    try {
+      raw = await readUtf8IfPresent(paths.legacyEvents, MAX_LEGACY_BYTES);
+    } catch (error) {
+      if (error instanceof ReceiptStoreError && error.code === "store_corrupt") {
+        unverifiable.add("oversized_legacy_store");
+      } else {
+        throw error;
+      }
+    }
+    if (raw) {
+      const events = [];
+      for (const line of raw.split(`
+`).filter(Boolean)) {
+        try {
+          events.push(JSON.parse(line));
+        } catch {
+          unverifiable.add("malformed_legacy_line");
+        }
+      }
+      const retrievals = new Map;
+      const observedTraceIds = new Set;
+      for (const event of events) {
+        if (typeof event.trace_id === "string" && event.trace_id) {
+          observedTraceIds.add(event.trace_id);
+        }
+        if (event.type !== "retrieved" || typeof event.trace_id !== "string") {
+          continue;
+        }
+        const rows = retrievals.get(event.trace_id) ?? [];
+        rows.push(event);
+        retrievals.set(event.trace_id, rows);
+      }
+      for (const [traceId, rows] of retrievals) {
+        if (rows.length !== 1) {
+          unverifiable.add("duplicate_legacy_trace");
+          unverifiableTraceIds.add(traceId);
+          continue;
+        }
+        const event = rows[0];
+        if (typeof event.session_id !== "string" || !event.session_id || !Array.isArray(event.result_ids)) {
+          unverifiable.add("malformed_legacy_membership");
+          unverifiableTraceIds.add(traceId);
+          continue;
+        }
+        const timestamp = typeof event.timestamp === "string" ? event.timestamp : "";
+        if (!Number.isFinite(Date.parse(timestamp))) {
+          unverifiable.add("malformed_legacy_timestamp");
+          unverifiableTraceIds.add(traceId);
+          continue;
+        }
+        const entryIds = event.result_ids;
+        if (entryIds.length === 0 || entryIds.some((entryId) => typeof entryId !== "string" || !entryId) || new Set(entryIds).size !== entryIds.length) {
+          unverifiable.add("malformed_legacy_membership");
+          unverifiableTraceIds.add(traceId);
+          continue;
+        }
+        const traceMemberships = [];
+        let traceUnverifiable = false;
+        for (const entryId of entryIds) {
+          const terminals = events.filter((candidate) => isReceiptOutcome(candidate.type) && candidate.trace_id === traceId && candidate.knowledge_id === entryId && candidate.session_id === event.session_id);
+          const distinctOutcomes = new Set(terminals.map((terminal2) => terminal2.type));
+          if (distinctOutcomes.size > 1) {
+            unverifiable.add("conflicting_legacy_terminal");
+            unverifiableTraceIds.add(traceId);
+            traceUnverifiable = true;
+            break;
+          }
+          const terminalEvent = terminals.at(-1);
+          let terminal;
+          if (terminalEvent) {
+            if (typeof terminalEvent.event_id !== "string" || !terminalEvent.event_id || typeof terminalEvent.timestamp !== "string" || !Number.isFinite(Date.parse(terminalEvent.timestamp))) {
+              unverifiable.add("malformed_legacy_terminal");
+              unverifiableTraceIds.add(traceId);
+              traceUnverifiable = true;
+              break;
+            }
+            terminal = {
+              outcome: terminalEvent.type,
+              source: typeof terminalEvent.source === "string" ? terminalEvent.source : "unknown",
+              reason: typeof terminalEvent.reason === "string" ? terminalEvent.reason : undefined,
+              event_id: terminalEvent.event_id,
+              committed_at: terminalEvent.timestamp
+            };
+          }
+          traceMemberships.push({
+            trace_id: traceId,
+            entry_id: entryId,
+            session_id: event.session_id,
+            phase: typeof event.phase === "string" ? event.phase : undefined,
+            task_id: typeof event.task_id === "string" ? event.task_id : undefined,
+            agent: typeof event.agent === "string" ? event.agent : undefined,
+            critical: true,
+            committed_at: timestamp,
+            membership_event_id: typeof event.event_id === "string" && event.event_id ? event.event_id : randomUUID2(),
+            grace_days: graceDays,
+            exposure_kind: legacyExposureKind(event),
+            origin: "legacy",
+            terminal,
+            terminal_history: terminal ? [{ ...terminal }] : undefined
+          });
+        }
+        if (!traceUnverifiable) {
+          imported.push(...traceMemberships);
+        }
+      }
+      for (const traceId of observedTraceIds) {
+        if (!retrievals.has(traceId)) {
+          unverifiable.add("evicted_legacy_membership");
+          unverifiableTraceIds.add(traceId);
+        }
+      }
+    } else {
+      unverifiable.add(existsSync2(paths.legacyEvents) ? "empty_legacy_store" : "missing_legacy_store");
+    }
+  }
+  if (imported.length)
+    await appendRecord(paths, state, makeRecord(state, "legacy_imported", { memberships: imported }));
+  if (unverifiable.size) {
+    await appendRecord(paths, state, makeRecord(state, "legacy_unverifiable", {
+      reason_codes: [...unverifiable].sort(),
+      trace_ids: [...unverifiableTraceIds].sort()
+    }));
+  }
+  await appendRecord(paths, state, makeRecord(state, "cutover_completed", {
+    imported_count: imported.length,
+    imported_trace_ids: [
+      ...new Set(imported.map((membership) => membership.trace_id))
+    ].sort()
+  }));
+}
+function isReceiptOutcome(value) {
+  return value === "applied" || value === "ignored" || value === "contradicted" || value === "violated" || value === "n_a";
+}
+function isLegacyUnverifiableTrace(state, traceId) {
+  if (state.legacyTraceRegistry.has(traceId))
+    return true;
+  if (state.legacyUnverifiableTraceIds.has(traceId))
+    return true;
+  if (!state.legacyUnverifiable)
+    return false;
+  return ![...state.memberships.values()].some((membership) => membership.origin === "v2");
+}
+async function runLocked(directory, graceDays, action, options = {}) {
+  const observations = [];
+  try {
+    const result = await withReceiptLedgerLock(directory, async (paths) => {
+      const state = await loadState(paths, observations);
+      const resolvedGraceDays = graceDays ?? (state.cutoverCompleted ? DEFAULT_RECEIPT_GRACE_DAYS : configuredGraceDays(directory));
+      await ensureCutoverLocked(paths, state, resolvedGraceDays);
+      if (options.compact !== false)
+        await compactIfNeeded(paths, state);
+      const result2 = await action(paths, state, resolvedGraceDays);
+      if (options.writeSnapshot !== false) {
+        await _internals3.writeSnapshot(paths, state).catch(() => {
+          return;
+        });
+      }
+      return { ok: true, ...result2 };
+    });
+    for (const observation of observations) {
+      emitKnowledgeReceiptTransition(observation);
+    }
+    return result;
+  } catch (error) {
+    for (const observation of observations) {
+      emitKnowledgeReceiptTransition(observation);
+    }
+    return unavailable(error);
+  }
+}
+async function commitApplicationMarkerBatch(directory, input) {
+  return runLocked(directory, undefined, async (paths, state) => {
+    const items = input.items ?? input.markers ?? [];
+    const committed = [];
+    const idempotent = [];
+    const rejected = [];
+    const transitions = [];
+    const traceExists = state.traceIds.has(input.trace_id);
+    const staged = new Map;
+    for (const item of items) {
+      const membership = state.memberships.get(keyOf(input.trace_id, item.entry_id));
+      if (!membership) {
+        rejected.push({
+          entry_id: item.entry_id,
+          reason: traceExists ? "id_not_in_trace" : isLegacyUnverifiableTrace(state, input.trace_id) ? "legacy_unverifiable" : "trace_not_found"
+        });
+        continue;
+      }
+      if (membership.session_id !== input.session_id) {
+        rejected.push({ entry_id: item.entry_id, reason: "wrong_session" });
+        continue;
+      }
+      const stagedOutcome = staged.get(item.entry_id);
+      if (stagedOutcome !== undefined) {
+        if (stagedOutcome === item.outcome)
+          idempotent.push(item.entry_id);
+        else {
+          rejected.push({
+            entry_id: item.entry_id,
+            reason: "duplicate_conflicting_terminal"
+          });
+        }
+        continue;
+      }
+      staged.set(item.entry_id, item.outcome);
+      if (membership.application_marker?.outcome === item.outcome) {
+        idempotent.push(item.entry_id);
+        continue;
+      }
+      if (membership.application_marker) {
+        rejected.push({
+          entry_id: item.entry_id,
+          reason: "duplicate_conflicting_terminal"
+        });
+        continue;
+      }
+      const eventId = randomUUID2();
+      const marker = {
+        outcome: item.outcome,
+        source: item.source ?? "unknown",
+        reason: item.reason,
+        event_id: eventId,
+        committed_at: nowIso()
+      };
+      transitions.push({
+        trace_id: input.trace_id,
+        entry_id: item.entry_id,
+        marker
+      });
+      committed.push({
+        entry_id: item.entry_id,
+        outcome: item.outcome,
+        event_id: eventId
+      });
+    }
+    if (transitions.length) {
+      await appendRecord(paths, state, makeRecord(state, "application_marker_committed", {
+        markers: transitions
+      }));
+    }
+    return { committed, idempotent, rejected };
+  });
+}
+async function queryHistoricalOutcomes(directory, entryIds, graceDays) {
+  return runLocked(directory, graceDays, async (paths, state) => {
+    const wanted = entryIds ? new Set(entryIds) : null;
+    const memberships = new Map;
+    for (const membership of state.memberships.values()) {
+      if (!wanted || wanted.has(membership.entry_id)) {
+        memberships.set(archiveKey(membership), membership);
+      }
+    }
+    const raw = await readUtf8IfPresent(paths.archive, MAX_ARCHIVE_BYTES);
+    if (raw) {
+      for (const line of raw.split(`
+`).filter(Boolean)) {
+        let summary = null;
+        try {
+          summary = parseArchiveSummary(JSON.parse(line));
+        } catch {}
+        if (!summary) {
+          throw new ReceiptStoreError("store_corrupt", "receipt archive contains an invalid authoritative summary");
+        }
+        if ("entry_id" in summary && (!wanted || wanted.has(summary.entry_id))) {
+          const key = archiveKey(summary);
+          if (!memberships.has(key))
+            memberships.set(key, summary);
+        }
+      }
+    }
+    return { memberships: [...memberships.values()] };
+  }, { compact: false, writeSnapshot: false });
+}
+async function phaseTransition(directory, phase, kind, sessionId, taskId, graceDays) {
+  return runLocked(directory, graceDays, async (paths, state) => {
+    if (!phase.trim()) {
+      throw new ReceiptStoreError("store_unavailable", "phase is required");
+    }
+    const scopeKeys = new Map;
+    const addScope = (scopeSessionId, scopeTaskId) => {
+      if (sessionId !== undefined && scopeSessionId !== sessionId || taskId !== undefined && scopeTaskId !== taskId)
+        return;
+      scopeKeys.set(phaseLifecycleKey(phase, scopeSessionId, scopeTaskId), {
+        session_id: scopeSessionId,
+        task_id: scopeTaskId
+      });
+    };
+    for (const membership of state.memberships.values()) {
+      if (membership.phase === phase)
+        addScope(membership.session_id, membership.task_id);
+    }
+    for (const trace of state.emptyTraces.values()) {
+      if (trace.phase === phase)
+        addScope(trace.session_id, trace.task_id);
+    }
+    for (const lifecycle of state.phaseLifecycle.values()) {
+      if (lifecycle.phase === phase)
+        addScope(lifecycle.session_id, lifecycle.task_id);
+    }
+    if (scopeKeys.size === 0 && sessionId !== undefined) {
+      addScope(sessionId, taskId);
+    }
+    if (scopeKeys.size === 0) {
+      throw new ReceiptStoreError("store_unavailable", "no exact receipt lifecycle scope exists for phase closure");
+    }
+    if (sessionId === undefined && scopeKeys.size !== 1) {
+      throw new ReceiptStoreError("store_unavailable", "receipt lifecycle scope is ambiguous without an exact session identity");
+    }
+    let eventId = "";
+    for (const [key, scope] of scopeKeys) {
+      const lifecycle = state.phaseLifecycle.get(key);
+      const existingEventId = kind === "phase_close_intent" ? lifecycle?.intent_event_id : lifecycle?.closed_event_id;
+      if (existingEventId) {
+        eventId ||= existingEventId;
+        continue;
+      }
+      const row = makeRecord(state, kind, { phase, ...scope });
+      await appendRecord(paths, state, row);
+      eventId ||= row.event_id;
+    }
+    if (kind === "phase_closed")
+      await compactIfNeeded(paths, state);
+    return { event_id: eventId };
+  });
+}
+var recordPhaseCloseIntent = (directory, phase, sessionId, taskId) => phaseTransition(directory, phase, "phase_close_intent", sessionId, taskId);
+var commitPhaseClosed = (directory, phase, sessionId, taskId) => phaseTransition(directory, phase, "phase_closed", sessionId, taskId);
+async function reconcilePhaseClose(directory, phase, durablePlanClosed, sessionId, taskId) {
+  if (!durablePlanClosed)
+    return { ok: true, reconciled: false };
+  const result = await commitPhaseClosed(directory, phase, sessionId, taskId);
+  return result.ok ? { ok: true, reconciled: true } : result;
+}
+async function compactIfNeeded(paths, state) {
+  const now = _internals3.nowMs();
+  const eligible = [...state.memberships.values()].filter((m) => m.terminal && m.phase_closed_at && now >= Date.parse(m.phase_closed_at) + m.grace_days * 86400000);
+  const eligibleEmpty = [...state.emptyTraces.values()].filter((trace) => trace.terminal_event_id && trace.phase_closed_at && now >= Date.parse(trace.phase_closed_at) + trace.grace_days * 86400000);
+  if (!eligible.length && !eligibleEmpty.length && state.recordCount <= _internals3.maxJournalRecords)
+    return;
+  const archiveById = new Map;
+  const existing = await readUtf8IfPresent(paths.archive, MAX_ARCHIVE_BYTES);
+  if (existing) {
+    for (const line of existing.split(`
+`).filter(Boolean)) {
+      let summary = null;
+      try {
+        summary = parseArchiveSummary(JSON.parse(line));
+      } catch {}
+      if (!summary) {
+        throw new ReceiptStoreError("store_corrupt", "receipt archive contains an invalid summary");
+      }
+      archiveById.set(archiveKey(summary), summary);
+    }
+  }
+  const retainedArchive = [...archiveById.values()];
+  let archiveContent = serializeArchive(retainedArchive);
+  let archiveBytes = Buffer.byteLength(archiveContent, "utf8");
+  let archiveChanged = false;
+  const retainIfCapacity = (summary) => {
+    const key = archiveKey(summary);
+    if (archiveById.has(key))
+      return;
+    const line = `${JSON.stringify(summary)}
+`;
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    if (retainedArchive.length + 1 > _internals3.maxArchiveRecords || archiveBytes + lineBytes > _internals3.maxArchiveBytes) {
+      return;
+    }
+    archiveById.set(key, summary);
+    retainedArchive.push(summary);
+    archiveContent += line;
+    archiveBytes += lineBytes;
+    archiveChanged = true;
+  };
+  for (const membership of eligible)
+    retainIfCapacity(membership);
+  for (const trace of eligibleEmpty) {
+    retainIfCapacity({ ...trace, summary_kind: "empty_trace" });
+  }
+  if (archiveChanged) {
+    await _internals3.atomicWriteFsynced(paths.archive, archiveContent);
+  }
+  const retainedIds = new Set(retainedArchive.map(archiveKey));
+  for (const membership of eligible) {
+    if (retainedIds.has(archiveKey(membership))) {
+      state.memberships.delete(keyOf(membership.trace_id, membership.entry_id));
+    }
+  }
+  for (const trace of eligibleEmpty) {
+    const summary = {
+      ...trace,
+      summary_kind: "empty_trace"
+    };
+    if (retainedIds.has(archiveKey(summary))) {
+      state.emptyTraces.delete(emptyKeyOf(trace.trace_id, trace.session_id));
+    }
+  }
+  for (const traceId of [...state.legacyTraceRegistry]) {
+    const stillLive = [...state.memberships.values()].some((membership) => membership.origin === "legacy" && membership.trace_id === traceId);
+    if (!stillLive)
+      state.legacyTraceRegistry.delete(traceId);
+  }
+  state.traceIds = new Set([...state.memberships.values()].map((membership) => membership.trace_id));
+  const fresh = emptyState(state.observations);
+  fresh.cutoverCompleted = state.cutoverCompleted;
+  fresh.legacyUnverifiable = state.legacyUnverifiable;
+  fresh.legacyTraceRegistry = new Set(state.legacyTraceRegistry);
+  fresh.legacyUnverifiableTraceIds = new Set(state.legacyUnverifiableTraceIds);
+  fresh.phaseLifecycle = new Map(state.phaseLifecycle);
+  fresh.auditTail = [...state.auditTail];
+  const checkpoint = makeRecord(fresh, "checkpoint", {
+    memberships: [...state.memberships.values()],
+    empty_traces: [...state.emptyTraces.values()],
+    cutover_completed: state.cutoverCompleted,
+    legacy_unverifiable: state.legacyUnverifiable,
+    legacy_trace_registry: [...state.legacyTraceRegistry].sort(),
+    legacy_unverifiable_trace_ids: [...state.legacyUnverifiableTraceIds].sort(),
+    phase_lifecycle: [...state.phaseLifecycle.values()],
+    audit_tail: state.auditTail
+  });
+  await _internals3.atomicWriteFsynced(paths.journal, `${JSON.stringify(checkpoint)}
+`);
+  state.lastSeq = checkpoint.seq;
+  state.lastHash = checkpoint.hash;
+  state.recordCount = 1;
+  queueRecordObservations(state, checkpoint);
+}
+function serializeArchive(summaries) {
+  return summaries.length ? `${summaries.map((summary) => JSON.stringify(summary)).join(`
+`)}
+` : "";
+}
+var _internals3 = {
+  nowMs: () => Date.now(),
+  writeSnapshot,
+  atomicWriteFsynced,
+  commitApplicationMarkerBatch,
+  maxJournalRecords: MAX_JOURNAL_RECORDS,
+  maxArchiveRecords: MAX_ARCHIVE_RECORDS,
+  maxArchiveBytes: MAX_ARCHIVE_BYTES
+};
+
+// src/hooks/knowledge-events.ts
+var KNOWLEDGE_EVENT_SCHEMA_VERSION = 1;
+var MAX_EVENT_LOG_ENTRIES = 5000;
+var counterRollupCache = new Map;
+var MAX_COUNTER_ROLLUP_CACHE_DIRS = 32;
+var RECEIPT_EVENT_TYPES = new Set([
+  "acknowledged",
+  "applied",
+  "ignored",
+  "contradicted",
+  "violated",
+  "n_a",
+  "override",
+  "no_relevant"
+]);
+function resolveKnowledgeEventsPath(directory) {
+  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-events.jsonl");
+}
+function resolveKnowledgeCounterBaselinePath(directory) {
+  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-counter-baseline.json");
+}
+var resolveHiveEventsPath2 = resolveHiveEventsPath;
+function resolveLegacyApplicationLogPath(directory) {
+  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-application.jsonl");
+}
+function newTraceId() {
+  return randomUUID3();
+}
+function newEventId() {
+  return randomUUID3();
+}
+function withDefaults(event) {
+  return {
+    schema_version: KNOWLEDGE_EVENT_SCHEMA_VERSION,
+    ...event,
+    event_id: event.event_id || newEventId(),
+    timestamp: event.timestamp || new Date().toISOString()
+  };
+}
+async function appendKnowledgeEvent(directory, event) {
+  const [populated] = await appendKnowledgeEventsBatch(directory, [event]);
+  return populated;
+}
+async function appendKnowledgeEventsBatch(directory, events) {
+  if (events.length === 0)
+    return [];
+  const populated = events.map(withDefaults);
+  const filePath = resolveKnowledgeEventsPath(directory);
+  const dirPath = path2.dirname(filePath);
+  await mkdir2(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(dirPath, {
+      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 }
+    });
+    await appendFile(filePath, `${populated.map((e) => JSON.stringify(e)).join(`
+`)}
+`, "utf-8");
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const evicted = lines.slice(0, lines.length - MAX_EVENT_LOG_ENTRIES);
+        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
+        await foldEvictedEventsIntoBaseline(directory, evicted, filePath);
+        await atomicWriteFile(filePath, `${trimmed.join(`
+`)}
+`);
+      }
+    } catch (err) {
+      warn(`[knowledge-events] local cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
+  return populated;
+}
+async function recordKnowledgeEvent(directory, event) {
+  try {
+    return await appendKnowledgeEvent(directory, event);
+  } catch (err) {
+    warn(`[knowledge-events] recordKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function recordKnowledgeEventsBatch(directory, events) {
+  try {
+    return await appendKnowledgeEventsBatch(directory, events);
+  } catch (err) {
+    warn(`[knowledge-events] recordKnowledgeEventsBatch failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function appendHiveKnowledgeEvent(event) {
+  const populated = withDefaults(event);
+  const filePath = resolveHiveEventsPath2();
+  const dirPath = path2.dirname(filePath);
+  await mkdir2(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(dirPath, {
+      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 },
+      stale: 5000
+    });
+    await appendFile(filePath, `${JSON.stringify(populated)}
+`, "utf-8");
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
+        await atomicWriteFile(filePath, `${trimmed.join(`
+`)}
+`);
+      }
+    } catch (err) {
+      warn(`[knowledge-events] hive cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
+  return populated;
+}
+async function recordHiveKnowledgeEvent(event) {
+  try {
+    return await appendHiveKnowledgeEvent(event);
+  } catch (err) {
+    warn(`[knowledge-events] recordHiveKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function readKnowledgeEvents(directory, maxEvents) {
+  const filePath = resolveKnowledgeEventsPath(directory);
+  if (!existsSync3(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  const out = [];
+  const max = maxEvents !== undefined && maxEvents > 0 ? maxEvents : Infinity;
+  for (const line of content.split(`
+`)) {
+    if (out.length >= max)
+      break;
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+async function readHiveKnowledgeEvents() {
+  const filePath = resolveHiveEventsPath2();
+  if (!existsSync3(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  return parseEventLines(content.split(`
+`), filePath);
+}
+async function readLegacyApplicationRecords(directory) {
+  const filePath = resolveLegacyApplicationLogPath(directory);
+  if (!existsSync3(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  const out = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+var MAX_VIOLATION_TIMESTAMPS = 10;
+function emptyRollup() {
+  return {
+    shown_count: 0,
+    acknowledged_count: 0,
+    applied_explicit_count: 0,
+    ignored_count: 0,
+    violated_count: 0,
+    contradicted_count: 0,
+    n_a_count: 0,
+    succeeded_after_shown_count: 0,
+    failed_after_shown_count: 0,
+    partial_after_shown_count: 0,
+    violation_timestamps: []
+  };
+}
+function cloneRollup(input) {
+  return {
+    ...emptyRollup(),
+    ...input,
+    violation_timestamps: [...input.violation_timestamps ?? []]
+  };
+}
+function cloneRollupMap(input) {
+  const out = new Map;
+  for (const [id, rollup] of input) {
+    out.set(id, cloneRollup(rollup));
+  }
+  return out;
+}
+function normalizeRollupTimestamps(rollup) {
+  if (rollup.violation_timestamps.length > 1) {
+    rollup.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+  }
+  if (rollup.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
+    rollup.violation_timestamps = rollup.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
+  }
+  return rollup;
+}
+function mergeRollupInto(target, source) {
+  target.shown_count += source.shown_count ?? 0;
+  target.acknowledged_count += source.acknowledged_count ?? 0;
+  target.applied_explicit_count += source.applied_explicit_count ?? 0;
+  target.ignored_count += source.ignored_count ?? 0;
+  target.violated_count += source.violated_count ?? 0;
+  target.contradicted_count += source.contradicted_count ?? 0;
+  target.n_a_count += source.n_a_count ?? 0;
+  target.succeeded_after_shown_count += source.succeeded_after_shown_count ?? 0;
+  target.failed_after_shown_count += source.failed_after_shown_count ?? 0;
+  target.partial_after_shown_count += source.partial_after_shown_count ?? 0;
+  if (source.last_applied_at) {
+    target.last_applied_at = maxIso(target.last_applied_at, source.last_applied_at);
+  }
+  if (source.last_acknowledged_at) {
+    target.last_acknowledged_at = maxIso(target.last_acknowledged_at, source.last_acknowledged_at);
+  }
+  target.violation_timestamps.push(...source.violation_timestamps ?? []);
+  normalizeRollupTimestamps(target);
+}
+function get(map, id) {
+  let r = map.get(id);
+  if (!r) {
+    r = emptyRollup();
+    map.set(id, r);
+  }
+  return r;
+}
+function maxIso(current, candidate) {
+  if (!current)
+    return candidate;
+  return candidate > current ? candidate : current;
+}
+async function readCounterBaseline(directory) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  if (!existsSync3(filePath))
+    return new Map;
+  let raw;
+  try {
+    raw = JSON.parse(await readFile2(filePath, "utf-8"));
+  } catch (err) {
+    warn(`[knowledge-events] corrupted counter baseline at ${filePath}; ignoring folded baseline and replaying live events only: ${err instanceof Error ? err.message : String(err)}`);
+    return new Map;
+  }
+  const map = new Map;
+  for (const [id, rollup] of Object.entries(raw)) {
+    map.set(id, normalizeRollupTimestamps(cloneRollup(rollup)));
+  }
+  return map;
+}
+async function writeCounterBaseline(directory, baseline) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  const out = {};
+  for (const [id, rollup] of [...baseline.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    out[id] = normalizeRollupTimestamps(cloneRollup(rollup));
+  }
+  await atomicWriteFile(filePath, `${JSON.stringify(out, null, 2)}
+`);
+}
+async function statCacheKey(filePath) {
+  try {
+    const fileStat = await stat2(filePath);
+    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return "missing";
+    throw err;
+  }
+}
+async function buildCounterRollupCacheKey(directory) {
+  const [eventsKey, legacyKey, baselineKey] = await Promise.all([
+    statCacheKey(resolveKnowledgeEventsPath(directory)),
+    statCacheKey(resolveLegacyApplicationLogPath(directory)),
+    statCacheKey(resolveKnowledgeCounterBaselinePath(directory))
+  ]);
+  return `${eventsKey}|${legacyKey}|${baselineKey}`;
+}
+function setCounterRollupCache(directory, key, rollups) {
+  if (counterRollupCache.has(directory)) {
+    counterRollupCache.delete(directory);
+  }
+  counterRollupCache.set(directory, {
+    key,
+    rollups: cloneRollupMap(rollups)
+  });
+  while (counterRollupCache.size > MAX_COUNTER_ROLLUP_CACHE_DIRS) {
+    const oldestKey = counterRollupCache.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    counterRollupCache.delete(oldestKey);
+  }
+}
+function parseEventLines(lines, filePath) {
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+async function foldEvictedEventsIntoBaseline(directory, evictedLines, filePath) {
+  const evictedEvents = parseEventLines(evictedLines, filePath);
+  if (evictedEvents.length === 0)
+    return;
+  const baseline = await readCounterBaseline(directory);
+  for (const [id, rollup] of recomputeCounters(evictedEvents)) {
+    mergeRollupInto(get(baseline, id), rollup);
+  }
+  await writeCounterBaseline(directory, baseline);
+}
+function recomputeCounters(events, legacyRecords = [], baseline = new Map) {
+  const map = new Map;
+  const retrievedIds = new Set;
+  for (const [id, rollup] of baseline) {
+    map.set(id, cloneRollup(rollup));
+    if ((rollup.shown_count ?? 0) > 0)
+      retrievedIds.add(id);
+  }
+  for (const e of events) {
+    switch (e.type) {
+      case "retrieved": {
+        for (const id of e.result_ids) {
+          retrievedIds.add(id);
+          get(map, id).shown_count += 1;
+        }
+        break;
+      }
+      case "acknowledged": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map, e.knowledge_id);
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
+        break;
+      }
+      case "applied": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map, e.knowledge_id);
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
+        break;
+      }
+      case "ignored":
+        if (!e.knowledge_id)
+          break;
+        get(map, e.knowledge_id).ignored_count += 1;
+        break;
+      case "violated": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map, e.knowledge_id);
+        r.violated_count += 1;
+        r.violation_timestamps.push(e.timestamp);
+        break;
+      }
+      case "contradicted":
+        if (!e.knowledge_id)
+          break;
+        get(map, e.knowledge_id).contradicted_count += 1;
+        break;
+      case "n_a":
+        if (!e.knowledge_id)
+          break;
+        get(map, e.knowledge_id).n_a_count += 1;
+        break;
+      case "no_relevant":
+        break;
+      case "unacknowledged":
+        break;
+      case "outcome": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map, e.knowledge_id);
+        if (e.outcome === "success")
+          r.succeeded_after_shown_count += 1;
+        else if (e.outcome === "failure")
+          r.failed_after_shown_count += 1;
+        else if (e.outcome === "partial")
+          r.partial_after_shown_count += 1;
+        break;
+      }
+    }
+  }
+  for (const rec of legacyRecords) {
+    const r = get(map, rec.knowledgeId);
+    switch (rec.result) {
+      case "shown":
+        if (!retrievedIds.has(rec.knowledgeId))
+          r.shown_count += 1;
+        break;
+      case "acknowledged":
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
+        break;
+      case "applied":
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
+        break;
+      case "ignored":
+        r.ignored_count += 1;
+        break;
+      case "contradicted":
+        r.contradicted_count += 1;
+        break;
+      case "violated":
+        r.violated_count += 1;
+        r.violation_timestamps.push(rec.timestamp);
+        break;
+    }
+  }
+  for (const r of map.values()) {
+    normalizeRollupTimestamps(r);
+  }
+  return map;
+}
+function countViolationsInWindow(timestamps, windowDays, now = new Date) {
+  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+  let count = 0;
+  for (const ts of timestamps) {
+    const t = Date.parse(ts);
+    if (!Number.isNaN(t) && t >= cutoff)
+      count += 1;
+  }
+  return count;
+}
+function countEmptyTraceTerminals(events) {
+  let n = 0;
+  for (const e of events) {
+    if (e.type === "no_relevant")
+      n += 1;
+  }
+  return n;
+}
+async function countEntryViolationsInWindow(directory, entryId, windowDays, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const [events, legacyRecords] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory)
+    ]);
+    let count = 0;
+    for (const e of events) {
+      if (e.type !== "violated" || e.knowledge_id !== entryId)
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    for (const rec of legacyRecords) {
+      if (rec.result !== "violated" || rec.knowledgeId !== entryId)
+        continue;
+      const t = Date.parse(rec.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function countEntryContradictionsInWindow(directory, entryId, windowDays, now = new Date) {
+  try {
+    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const events = await readKnowledgeEvents(directory);
+    let count = 0;
+    for (const e of events) {
+      if (e.type !== "contradicted" || e.knowledge_id !== entryId)
+        continue;
+      const t = Date.parse(e.timestamp);
+      if (!Number.isNaN(t) && t >= cutoff)
+        count += 1;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function readKnowledgeCounterRollups(directory) {
+  try {
+    const cacheKey = await buildCounterRollupCacheKey(directory);
+    const cached = counterRollupCache.get(directory);
+    if (cached?.key === cacheKey) {
+      counterRollupCache.delete(directory);
+      counterRollupCache.set(directory, cached);
+      return cloneRollupMap(cached.rollups);
+    }
+    const [events, legacyRecords, baseline] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory),
+      readCounterBaseline(directory)
+    ]);
+    const rollups = recomputeCounters(events, legacyRecords, baseline);
+    setCounterRollupCache(directory, cacheKey, rollups);
+    return cloneRollupMap(rollups);
+  } catch (err) {
+    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
+    return new Map;
+  }
+}
+async function readAuthoritativeKnowledgeCounterRollups(directory) {
+  const history = await queryHistoricalOutcomes(directory);
+  if (!history.ok)
+    return new Map;
+  const rollups = new Map;
+  for (const membership of history.memberships) {
+    const rollup = get(rollups, membership.entry_id);
+    rollup.shown_count += 1;
+    if (membership.application_marker) {
+      rollup.acknowledged_count += 1;
+      rollup.last_acknowledged_at = maxIso(rollup.last_acknowledged_at, membership.application_marker.committed_at);
+    }
+    const compatible = membership;
+    const seen = new Set;
+    for (const terminal of [
+      ...compatible.terminal_history ?? [],
+      ...compatible.historical_terminals ?? [],
+      ...membership.terminal ? [membership.terminal] : []
+    ]) {
+      if (seen.has(terminal.event_id))
+        continue;
+      seen.add(terminal.event_id);
+      switch (terminal.outcome) {
+        case "applied":
+          rollup.applied_explicit_count += 1;
+          rollup.last_applied_at = maxIso(rollup.last_applied_at, terminal.committed_at);
+          break;
+        case "ignored":
+          rollup.ignored_count += 1;
+          break;
+        case "violated":
+          rollup.violated_count += 1;
+          rollup.violation_timestamps.push(terminal.committed_at);
+          break;
+        case "contradicted":
+          rollup.contradicted_count += 1;
+          break;
+        case "n_a":
+          rollup.n_a_count += 1;
+          break;
+      }
+    }
+    normalizeRollupTimestamps(rollup);
+  }
+  return rollups;
+}
+function effectiveRetrievalOutcomes(stored, rollup) {
+  const base = stored ?? {
+    applied_count: 0,
+    succeeded_after_count: 0,
+    failed_after_count: 0
+  };
+  if (!rollup)
+    return base;
+  const { n_a_count: _na, ...rollupWithoutNa } = rollup;
+  return {
+    ...base,
+    ...rollupWithoutNa,
+    succeeded_after_shown_count: (base.succeeded_after_shown_count ?? 0) + (rollup.succeeded_after_shown_count ?? 0),
+    failed_after_shown_count: (base.failed_after_shown_count ?? 0) + (rollup.failed_after_shown_count ?? 0)
+  };
+}
+var VERDICT_CONFIDENCE_BOOST = 0.03;
+var VERDICT_CONFIDENCE_DECAY = 0.05;
+async function applyKnowledgeVerdictFeedback(directory, options) {
+  try {
+    const history = await _internals4.queryHistoricalOutcomes(directory);
+    if (!history.ok)
+      return { processed: 0, bumps: 0 };
+    const seenEventIds = new Set;
+    const events = history.memberships.flatMap((membership) => {
+      const compatible = membership;
+      const terminals = [
+        ...compatible.terminal_history ?? [],
+        ...compatible.historical_terminals ?? [],
+        ...membership.terminal ? [membership.terminal] : []
+      ];
+      return terminals.flatMap((terminal) => {
+        if (terminal.outcome !== "applied" && terminal.outcome !== "violated" && terminal.outcome !== "ignored" || seenEventIds.has(terminal.event_id)) {
+          return [];
+        }
+        seenEventIds.add(terminal.event_id);
+        return [
+          {
+            type: terminal.outcome,
+            event_id: terminal.event_id,
+            knowledge_id: membership.entry_id,
+            timestamp: terminal.committed_at
+          }
+        ];
+      });
+    }).sort((a, b) => a.timestamp === b.timestamp ? a.event_id.localeCompare(b.event_id) : a.timestamp.localeCompare(b.timestamp));
+    const markerIndex = options?.sinceTimestamp && options.sinceEventId ? events.findIndex((e) => e.timestamp === options.sinceTimestamp && e.event_id === options.sinceEventId) : -1;
+    const actionable = events.filter((e, index) => {
+      if (options?.sinceTimestamp && e.timestamp < options.sinceTimestamp) {
+        return false;
+      }
+      if (options?.sinceTimestamp && e.timestamp === options.sinceTimestamp) {
+        if (!options.sinceEventId) {
+          return false;
+        }
+        if (markerIndex < 0) {
+          return false;
+        }
+        return index > markerIndex;
+      }
+      return true;
+    });
+    if (actionable.length === 0) {
+      return { processed: 0, bumps: 0 };
+    }
+    const groups = new Map;
+    let lastProcessedTimestamp;
+    let lastProcessedEventId;
+    for (const event of actionable) {
+      if (typeof event.timestamp === "string" && (!lastProcessedTimestamp || event.timestamp >= lastProcessedTimestamp)) {
+        lastProcessedTimestamp = event.timestamp;
+        lastProcessedEventId = event.event_id;
+      }
+      const kid = event.knowledge_id;
+      if (!kid)
+        continue;
+      const group = groups.get(kid) ?? [];
+      group.push(event);
+      groups.set(kid, group);
+    }
+    const deltas = [];
+    for (const [id, group] of groups) {
+      const positives = group.filter((event) => event.type === "applied").length;
+      const negatives = group.length - positives;
+      if (positives === 0 && negatives === 0)
+        continue;
+      const delta = positives > negatives ? VERDICT_CONFIDENCE_BOOST : -VERDICT_CONFIDENCE_DECAY;
+      deltas.push({
+        id,
+        delta,
+        receipt_events: group.map((event) => ({
+          event_id: event.event_id,
+          timestamp: event.timestamp,
+          outcome: event.type
+        }))
+      });
+    }
+    let bumps = 0;
+    if (deltas.length > 0) {
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-dpqgvvjt.js");
+      bumps = await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
+    }
+    return {
+      processed: groups.size,
+      bumps,
+      lastProcessedTimestamp,
+      lastProcessedEventId
+    };
+  } catch (err) {
+    warn(`[knowledge-events] applyKnowledgeVerdictFeedback failed (fail-open): ${err instanceof Error ? err.message : String(err)}`);
+    return { processed: 0, bumps: 0 };
+  }
+}
+var _internals4 = {
+  resolveKnowledgeEventsPath,
+  resolveKnowledgeCounterBaselinePath,
+  appendKnowledgeEvent,
+  recordKnowledgeEvent,
+  readKnowledgeEvents,
+  queryHistoricalOutcomes,
+  readCounterBaseline,
+  readLegacyApplicationRecords,
+  readKnowledgeCounterRollups,
+  readAuthoritativeKnowledgeCounterRollups,
+  effectiveRetrievalOutcomes,
+  recomputeCounters,
+  applyKnowledgeVerdictFeedback,
+  newTraceId,
+  newEventId,
+  resolveHiveEventsPath: resolveHiveEventsPath2,
+  appendHiveKnowledgeEvent,
+  recordHiveKnowledgeEvent,
+  readHiveKnowledgeEvents,
+  mergeRollupInto
+};
+
+export { queryHistoricalOutcomes, recordPhaseCloseIntent, reconcilePhaseClose, KNOWLEDGE_EVENT_SCHEMA_VERSION, MAX_EVENT_LOG_ENTRIES, RECEIPT_EVENT_TYPES, resolveKnowledgeEventsPath, resolveKnowledgeCounterBaselinePath, resolveHiveEventsPath2 as resolveHiveEventsPath, resolveLegacyApplicationLogPath, newTraceId, newEventId, appendKnowledgeEvent, appendKnowledgeEventsBatch, recordKnowledgeEvent, recordKnowledgeEventsBatch, appendHiveKnowledgeEvent, recordHiveKnowledgeEvent, readKnowledgeEvents, readHiveKnowledgeEvents, readLegacyApplicationRecords, MAX_VIOLATION_TIMESTAMPS, recomputeCounters, countViolationsInWindow, countEmptyTraceTerminals, countEntryViolationsInWindow, countEntryContradictionsInWindow, readKnowledgeCounterRollups, readAuthoritativeKnowledgeCounterRollups, effectiveRetrievalOutcomes, applyKnowledgeVerdictFeedback, _internals4 as _internals };