@remnic/core 9.65.6 → 9.65.8

package/dist/chunk-5ACCD4L7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/projection-support.ts","../src/storage/secure-line-reader.ts","../src/storage/memory-lifecycle-ledger-access.ts"],"sourcesContent":["/**\n * Projection maintenance support (issue #2119) — helpers shared by the\n * scheduled projection rebuild, the CLI rebuild, and the ledger rebuild.\n * Lives beside the rebuild ops so the at-ceiling store/rebuild modules stay\n * within their structural ratchets.\n */\n\nimport path from \"node:path\";\nimport {\n  openProjectionReadonly,\n  readProjectedEntityMentions,\n  readProjectedGovernanceRecord,\n  readProjectedNativeKnowledgeChunks,\n  type MemoryProjectionGovernanceAppliedActionRow,\n  type MemoryProjectionGovernanceReviewQueueRow,\n  type ProjectedEntityMentionRow,\n  type ProjectedNativeKnowledgeChunkRow,\n} from \"../memory-projection-store.js\";\nimport {\n  isFrontmatterDerivedLifecycleEventType,\n  memoryLifecycleEventProjectionIdentity,\n} from \"../memory-lifecycle-ledger-utils.js\";\nimport type { MemoryLifecycleEvent } from \"../types.js\";\nimport type { BetterSqlite3Database } from \"../runtime/better-sqlite.js\";\n\n/** Read the projection meta rebuiltAt timestamp; null when absent/unopenable. */\nexport function readProjectionRebuiltAt(memoryDir: string): string | null {\n  const db = openProjectionReadonly(memoryDir);\n  if (!db) return null;\n  try {\n    const row = db.prepare(\"SELECT value FROM meta WHERE key = 'rebuiltAt'\").get() as\n      | { value?: unknown }\n      | undefined;\n    return typeof row?.value === \"string\" && row.value.length > 0 ? row.value : null;\n  } catch {\n    return null;\n  } finally {\n    db.close();\n  }\n}\n\n/** Format projection age description string for fallback warning telemetry. */\nexport function formatProjectionAge(rebuiltAt: string | null): string {\n  if (!rebuiltAt) return \"projection never rebuilt\";\n  const ageMs = Date.now() - Date.parse(rebuiltAt);\n  if (!Number.isFinite(ageMs)) return `projection rebuiltAt=${rebuiltAt}`;\n  const ageMin = Math.max(0, Math.round(ageMs / 60_000));\n  const age = ageMin >= 120 ? `${Math.round(ageMin / 60)}h` : `${ageMin}m`;\n  return `projection ${age} stale, last rebuilt ${rebuiltAt}`;\n}\n\nexport interface ProjectionLifecycleLedgerHighWater {\n  eventCount: number;\n  sourceEventCount: number;\n}\n\nfunction readProjectionHighWaterFromDb(\n  db: BetterSqlite3Database,\n): ProjectionLifecycleLedgerHighWater | null {\n  const sourceRow = db.prepare(\n    \"SELECT value FROM meta WHERE key = 'sourceLifecycleLedgerEventCount'\",\n  ).get() as { value?: unknown } | undefined;\n  const projectedRow = db.prepare(\n    \"SELECT value FROM meta WHERE key = 'projectedLifecycleLedgerEventCount'\",\n  ).get() as { value?: unknown } | undefined;\n  if (\n    typeof sourceRow?.value !== \"string\"\n    || !/^\\d+$/.test(sourceRow.value)\n    || typeof projectedRow?.value !== \"string\"\n    || !/^\\d+$/.test(projectedRow.value)\n  ) return null;\n  const sourceEventCount = Number(sourceRow.value);\n  const eventCount = Number(projectedRow.value);\n  if (!Number.isSafeInteger(sourceEventCount) || !Number.isSafeInteger(eventCount)) return null;\n  return { eventCount, sourceEventCount };\n}\n\nexport function readProjectionLifecycleLedgerHighWater(\n  memoryDir: string,\n): ProjectionLifecycleLedgerHighWater | null {\n  const db = openProjectionReadonly(memoryDir);\n  if (!db) return null;\n  try {\n    return readProjectionHighWaterFromDb(db);\n  } catch {\n    return null;\n  } finally {\n    db.close();\n  }\n}\n\nexport interface ProjectionLifecycleLedgerLagTracker {\n  highWater: ProjectionLifecycleLedgerHighWater;\n  record(event: MemoryLifecycleEvent): { unique: boolean; projected: boolean };\n  close(): void;\n}\n\nexport function openProjectionLifecycleLedgerLagTracker(\n  memoryDir: string,\n): ProjectionLifecycleLedgerLagTracker | null {\n  const db = openProjectionReadonly(memoryDir);\n  if (!db) return null;\n  try {\n    const highWater = readProjectionHighWaterFromDb(db);\n    if (!highWater) {\n      db.close();\n      return null;\n    }\n    db.pragma(\"temp_store = FILE\");\n    db.exec(`\n      CREATE TEMP TABLE projection_lag_current_identity (\n        identity TEXT PRIMARY KEY\n      ) WITHOUT ROWID;\n    `);\n    db.pragma(\"temp.cache_size = -1024\");\n    const insertCurrent = db.prepare(\n      \"INSERT OR IGNORE INTO projection_lag_current_identity(identity) VALUES (?)\",\n    );\n    const findProjectedEvent = db.prepare(\n      \"SELECT 1 FROM memory_timeline WHERE event_id = ? LIMIT 1\",\n    );\n    const findProjectedFrontmatterEvent = db.prepare(`\n      SELECT 1\n      FROM memory_timeline\n      WHERE memory_id = ? AND event_type = ? AND timestamp = ?\n      LIMIT 1\n    `);\n    return {\n      highWater,\n      record(event) {\n        if (!event.memoryId.trim()) return { unique: false, projected: false };\n        const identity = memoryLifecycleEventProjectionIdentity(event);\n        const inserted = insertCurrent.run(identity);\n        if (inserted.changes === 0) return { unique: false, projected: false };\n        const projected = isFrontmatterDerivedLifecycleEventType(event.eventType)\n          ? findProjectedFrontmatterEvent.get(event.memoryId, event.eventType, event.timestamp)\n          : findProjectedEvent.get(event.eventId);\n        return { unique: true, projected: projected !== undefined };\n      },\n      close: () => db.close(),\n    };\n  } catch {\n    db.close();\n    return null;\n  }\n}\n/** Write the high-water ledger marker counts to projection meta store. */\nexport function writeProjectionMetaHighWater(\n  insertMeta: { run: (key: string, value: string) => void },\n  sourceLifecycleLedgerEventCount: number,\n  timelineRows: MemoryLifecycleEvent[],\n): void {\n  insertMeta.run(\"sourceLifecycleLedgerEventCount\", String(sourceLifecycleLedgerEventCount));\n  insertMeta.run(\n    \"projectedLifecycleLedgerEventCount\",\n    String(new Set(timelineRows.map(memoryLifecycleEventProjectionIdentity)).size),\n  );\n}\n\nexport function readProjectedEntityMentionRows(\n  memoryDir: string,\n): { projectionExists: boolean; rows: ProjectedEntityMentionRow[] } {\n  const rows = readProjectedEntityMentions(memoryDir);\n  if (rows === null) return { projectionExists: false, rows: [] };\n  return { projectionExists: true, rows };\n}\n\nexport function readProjectedNativeKnowledgeRows(\n  memoryDir: string,\n): { projectionExists: boolean; rows: ProjectedNativeKnowledgeChunkRow[] } {\n  const rows = readProjectedNativeKnowledgeChunks(memoryDir);\n  if (rows === null) return { projectionExists: false, rows: [] };\n  return { projectionExists: true, rows };\n}\n\nexport function readProjectedGovernanceRows(memoryDir: string): {\n  projectionExists: boolean;\n  runId: string | null;\n  summary: unknown;\n  metrics: unknown;\n  reviewQueueRows: MemoryProjectionGovernanceReviewQueueRow[];\n  appliedActionRows: MemoryProjectionGovernanceAppliedActionRow[];\n  report: string;\n} {\n  const record = readProjectedGovernanceRecord(memoryDir);\n  if (record === null) {\n    return {\n      projectionExists: false,\n      runId: null,\n      summary: undefined,\n      metrics: undefined,\n      reviewQueueRows: [],\n      appliedActionRows: [],\n      report: \"\",\n    };\n  }\n  return {\n    projectionExists: true,\n    runId: record.runId,\n    summary: record.summary,\n    metrics: record.metrics,\n    reviewQueueRows: record.reviewQueueRows,\n    appliedActionRows: record.appliedActionRows,\n    report: record.report,\n  };\n}\n\n/**\n * Assert an optionally injected storage (e.g. the daemon's live unlocked\n * secure-store instance) is rooted at `memoryDir`, and hand it back. Shared\n * by the projection and lifecycle-ledger rebuilds so the containment guard\n * cannot drift between them; callers construct their own StorageManager when\n * nothing was injected (keeps this module off the direct-storage-import\n * ratchet, issue #1533).\n */\nexport function assertInjectedStorageRooted<T extends { dir: string }>(\n  label: string,\n  memoryDir: string,\n  injected: T | undefined,\n): T | undefined {\n  if (injected && path.resolve(injected.dir) !== path.resolve(memoryDir)) {\n    throw new Error(\n      `${label}: storage.dir (${injected.dir}) must match memoryDir (${memoryDir})`,\n    );\n  }\n  return injected;\n}\n\nexport interface SkippedDuplicateMemory {\n  memoryId: string;\n  keptPath: string;\n  skippedPath: string;\n}\n\nexport interface SkippedBlankIdMemory {\n  path: string;\n}\nexport interface SkippedDuplicateTimelineEvent {\n  eventId: string;\n  keptPath: string;\n  skippedPath: string;\n}\n\nexport interface SkippedBlankIdTimelineEvent {\n  eventId: string;\n  path: string;\n}\n","import { createReadStream } from \"node:fs\";\nimport { lstat, open } from \"node:fs/promises\";\nimport { createInterface } from \"node:readline\";\n\nimport { isEncryptedFile, MAGIC_HEADER_SIZE } from \"../secure-store/secure-fs.js\";\nimport type { ContextTransformTelemetryRecord } from \"../active-context-transform.js\";\nimport type { MemoryActionEvent, MemoryLifecycleEvent } from \"../types.js\";\n\n/**\n * Whole-file decrypt ceiling for encrypted state files. V8's max string length\n * is ~512MB; a decrypted body that approaches it throws an opaque\n * `Invalid string length` on every read (the 691MB lifecycle-ledger incident).\n * We refuse at a size comfortably under the cap and point the operator at the\n * compaction remedy instead of letting the runtime crash. Plaintext streaming\n * is unaffected at any size.\n */\nexport const STATE_FILE_MAX_DECRYPT_BYTES = 400 * 1024 * 1024;\n\n/**\n * Stream plaintext files by line while preserving authenticated whole-file\n * reads for encrypted files. `maxDecryptBytes` bounds the whole-file decrypt:\n * when set, an encrypted file at/over it is refused before decryption with an\n * actionable error. The ceiling is OPT-IN so it applies ONLY to callers with a\n * compaction-backed remedy (the lifecycle ledger). Callers with no bounded\n * maintenance path — e.g. the memory-actions ledger — omit it and keep the\n * prior unbounded read (issue #1910).\n */\nexport async function* readMaybeEncryptedLines(\n  filePath: string,\n  readEncryptedFile: () => Promise<string>,\n  maxDecryptBytes?: number,\n): AsyncGenerator<string> {\n  // Reject a symlink/FIFO/device BEFORE opening, matching the maintenance ledger\n  // probe (probeEncryptedRegularFileHeader, #2033): opening a FIFO blocks until a\n  // writer appears and a symlink would redirect the read outside our tree. An\n  // ENOENT from the missing regular file propagates so callers keep their\n  // absent-file → [] behavior (they catch ENOENT), exactly as a missing open did.\n  const entryStat = await lstat(filePath);\n  if (!entryStat.isFile()) {\n    throw new Error(\n      `refusing to read non-regular state file ${filePath} `\n      + `(symlink/FIFO/device); opening it could block or escape containment (#2033)`,\n    );\n  }\n  const file = await open(filePath, \"r\");\n  const header = Buffer.alloc(MAGIC_HEADER_SIZE);\n  try {\n    const { bytesRead } = await file.read(header, 0, header.length, 0);\n    if (isEncryptedFile(header.subarray(0, bytesRead))) {\n      if (maxDecryptBytes !== undefined) {\n        const { size } = await file.stat();\n        if (size >= maxDecryptBytes) {\n          throw new Error(\n            `encrypted state file ${filePath} is ${size} bytes, at or over the ${maxDecryptBytes}-byte `\n            + `whole-file decrypt limit. Run 'remnic rebuild-memory-lifecycle-ledger --write' (add `\n            + `'--namespace <ns>' when the path is under namespaces/<ns>/state) or 'remnic doctor' to compact it.`,\n          );\n        }\n      }\n      yield* (await readEncryptedFile()).split(\"\\n\");\n      return;\n    }\n\n    const input = createReadStream(filePath, {\n      autoClose: false,\n      encoding: \"utf8\",\n      fd: file.fd,\n      start: 0,\n    });\n    const lines = createInterface({ input, crlfDelay: Infinity });\n    try {\n      for await (const line of lines) yield line;\n    } finally {\n      lines.close();\n    }\n  } finally {\n    await file.close();\n  }\n}\n\nexport async function readMemoryActionEventRowsFromLines(\n  lines: AsyncIterable<string>,\n  limit: number,\n): Promise<Array<{ line: number; event: MemoryActionEvent }>> {\n  const out: Array<{ line: number; event: MemoryActionEvent }> = [];\n  let writeIndex = 0;\n  let lineNumber = 0;\n  for await (const row of lines) {\n    lineNumber += 1;\n    const line = row.trim();\n    if (!line) continue;\n    try {\n      const parsed = JSON.parse(line) as Partial<MemoryActionEvent> & { recordKind?: unknown };\n      // Ledger discriminated union (#2347): any row carrying a `recordKind`\n      // belongs to another record family (e.g. context_transform) and must\n      // be ignored here — the legacy parser stays strict for its own kind.\n      if (parsed.recordKind !== undefined) continue;\n      const outcome = parsed.outcome === \"applied\" || parsed.outcome === \"skipped\" || parsed.outcome === \"failed\"\n        ? parsed.outcome\n        : null;\n      if (\n        typeof parsed.timestamp === \"string\" &&\n        typeof parsed.action === \"string\" &&\n        outcome !== null\n      ) {\n        const entry = {\n          line: lineNumber,\n          event: { ...parsed, outcome } as MemoryActionEvent,\n        };\n        if (out.length < limit) {\n          out.push(entry);\n        } else {\n          out[writeIndex] = entry;\n          writeIndex = (writeIndex + 1) % limit;\n        }\n      }\n    } catch {\n      // Ignore malformed rows (fail-open).\n    }\n  }\n  return writeIndex === 0 ? out : [...out.slice(writeIndex), ...out.slice(0, writeIndex)];\n}\n\n/**\n * Tail read for context-transform telemetry rows (#2347). Selects ONLY\n * records discriminated by `recordKind: \"context_transform\"` — the sibling\n * of `readMemoryActionEventRowsFromLines`, with the same O(limit) ring\n * buffer and line-number semantics. Malformed rows are skipped fail-open;\n * legacy action rows are never returned here.\n */\nexport async function readContextTransformRecordRowsFromLines(\n  lines: AsyncIterable<string>,\n  limit: number,\n): Promise<Array<{ line: number; record: ContextTransformTelemetryRecord }>> {\n  const out: Array<{ line: number; record: ContextTransformTelemetryRecord }> = [];\n  let writeIndex = 0;\n  let lineNumber = 0;\n  for await (const row of lines) {\n    lineNumber += 1;\n    const line = row.trim();\n    if (!line) continue;\n    try {\n      const parsed = JSON.parse(line) as Partial<ContextTransformTelemetryRecord>;\n      if (\n        parsed.recordKind === \"context_transform\" &&\n        typeof parsed.timestamp === \"string\" &&\n        typeof parsed.actionId === \"string\" &&\n        typeof parsed.planHash === \"string\"\n      ) {\n        const entry = {\n          line: lineNumber,\n          record: parsed as ContextTransformTelemetryRecord,\n        };\n        if (out.length < limit) {\n          out.push(entry);\n        } else {\n          out[writeIndex] = entry;\n          writeIndex = (writeIndex + 1) % limit;\n        }\n      }\n    } catch {\n      // Ignore malformed rows (fail-open).\n    }\n  }\n  return writeIndex === 0 ? out : [...out.slice(writeIndex), ...out.slice(0, writeIndex)];\n}\n\n/**\n * Validate that a parsed row carries every required lifecycle-event field.\n * Shared by the tail reader and the per-memory reader so both apply the EXACT\n * same fail-open guard as `readAllLifecycleEventsFromLedger` (`eventType` is any\n * string). Governance reads via `readMemoryLifecycleEvents(MAX_SAFE_INTEGER)`\n * must be byte-for-byte identical to `readAllMemoryLifecycleEvents`, so this\n * MUST NOT restrict `eventType` to a handled allow-list — an unknown type is\n * still admitted here and sorted deterministically by `lifecycleEventSortRank`\n * (issue #1910).\n */\nfunction isValidLifecycleEventRow(\n  parsed: Partial<MemoryLifecycleEvent>,\n): parsed is MemoryLifecycleEvent {\n  return (\n    typeof parsed.eventId === \"string\" &&\n    typeof parsed.memoryId === \"string\" &&\n    typeof parsed.eventType === \"string\" &&\n    typeof parsed.timestamp === \"string\" &&\n    typeof parsed.actor === \"string\" &&\n    typeof parsed.ruleVersion === \"string\"\n  );\n}\n\n/**\n * Bounded min-heap that retains the `limit` rows that rank highest under\n * `compare`, breaking ties by append order (later rows win). Heap use is\n * O(limit); each row costs O(log limit). Used for the per-memory timeline\n * fallback, which must keep the last `limit` events in canonical\n * timestamp/event order — not merely the last `limit` appended rows.\n */\nclass BoundedLifecycleTopN {\n  private readonly heap: Array<{ event: MemoryLifecycleEvent; seq: number }> = [];\n\n  constructor(\n    private readonly limit: number,\n    private readonly compare: (a: MemoryLifecycleEvent, b: MemoryLifecycleEvent) => number,\n  ) {}\n\n  private less(\n    a: { event: MemoryLifecycleEvent; seq: number },\n    b: { event: MemoryLifecycleEvent; seq: number },\n  ): boolean {\n    const c = this.compare(a.event, b.event);\n    return c !== 0 ? c < 0 : a.seq < b.seq;\n  }\n\n  add(event: MemoryLifecycleEvent, seq: number): void {\n    const item = { event, seq };\n    if (this.heap.length < this.limit) {\n      this.heap.push(item);\n      this.siftUp(this.heap.length - 1);\n    } else if (this.heap.length > 0 && this.less(this.heap[0], item)) {\n      this.heap[0] = item;\n      this.siftDown(0);\n    }\n  }\n\n  /** Kept rows in ascending canonical order (append order breaks ties). */\n  drainSorted(): MemoryLifecycleEvent[] {\n    return this.heap\n      .slice()\n      .sort((a, b) => (this.less(a, b) ? -1 : this.less(b, a) ? 1 : 0))\n      .map((item) => item.event);\n  }\n\n  private siftUp(index: number): void {\n    let i = index;\n    while (i > 0) {\n      const parent = (i - 1) >> 1;\n      if (!this.less(this.heap[i], this.heap[parent])) break;\n      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];\n      i = parent;\n    }\n  }\n\n  private siftDown(index: number): void {\n    let i = index;\n    const n = this.heap.length;\n    for (;;) {\n      const left = 2 * i + 1;\n      const right = 2 * i + 2;\n      let smallest = i;\n      if (left < n && this.less(this.heap[left], this.heap[smallest])) smallest = left;\n      if (right < n && this.less(this.heap[right], this.heap[smallest])) smallest = right;\n      if (smallest === i) break;\n      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];\n      i = smallest;\n    }\n  }\n}\n\n/**\n * Bounded tail read for lifecycle-event rows, mirroring\n * `readMemoryActionEventRowsFromLines`: heap use is O(limit) rather than\n * O(rows), no matter how large the ledger is. When `memoryId` is supplied,\n * only rows for that memory are considered, so the per-memory timeline\n * fallback never materializes the whole ledger either.\n *\n * Without `compare`, the retained rows are the last `limit` *appended* rows\n * (returned oldest→newest of that tail); callers apply\n * `sortMemoryLifecycleEvents` for canonical ordering. With `compare`, the\n * retained rows are the `limit` rows that rank highest under `compare` (ties\n * broken by append order), returned in ascending `compare` order — preserving\n * the prior \"filter → canonical sort → last N\" semantics without loading the\n * whole file.\n */\nexport async function readMemoryLifecycleEventsFromLines(\n  lines: AsyncIterable<string>,\n  limit: number,\n  memoryId?: string,\n  compare?: (a: MemoryLifecycleEvent, b: MemoryLifecycleEvent) => number,\n  onEvent?: (event: MemoryLifecycleEvent) => void,\n): Promise<MemoryLifecycleEvent[]> {\n  if (limit <= 0) return [];\n  const top = compare ? new BoundedLifecycleTopN(limit, compare) : null;\n  const ring: MemoryLifecycleEvent[] = [];\n  let writeIndex = 0;\n  let seq = 0;\n  for await (const row of lines) {\n    const line = row.trim();\n    if (!line) continue;\n    try {\n      const parsed = JSON.parse(line) as Partial<MemoryLifecycleEvent>;\n      if (!isValidLifecycleEventRow(parsed)) continue;\n      onEvent?.(parsed);\n      if (memoryId !== undefined && parsed.memoryId !== memoryId) continue;\n      if (top) {\n        top.add(parsed, seq++);\n      } else if (ring.length < limit) {\n        ring.push(parsed);\n      } else {\n        ring[writeIndex] = parsed;\n        writeIndex = (writeIndex + 1) % limit;\n      }\n    } catch {\n      // Ignore malformed rows (fail-open).\n    }\n  }\n  if (top) return top.drainSorted();\n  return writeIndex === 0 ? ring : [...ring.slice(writeIndex), ...ring.slice(0, writeIndex)];\n}\n","import { SecureStoreLockedError } from \"../secure-store/secure-fs.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\nimport { displayErrorDetail } from \"../runtime/better-sqlite.js\";\nimport { lstat, rename, stat, unlink } from \"node:fs/promises\";\nimport { randomUUID } from \"node:crypto\";\nimport path from \"node:path\";\nimport type { MemoryLifecycleEvent } from \"../types.js\";\nimport {\n  compareMemoryLifecycleEvents,\n  sortMemoryLifecycleEvents,\n  memoryLifecycleLedgerLockPath,\n  MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,\n  MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS,\n} from \"../memory-lifecycle-ledger-utils.js\";\nimport { withHeldFileLock, type HeldFileLockOptions } from \"../utils/serialize-mutations.js\";\nimport { ensureContainedSpillDir, listContainedSpillFiles } from \"../utils/path-containment.js\";\nimport {\n  readMaybeEncryptedLines,\n  readMemoryLifecycleEventsFromLines,\n  STATE_FILE_MAX_DECRYPT_BYTES,\n} from \"./secure-line-reader.js\";\nimport { getMemoryProjectionPath } from \"../memory-projection-store.js\";\nimport {\n  openProjectionLifecycleLedgerLagTracker,\n  type ProjectionLifecycleLedgerLagTracker,\n} from \"../maintenance/projection-support.js\";\nimport {\n  type ProjectionLedgerLagTelemetry,\n  warnProjectionFallback,\n} from \"../storage-guards.js\";\n\n/** Reads a lifecycle-ledger file through the secure whole-file/plaintext line source. */\nexport type LedgerSecureReader = (filePath: string) => Promise<string>;\n\n/**\n * Lifecycle-ledger read access, extracted from storage.ts (issues #1910,\n * #1995) so the god-file line-count ratchet does not grow. Behavior is\n * unchanged: both readers stream `state/memory-lifecycle-ledger.jsonl` through\n * the same secure whole-file-or-plaintext line source, are fail-open on\n * malformed rows, return `[]` on an absent ledger (ENOENT), and rethrow when a\n * required secure store is locked.\n */\n\n/** Reads a lifecycle-ledger file as a raw (possibly still-encrypted-on-disk)\n *  buffer, decrypting through the live secure key when present. */\nexport type LedgerSecureBufferReader = (filePath: string) => Promise<Buffer>;\n\n/**\n * Parse + canonically sort lifecycle rows from a line source. Permissive\n * validation (any `eventType` string is admitted) — matches the historical\n * `readAllMemoryLifecycleEvents` contract that projection rebuild depends on.\n * Fail-open on malformed rows.\n */\nasync function collectLifecycleEvents(\n  lines: AsyncIterable<string>,\n): Promise<MemoryLifecycleEvent[]> {\n  const out: MemoryLifecycleEvent[] = [];\n  for await (const line of lines) {\n    const row = line.trim();\n    if (!row) continue;\n    try {\n      const parsed = JSON.parse(row) as Partial<MemoryLifecycleEvent>;\n      if (\n        typeof parsed.eventId === \"string\" &&\n        typeof parsed.memoryId === \"string\" &&\n        typeof parsed.eventType === \"string\" &&\n        typeof parsed.timestamp === \"string\" &&\n        typeof parsed.actor === \"string\" &&\n        typeof parsed.ruleVersion === \"string\"\n      ) {\n        out.push(parsed as MemoryLifecycleEvent);\n      }\n    } catch {\n      // Ignore malformed rows (fail-open).\n    }\n  }\n  return sortMemoryLifecycleEvents(out);\n}\n\n/**\n * Max bytes of a single ledger row we will decode to a V8 string. A malformed\n * or truncated row with no newline can span most of an oversized buffer;\n * decoding it whole with `buf.toString` could exceed V8's ~512MB string cap and\n * THROW before the fail-open JSON.parse in {@link collectLifecycleEvents} can\n * skip it, aborting a compaction that could otherwise rewrite the ledger from\n * its remaining good rows (#2033). Comfortably above any real fixed-schema\n * lifecycle row, far below the string cap, so a legitimate row is never dropped.\n */\nconst LEDGER_ROW_MAX_DECODE_BYTES = 64 * 1024 * 1024;\n\n/**\n * Yield ledger lines from a whole-file buffer WITHOUT ever materializing the\n * entire decrypted body as one V8 string. A decrypted Buffer can hold ~4GB\n * where a string tops out near 512MB, so this is the read compaction uses to\n * shrink an oversize encrypted ledger — the exact file the string-capped\n * `readMaybeEncryptedLines` path refuses (issue #1910, #2033 Cursor High).\n * `Buffer.indexOf` scans for the 0x0A newline natively. A single oversized row\n * with no newline (a truncated write or garbled decrypt output) is SKIPPED\n * undecoded rather than passed to `toString`, so it can never exceed the string\n * cap and abort the read; the fail-open reader drops it anyway (#2033).\n */\nasync function* linesFromBuffer(\n  readBuffer: () => Promise<Buffer>,\n): AsyncGenerator<string> {\n  const buf = await readBuffer();\n  let start = 0;\n  let nl = buf.indexOf(0x0a, start);\n  while (nl !== -1) {\n    if (nl - start <= LEDGER_ROW_MAX_DECODE_BYTES) yield buf.toString(\"utf8\", start, nl);\n    start = nl + 1;\n    nl = buf.indexOf(0x0a, start);\n  }\n  if (start < buf.length && buf.length - start <= LEDGER_ROW_MAX_DECODE_BYTES) {\n    yield buf.toString(\"utf8\", start, buf.length);\n  }\n}\n\n/**\n * Every valid ledger row in canonical order, read through the string-capped\n * secure line source (refuses an encrypted body over the whole-file decrypt\n * limit). General readers use this; compaction uses the uncapped buffer variant.\n */\nexport async function readAllLifecycleEventsFromLedger(\n  ledgerPath: string,\n  readSecureFile: LedgerSecureReader,\n): Promise<MemoryLifecycleEvent[]> {\n  try {\n    return await collectLifecycleEvents(\n      readMaybeEncryptedLines(\n        ledgerPath,\n        () => readSecureFile(ledgerPath),\n        STATE_FILE_MAX_DECRYPT_BYTES,\n      ),\n    );\n  } catch (err) {\n    if (err instanceof SecureStoreLockedError) throw err;\n    if (!isErrnoCode(err, \"ENOENT\")) throw err;\n    return [];\n  }\n}\n\n/**\n * Compaction-only variant of {@link readAllLifecycleEventsFromLedger} that reads\n * the ledger through a decrypted BUFFER instead of the string-capped whole-file\n * path. This is what lets background compaction shrink an oversize encrypted\n * ledger: the string cap (`STATE_FILE_MAX_DECRYPT_BYTES`) that points general\n * readers at the compaction remedy would otherwise also block the remedy itself\n * (issue #1910, #2033 Cursor High). Same permissive validation, canonical sort,\n * fail-open-on-malformed, and ENOENT→[] / locked-store-rethrow contract.\n */\nexport async function readAllLifecycleEventsFromLedgerBuffer(\n  ledgerPath: string,\n  readSecureBuffer: LedgerSecureBufferReader,\n): Promise<MemoryLifecycleEvent[]> {\n  try {\n    return await collectLifecycleEvents(linesFromBuffer(() => readSecureBuffer(ledgerPath)));\n  } catch (err) {\n    if (err instanceof SecureStoreLockedError) throw err;\n    if (!isErrnoCode(err, \"ENOENT\")) throw err;\n    return [];\n  }\n}\n\n/**\n * Bounded tail read: retains at most `limit` rows via a streaming min-heap so\n * the whole ledger is never materialized. Rows are always ranked by the\n * canonical comparator, so the result is the last `limit` events in canonical\n * (memoryId, timestamp, eventType) order — byte-for-byte the prior `readAll →\n * sort → slice(-limit)`, whether or not `memoryId` is supplied. Governance\n * passes `MAX_SAFE_INTEGER`, so the heap keeps every row and equals\n * `readAllMemoryLifecycleEvents` (issue #1910; CodeRabbit: keep the no-memoryId\n * read on the canonical tail). With `memoryId` only that memory's rows are\n * considered, so the per-memory timeline fallback never materializes the whole\n * ledger either.\n */\nexport async function readBoundedLifecycleEventsFromLedger(\n  ledgerPath: string,\n  readSecureFile: LedgerSecureReader,\n  limit: number,\n  memoryId?: string,\n): Promise<MemoryLifecycleEvent[]> {\n  const cappedLimit = Math.max(0, Math.floor(limit));\n  if (cappedLimit === 0 || Number.isNaN(cappedLimit)) return [];\n  try {\n    return await readMemoryLifecycleEventsFromLines(\n      readMaybeEncryptedLines(\n        ledgerPath,\n        () => readSecureFile(ledgerPath),\n        STATE_FILE_MAX_DECRYPT_BYTES,\n      ),\n      cappedLimit,\n      memoryId,\n      compareMemoryLifecycleEvents,\n    );\n  } catch (err) {\n    if (err instanceof SecureStoreLockedError) throw err;\n    if (!isErrnoCode(err, \"ENOENT\")) throw err;\n    return [];\n  }\n}\n\nexport interface LifecycleLedgerProjectionLagRead {\n  events: MemoryLifecycleEvent[];\n  currentEventCount: number;\n  deltaEvents: number;\n  telemetryAvailable: boolean;\n}\n\nexport async function readBoundedLifecycleEventsWithProjectionLag(\n  ledgerPath: string,\n  readSecureFile: LedgerSecureReader,\n  limit: number,\n  memoryId: string,\n  tracker: ProjectionLifecycleLedgerLagTracker,\n): Promise<LifecycleLedgerProjectionLagRead> {\n  let currentEventCount = 0;\n  let deltaEvents = 0;\n  let telemetryAvailable = true;\n  try {\n    const events = await readMemoryLifecycleEventsFromLines(\n      readMaybeEncryptedLines(\n        ledgerPath,\n        () => readSecureFile(ledgerPath),\n        STATE_FILE_MAX_DECRYPT_BYTES,\n      ),\n      Math.max(0, Math.floor(limit)),\n      memoryId,\n      compareMemoryLifecycleEvents,\n      (event) => {\n        if (!telemetryAvailable) return;\n        try {\n          const tracked = tracker.record(event);\n          if (!tracked.unique) return;\n          currentEventCount += 1;\n          if (!tracked.projected) deltaEvents += 1;\n        } catch {\n          telemetryAvailable = false;\n          currentEventCount = 0;\n          deltaEvents = 0;\n        }\n      },\n    );\n    return { events, currentEventCount, deltaEvents, telemetryAvailable };\n  } catch (err) {\n    if (err instanceof SecureStoreLockedError) throw err;\n    if (!isErrnoCode(err, \"ENOENT\")) throw err;\n    return { events: [], currentEventCount: 0, deltaEvents: 0, telemetryAvailable: false };\n  }\n}\n/**\n * Probe filesystem identity stamps (dev:ino:size:mtimeMs:ctimeMs) for the\n * projection database and lifecycle-ledger file. Returns `null` when either\n * file is missing or unstatable so caller can disable the lag cache without\n * throwing on transient I/O or permission errors (#2119 / review).\n */\nexport async function probeProjectionLedgerIdentities(\n  projectionPath: string,\n  ledgerPath: string,\n): Promise<{ projectionIdentity: string; ledgerIdentity: string } | null> {\n  try {\n    const [projectionIdentity, ledgerIdentity] = await Promise.all(\n      [projectionPath, ledgerPath].map(async (filePath) => {\n        try {\n          const file = await lstat(filePath);\n          return `${file.dev}:${file.ino}:${file.size}:${file.mtimeMs}:${file.ctimeMs}`;\n        } catch (err) {\n          if (isErrnoCode(err, \"ENOENT\")) return \"absent\";\n          // Probe failure: disable lag cache, do not block the primary timeline read (#2119 review).\n          return null;\n        }\n      }),\n    );\n    if (!projectionIdentity || !ledgerIdentity) return null;\n    return { projectionIdentity, ledgerIdentity };\n  } catch {\n    return null;\n  }\n}\n\nexport interface ProjectionLedgerLagScan {\n  telemetry: ProjectionLedgerLagTelemetry | null;\n  events: MemoryLifecycleEvent[];\n  memoryId: string;\n  limit: number;\n}\n\nexport class ProjectionLedgerLagManager {\n  private lagCache: {\n    generation: string;\n    telemetry: ProjectionLedgerLagTelemetry;\n  } | null = null;\n  private lagInFlight: {\n    generation: string;\n    scan: Promise<ProjectionLedgerLagScan>;\n  } | null = null;\n\n  async resolveTimelineWithLag(options: {\n    baseDir: string;\n    ledgerPath: string;\n    memoryId: string;\n    cappedLimit: number;\n    readSecureFile: LedgerSecureReader;\n    projectionAge: () => string;\n  }): Promise<MemoryLifecycleEvent[]> {\n    const { baseDir, ledgerPath, memoryId, cappedLimit, readSecureFile, projectionAge } = options;\n    const projectionPath = getMemoryProjectionPath(baseDir);\n    const identities = await probeProjectionLedgerIdentities(projectionPath, ledgerPath);\n\n    if (!identities) {\n      warnProjectionFallback(baseDir, \"getMemoryTimeline\", projectionAge);\n      return readBoundedLifecycleEventsFromLedger(ledgerPath, readSecureFile, cappedLimit, memoryId);\n    }\n\n    const { projectionIdentity, ledgerIdentity } = identities;\n    const generation = `${projectionIdentity}\\0${ledgerIdentity}`;\n\n    const cachedLag = this.lagCache?.generation === generation\n      ? this.lagCache.telemetry\n      : null;\n    if (cachedLag) {\n      warnProjectionFallback(baseDir, \"getMemoryTimeline\", projectionAge, cachedLag);\n      return readBoundedLifecycleEventsFromLedger(ledgerPath, readSecureFile, cappedLimit, memoryId);\n    }\n\n    const inFlight = this.lagInFlight?.generation === generation\n      ? this.lagInFlight.scan\n      : null;\n    if (inFlight) {\n      const result = await inFlight;\n      if (result.telemetry) {\n        this.lagCache = { generation, telemetry: result.telemetry };\n      }\n      warnProjectionFallback(baseDir, \"getMemoryTimeline\", projectionAge, result.telemetry ?? undefined);\n      if (result.memoryId === memoryId && result.limit === cappedLimit) return result.events;\n      return readBoundedLifecycleEventsFromLedger(ledgerPath, readSecureFile, cappedLimit, memoryId);\n    }\n\n    const tracker = openProjectionLifecycleLedgerLagTracker(baseDir);\n    if (tracker) {\n      const highWater = tracker.highWater;\n      const scan = (async (): Promise<ProjectionLedgerLagScan> => {\n        try {\n          const fallback = await readBoundedLifecycleEventsWithProjectionLag(\n            ledgerPath,\n            readSecureFile,\n            cappedLimit,\n            memoryId,\n            tracker,\n          );\n          return {\n            telemetry: fallback.telemetryAvailable\n              ? {\n                  projectedEvents: highWater.eventCount,\n                  currentLedgerEvents: fallback.currentEventCount,\n                  deltaEvents: fallback.deltaEvents,\n                }\n              : null,\n            events: fallback.events,\n            memoryId,\n            limit: cappedLimit,\n          };\n        } finally {\n          try {\n            tracker.close();\n          } catch {\n            // Lag telemetry cleanup must not replace a successful ledger fallback.\n          }\n        }\n      })();\n      this.lagInFlight = { generation, scan };\n      try {\n        const result = await scan;\n        if (result.telemetry) {\n          this.lagCache = { generation, telemetry: result.telemetry };\n        }\n        warnProjectionFallback(baseDir, \"getMemoryTimeline\", projectionAge, result.telemetry ?? undefined);\n        return result.events;\n      } finally {\n        if (this.lagInFlight?.scan === scan) {\n          this.lagInFlight = null;\n        }\n      }\n    }\n\n    warnProjectionFallback(baseDir, \"getMemoryTimeline\", projectionAge);\n    return readBoundedLifecycleEventsFromLedger(ledgerPath, readSecureFile, cappedLimit, memoryId);\n  }\n}\n\n/**\n * Directory holding the durable pending-append spill for a lifecycle ledger\n * (#2033). When an append cannot acquire the ledger lock within its budget —\n * because a long compaction/rebuild rewrite legitimately holds it — the event\n * is written as its OWN immutable file here instead of being dropped fail-open,\n * then folded back into the ledger by the next lock holder (a later append or\n * the maintenance drain).\n *\n * A per-event file (not a single appended file) is deliberate: each spill is\n * encrypted at its own path so the path-bound AAD stays valid, and the drainer\n * only ever deletes files it has already read — a spill that lands mid-drain is\n * simply a new file picked up on the next pass, so nothing is clobbered or lost.\n */\nexport function pendingLifecycleLedgerDir(ledgerPath: string): string {\n  return `${ledgerPath}.pending.d`;\n}\n\n/**\n * Secure IO the pending spill needs. `writeSecure`/`readSecure` mirror the\n * ledger's own secure write/read so each spill file is encrypted at rest exactly\n * like the ledger it backs (each at its own path-bound AAD).\n *\n * `writeSecure` MUST be ATOMIC (#2033): it writes the payload to a temp file in\n * the SAME directory and then renames it onto `filePath`, so a concurrent lock\n * holder draining the pending dir never lists or reads a half-written spill (the\n * exact partial-fold the drain's `*.jsonl`-only lister must never see). The\n * temp+rename is bound to the FINAL path because the ciphertext's AAD is the\n * final path — an outer rename at the spill layer would leave the bytes\n * undecryptable, so the atomic step lives here in `writeSecure`. The production\n * wiring (`writeMaybeEncryptedFile`) already renames its temp onto `filePath`,\n * naming that temp `<final>.tmp-…` (never `*.jsonl`), so the drain skips it.\n */\nexport interface LifecyclePendingIo {\n  writeSecure: (filePath: string, payload: string) => Promise<void>;\n  readSecure: (filePath: string) => Promise<string>;\n}\n\nfunction withTrailingNewline(content: string): string {\n  return content.length === 0 || content.endsWith(\"\\n\") ? content : `${content}\\n`;\n}\n\n/**\n * Serialize lifecycle events into the ledger's newline-delimited JSON payload,\n * stamping a fallback timestamp on any event that lacks one. Extracted from\n * storage.ts (issue #1995 file-size ratchet); behavior unchanged.\n */\nexport function serializeLifecycleAppendPayload(events: MemoryLifecycleEvent[]): string {\n  const nowIso = new Date().toISOString();\n  return events\n    .map((event) => {\n      const normalized: MemoryLifecycleEvent = {\n        ...event,\n        timestamp: event.timestamp && event.timestamp.length > 0 ? event.timestamp : nowIso,\n      };\n      return `${JSON.stringify(normalized)}\\n`;\n    })\n    .join(\"\");\n}\n\n/**\n * Write one spill file (a fresh, uniquely-named, immutable per-append file).\n * The write goes to the FINAL `<uuid>.jsonl` path through {@link LifecyclePendingIo}\n * `writeSecure`, whose atomic temp+rename (bound to that final path, since the\n * ciphertext's AAD is the final path) guarantees a concurrent lock holder's\n * drain never lists or folds a half-written spill (#2033).\n */\nasync function spillPendingAppend(\n  ledgerPath: string,\n  io: LifecyclePendingIo,\n  payload: string,\n): Promise<void> {\n  const dir = pendingLifecycleLedgerDir(ledgerPath);\n  await ensureContainedSpillDir(dir);\n  const finalPath = path.join(dir, `${randomUUID()}.jsonl`);\n  await io.writeSecure(finalPath, payload);\n}\n\n/** Suffix marking a spill that has been CLAIMED for commit but not yet deleted. */\nconst CLAIMED_SPILL_SUFFIX = \".claimed\";\n\n/**\n * Recover claims a crashed drain left mid-flight (#2033). A crash-safe drain\n * renames `*.jsonl` → `*.jsonl.claimed` BEFORE committing (see\n * {@link claimSpillBatch}); if the process dies between that rename and the\n * ledger write, the durable `.claimed` file is the ONLY copy of those rows. This\n * renames every orphaned `*.jsonl.claimed` back to `*.jsonl` so it re-enters the\n * normal claim+commit flow — nothing a crash left behind is lost. Reads only\n * ever happen at the restored `.jsonl` path, so the path-bound AAD of an\n * encrypted spill stays valid. A file that vanished or cannot be renamed is left\n * for a later pass. MUST run under the held ledger lock, before draining.\n */\nasync function recoverOrphanedClaims(ledgerPath: string): Promise<void> {\n  const claimed = await listContainedSpillFiles(\n    pendingLifecycleLedgerDir(ledgerPath),\n    `.jsonl${CLAIMED_SPILL_SUFFIX}`,\n  );\n  for (const claimedPath of claimed) {\n    const original = claimedPath.slice(0, -CLAIMED_SPILL_SUFFIX.length);\n    await rename(claimedPath, original).catch(() => undefined);\n  }\n}\n\n/** Max bytes of pending-spill content folded into one append (#2033). The drain\n *  reads and concatenates at most this many bytes of spill content per batch, so\n *  a large pending queue folds in bounded segments instead of one giant string:\n *  the secure-store append decrypts the active ledger and concatenates the\n *  payload as a V8 string, and a single unbounded fold could throw before\n *  draining or recreate an encrypted active ledger over the whole-file decrypt\n *  cap, stranding the rows in the excluded pending queue. */\nconst PENDING_SPILL_BATCH_MAX_BYTES = 1024 * 1024;\n\n/**\n * Claim ONE bounded batch of spills for commit via a CRASH-SAFE rename (#2033).\n * Content is read LAZILY here — at each spill's original (AAD-bound) path, so an\n * encrypted spill still decrypts — and at most `PENDING_SPILL_BATCH_MAX_BYTES`\n * (plus one spill) is held in memory or concatenated per call, bounding both the\n * fold's memory and the payload handed to a single append. Each spill is read,\n * then atomically renamed `*.jsonl` → `*.jsonl.claimed` BEFORE its rows are\n * committed: a crash between the claim and the commit leaves the rows on disk\n * (recovered by {@link recoverOrphanedClaims}) instead of losing them. A read\n * failure propagates with the file untouched (not yet claimed), leaving it for a\n * later retry; a rename that fails skips that spill this pass. Returns the batch\n * payload, its claimed paths, and the next input index. A lone spill larger than\n * the batch limit is claimed alone so the drain always makes progress.\n */\nasync function claimSpillBatch(\n  files: string[],\n  startIndex: number,\n  io: LifecyclePendingIo,\n): Promise<{\n  payload: string;\n  claimedPaths: string[];\n  nextIndex: number;\n}> {\n  const parts: string[] = [];\n  const claimedPaths: string[] = [];\n  let payloadBytes = 0;\n  let nextIndex = startIndex;\n  for (; nextIndex < files.length; nextIndex++) {\n    const filePath = files[nextIndex]!;\n    // Read at the ORIGINAL (AAD-bound) path BEFORE claiming. A read failure\n    // propagates with the file untouched, so it stays for a later retry.\n    const content = withTrailingNewline(await io.readSecure(filePath));\n    const spillBytes = Buffer.byteLength(content, \"utf8\");\n    // Stop before a spill that would overflow a non-empty batch so peak memory\n    // and the single-append payload stay bounded; it starts the next batch.\n    if (parts.length > 0 && payloadBytes + spillBytes > PENDING_SPILL_BATCH_MAX_BYTES) {\n      break;\n    }\n    const claimedPath = `${filePath}${CLAIMED_SPILL_SUFFIX}`;\n    try {\n      await rename(filePath, claimedPath);\n    } catch {\n      continue; // could not claim → do not commit; a later drain retries it.\n    }\n    parts.push(content);\n    claimedPaths.push(claimedPath);\n    payloadBytes += spillBytes;\n  }\n  return { payload: parts.join(\"\"), claimedPaths, nextIndex };\n}\n\n/** Delete claimed spill files after their rows are durably committed. A delete\n *  that fails leaves an orphan the next drain recovers and re-commits — a\n *  duplicate the eventId-deduping rebuild collapses, never a lost row (#2033). */\nasync function finalizeClaimedSpills(claimedPaths: string[]): Promise<void> {\n  for (const claimedPath of claimedPaths) {\n    await unlink(claimedPath).catch(() => undefined);\n  }\n}\n\n/** Roll a failed commit's claims back to unclaimed `*.jsonl` spills so they are\n *  retried as normal spills (#2033). Best-effort: an un-renamable claim is\n *  instead recovered by the next drain's orphan sweep. */\nasync function rollbackClaimedSpills(claimedPaths: string[]): Promise<void> {\n  for (const claimedPath of claimedPaths) {\n    const original = claimedPath.slice(0, -CLAIMED_SPILL_SUFFIX.length);\n    await rename(claimedPath, original).catch(() => undefined);\n  }\n}\n\n/**\n * Under the held ledger lock, fold durable pending spills into the ledger in\n * bounded batches together with `extraPayload` (a new event's rows, or \"\" for a\n * drain-only pass). Recover orphaned claims first, then repeatedly claim ONE\n * bounded batch ({@link claimSpillBatch}) — reading its content lazily — COMMIT\n * the claimed rows, and FINALIZE by deleting the claimed files. A commit failure\n * rolls the current batch's claims back to unclaimed spills and rethrows, so a\n * failed write neither loses nor double-commits rows; batches already committed\n * stay durable (append-only, eventId-deduped on rebuild). Returns true when\n * spill rows were committed.\n */\nasync function foldPendingSpillsIntoAppend(\n  ledgerPath: string,\n  append: (payload: string) => Promise<void>,\n  extraPayload: string,\n  pending: LifecyclePendingIo | undefined,\n): Promise<boolean> {\n  if (!pending) {\n    if (extraPayload.length > 0) await append(extraPayload);\n    return false;\n  }\n  await recoverOrphanedClaims(ledgerPath);\n  // listContainedSpillFiles rejects a symlinked pending dir and skips any\n  // symlinked/escaping entry BEFORE we secure-read or later unlink it (#2033),\n  // so a poisoned link cannot redirect a decrypt/delete outside the spill dir.\n  const files = await listContainedSpillFiles(pendingLifecycleLedgerDir(ledgerPath));\n  let nextIndex = 0;\n  let drained = false;\n\n  while (nextIndex < files.length) {\n    const batch = await claimSpillBatch(files, nextIndex, pending);\n    nextIndex = batch.nextIndex;\n    if (batch.claimedPaths.length === 0) {\n      if (nextIndex >= files.length) break;\n      continue;\n    }\n    try {\n      await append(batch.payload);\n    } catch (err) {\n      await rollbackClaimedSpills(batch.claimedPaths);\n      throw err;\n    }\n    await finalizeClaimedSpills(batch.claimedPaths);\n    drained = true;\n  }\n\n  if (extraPayload.length > 0) await append(extraPayload);\n  return drained;\n}\n\n/**\n * Append `payload` to the lifecycle ledger under the cross-process ledger lock\n * so it is serialized against compaction's whole-file rewrite (issue #1910):\n * both hold this lock, so an append during a rewrite waits and lands on the\n * compacted ledger instead of being clobbered by the atomic rename.\n *\n * The acquisition budget defaults to MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS\n * (twice the stale window), NOT withHeldFileLock's 5s default: a compaction\n * rewrite of a large ledger can legitimately hold the lock past 5s, and giving\n * up there would surface acquired=false. With this budget a normal append waits\n * out the compaction — or, if the holder crashed, past the stale-break window so\n * it still acquires.\n *\n * When the budget is nonetheless exhausted (a rewrite of a very large ledger\n * holds the lock past even this window), a configured `pending` queue makes the\n * append DURABLE instead of dropping it fail-open (#2033): the event is spilled\n * to an encrypted per-event file and folded back into the ledger by the next\n * lock holder, guaranteeing eventual append. Without a pending queue the old\n * behavior stands — REFUSE to append unlocked rather than let a rewrite clobber\n * the row. `lockOptions` lets tests shrink the budget to exercise both branches.\n */\nexport async function appendLifecycleEventsSerialized(\n  ledgerPath: string,\n  append: (payload: string) => Promise<void>,\n  payload: string,\n  pending?: LifecyclePendingIo,\n  lockOptions?: Pick<HeldFileLockOptions, \"maxWaitMs\" | \"pollMs\">,\n): Promise<void> {\n  await withHeldFileLock(\n    memoryLifecycleLedgerLockPath(ledgerPath),\n    {\n      staleMs: MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,\n      maxWaitMs: MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS,\n      ...lockOptions,\n    },\n    async (acquired) => {\n      if (!acquired) {\n        if (!pending) {\n          throw new Error(\n            \"memory-lifecycle-ledger append aborted: could not acquire the ledger lock within \"\n            + \"the budget and no durable pending queue is configured; refusing to append unlocked \"\n            + \"so a concurrent compaction rewrite cannot clobber the new event (issue #1910).\",\n          );\n        }\n        await spillPendingAppend(ledgerPath, pending, payload);\n        return;\n      }\n      await foldPendingSpillsIntoAppend(ledgerPath, append, payload, pending);\n    },\n  );\n}\n\n/**\n * Drain the durable pending spills into the ledger under the ledger lock WITHOUT\n * appending a new event (#2033). Maintenance calls this so events that spilled\n * while a long compaction held the lock are eventually written even when no\n * further append arrives. A non-acquired lock is a no-op (retried next pass).\n * Uses the crash-safe claim/commit protocol ({@link foldPendingSpillsIntoAppend}):\n * spills are claimed by rename before the write and deleted only after it, an\n * orphaned claim from an earlier crash is recovered first, and a write failure\n * rolls the claims back — so a process crash mid-drain can never lose a row.\n * Returns true when rows were drained.\n */\nexport async function drainPendingLifecycleAppendsSerialized(\n  ledgerPath: string,\n  append: (payload: string) => Promise<void>,\n  pending: LifecyclePendingIo,\n  lockOptions?: Pick<HeldFileLockOptions, \"maxWaitMs\" | \"pollMs\">,\n): Promise<boolean> {\n  let drained = false;\n  await withHeldFileLock(\n    memoryLifecycleLedgerLockPath(ledgerPath),\n    {\n      staleMs: MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,\n      maxWaitMs: MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS,\n      ...lockOptions,\n    },\n    async (acquired) => {\n      if (!acquired) return; // lock busy; the next maintenance pass retries.\n      drained = await foldPendingSpillsIntoAppend(ledgerPath, append, \"\", pending);\n    },\n  );\n  return drained;\n}\n\n/**\n * Fast-path pending drain for a store (#2033): a no-op that takes NO lock when\n * the pending directory is absent, otherwise ensures the state dir exists and\n * drains under the ledger lock. Keeps StorageManager's public drain method a\n * thin delegate so the bounded-state logic stays in this sibling (issue #1995\n * file-size ratchet). Returns true when rows were drained.\n */\nexport async function drainPendingLifecycleLedgerIfAny(\n  ledgerPath: string,\n  io: LifecyclePendingIo,\n  append: (payload: string) => Promise<void>,\n  ensureReady: () => Promise<void>,\n): Promise<boolean> {\n  try {\n    await stat(pendingLifecycleLedgerDir(ledgerPath));\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false; // nothing pending — no lock taken.\n    throw err;\n  }\n  await ensureReady();\n  return drainPendingLifecycleAppendsSerialized(ledgerPath, append, io);\n}\n\n/** Result of a pre-snapshot lifecycle drain (#2033): `folded` is true when spill\n *  rows were committed to the active ledger; `pendingDeferred` is true when\n *  durable spill rows STILL remain in the offline-sync-EXCLUDED pending queue\n *  after the attempt (the ledger lock was held by a peer, or a spill could not\n *  be claimed). A caller MUST NOT report a clean snapshot while `pendingDeferred`\n *  is true — those append-only rows would be silently omitted. */\nexport interface DrainPendingLifecycleForSyncResult {\n  folded: boolean;\n  pendingDeferred: boolean;\n}\n\n/**\n * Offline-sync pre-snapshot drain (#2033). Like {@link drainPendingLifecycleLedgerIfAny}\n * but reports whether durable rows are STILL pending after the attempt so an\n * offline snapshot never silently drops append-only lifecycle rows (promotions,\n * imports, explicit captures) that spilled while the ledger lock was held. Fast\n * no-op — no lock, no dir creation — when nothing is pending. Otherwise drains\n * under the ledger lock, then re-enumerates the pending directory: any remaining\n * live (`*.jsonl`) or crash-orphaned (`*.jsonl.claimed`) spill marks the drain as\n * deferred. A read/append failure inside the lock (locked key, encrypted body)\n * propagates to the caller, which retries or aborts.\n */\nexport async function drainPendingLifecycleLedgerForSync(\n  ledgerPath: string,\n  io: LifecyclePendingIo,\n  append: (payload: string) => Promise<void>,\n  ensureReady: () => Promise<void>,\n): Promise<DrainPendingLifecycleForSyncResult> {\n  const dir = pendingLifecycleLedgerDir(ledgerPath);\n  try {\n    await stat(dir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return { folded: false, pendingDeferred: false };\n    throw err;\n  }\n  await ensureReady();\n  const folded = await drainPendingLifecycleAppendsSerialized(ledgerPath, append, io);\n  const remaining =\n    (await listContainedSpillFiles(dir)).length +\n    (await listContainedSpillFiles(dir, `.jsonl${CLAIMED_SPILL_SUFFIX}`)).length;\n  return { folded, pendingDeferred: remaining > 0 };\n}\n\n/**\n * Bounded pre-snapshot drain driver (#2033): invoke `drain` up to `maxAttempts`\n * times and return once it reports no pending rows; if durable rows remain\n * deferred (ledger lock held by a peer) or every attempt throws, throw so the\n * offline-sync caller ABORTS rather than building a snapshot that silently omits\n * append-only lifecycle rows. Kept here (not in the access-service god-file, issue\n * #1995) so both snapshot entrypoints share one retry/abort contract.\n */\nexport async function drainPendingLifecycleForSyncOrThrow(\n  drain: () => Promise<DrainPendingLifecycleForSyncResult>,\n  maxAttempts = 3,\n): Promise<void> {\n  let lastError: unknown;\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    try {\n      const result = await drain();\n      if (!result.pendingDeferred) return;\n      lastError = undefined;\n    } catch (err) {\n      lastError = err;\n    }\n  }\n  const detail = lastError\n    ? `: ${displayErrorDetail(lastError) || \"unknown error\"}`\n    : \" (ledger lock held by a peer)\";\n  throw new Error(\n    `offline-sync lifecycle drain could not fold pending memory-lifecycle events after ${maxAttempts} attempts${detail}; aborting snapshot so the pending rows are not silently excluded (#2033)`,\n  );\n}\n"],"mappings":"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","names":["lstat","path","lstat","path"]}

package/dist/{chunk-W6J4POB6.js → chunk-5DHKCO52.js}

@@ -3,7 +3,7 @@ import {
   getOperation,
   operationRequiresAuthorizedNamespace,
   operationUsesPrincipalNamespace
-} from "./chunk-PNAGNVGK.js";
+} from "./chunk-OXRRJXPR.js";
 import {
   assertOperationAuthorizationAllowed
 } from "./chunk-MZWSOLMT.js";
@@ -60,4 +60,4 @@ export {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace
 };
-//# sourceMappingURL=chunk-W6J4POB6.js.map
+//# sourceMappingURL=chunk-5DHKCO52.js.map

package/dist/{chunk-IRXMJLTW.js → chunk-5HK3CJAR.js}

@@ -1,6 +1,6 @@
 import {
   isValidCapsuleSince
-} from "./chunk-5W7CTZ2E.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -484,4 +484,4 @@ export {
   actionConfidenceRequestSchema,
   validateRequest
 };
-//# sourceMappingURL=chunk-IRXMJLTW.js.map
+//# sourceMappingURL=chunk-5HK3CJAR.js.map

package/dist/{chunk-NLUCDKLT.js → chunk-5RWZH6PH.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-PNAGNVGK.js";
+} from "./chunk-OXRRJXPR.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-NLUCDKLT.js.map
+//# sourceMappingURL=chunk-5RWZH6PH.js.map

package/dist/{chunk-H7BZBSP6.js → chunk-645WOU5I.js}

@@ -1,9 +1,9 @@
-import {
-  unifiedDedupeAndRank
-} from "./chunk-LUPVCGYK.js";
 import {
   shouldRecallEventOrderEvidence
 } from "./chunk-BUYVPUEM.js";
+import {
+  unifiedDedupeAndRank
+} from "./chunk-LUPVCGYK.js";
 import {
   buildEvidencePack
 } from "./chunk-DGFU5MSX.js";
@@ -2236,4 +2236,4 @@ var NUMBER_WORD_VALUES = {
 export {
   buildEventOrderRecallSection
 };
-//# sourceMappingURL=chunk-H7BZBSP6.js.map
+//# sourceMappingURL=chunk-645WOU5I.js.map

package/dist/{chunk-AYAZWXJI.js → chunk-76DIF5KT.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportError,
   getOperation
-} from "./chunk-PNAGNVGK.js";
+} from "./chunk-OXRRJXPR.js";
 import {
   abortError,
   isAbortError
@@ -499,4 +499,4 @@ export {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers
 };
-//# sourceMappingURL=chunk-AYAZWXJI.js.map
+//# sourceMappingURL=chunk-76DIF5KT.js.map

package/dist/{chunk-OPPBTPUU.js → chunk-7KQB4EBS.js}

@@ -1,10 +1,10 @@
-import {
-  sidecarKey
-} from "./chunk-UFKPQBXH.js";
 import {
   DERIVED_FROM_MEMORY_ID_RE,
   isConsolidationOperator
 } from "./chunk-G7D6GZ5J.js";
+import {
+  sidecarKey
+} from "./chunk-UFKPQBXH.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -342,4 +342,4 @@ function isPathWithin(candidate, root) {
 export {
   runConsolidationProvenanceCheck
 };
-//# sourceMappingURL=chunk-OPPBTPUU.js.map
+//# sourceMappingURL=chunk-7KQB4EBS.js.map

package/dist/{chunk-I2HTKOOP.js → chunk-7VZFRUQU.js}

@@ -2,10 +2,10 @@ import {
   RECONCILE_MANIFEST_FORMAT,
   RECONCILE_MANIFEST_SCHEMA_VERSION,
   buildReconcileManifestFile
-} from "./chunk-T42L3S6A.js";
+} from "./chunk-XBGHAAKR.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-HZNYJN77.js";
+} from "./chunk-F3NVYTTA.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-XDL5CYZN.js";
@@ -49,4 +49,4 @@ async function createOfflineSyncManifestStream(orchestrator, namespace, userExcl
 export {
   createOfflineSyncManifestStream
 };
-//# sourceMappingURL=chunk-I2HTKOOP.js.map
+//# sourceMappingURL=chunk-7VZFRUQU.js.map

package/dist/{chunk-DPNXADEI.js → chunk-7WOWGRAU.js}

@@ -15,10 +15,10 @@ import {
   PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
   normalizeActionIntent,
   sanitizePayloadString
-} from "./chunk-D2YNNDML.js";
+} from "./chunk-KWIGDKM2.js";
 import {
   parseSubjectRuntimeConfig
-} from "./chunk-AAXJNINV.js";
+} from "./chunk-UL4MKZHI.js";
 import {
   cloneDefaultSessionObserverBands
 } from "./chunk-Z5LAYHGJ.js";
@@ -35,13 +35,13 @@ import {
 import {
   parseExternalWikiRoots
 } from "./chunk-NLDVVWCL.js";
+import {
+  parseDependencyPropagationConfig
+} from "./chunk-VUDMT5CP.js";
 import {
   resolveEmitLegacyTools,
   resolveNamespaceCatalogEnabled
 } from "./chunk-OO42R444.js";
-import {
-  parseDependencyPropagationConfig
-} from "./chunk-VUDMT5CP.js";
 import {
   parseContradictionLocalizationConfig,
   parseContradictionScanConfig
@@ -56,10 +56,13 @@ import {
 } from "./chunk-PIG4WJFQ.js";
 import {
   parseSecurityConfig
-} from "./chunk-T3JQTCCO.js";
+} from "./chunk-JI7U6AS3.js";
 import {
   parseBoundedJsonlStateConfig
 } from "./chunk-KFZY2OFH.js";
+import {
+  parseActiveContextFields
+} from "./chunk-B32WYRXX.js";
 import {
   parseCodingKnowledgeConfig
 } from "./chunk-FEHIOYML.js";
@@ -3640,6 +3643,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
       (category) => typeof category === "string" && VALID_MEMORY_CATEGORIES.has(category)
     ) : void 0,
     maxCompressionTokensPerHour: typeof cfg.maxCompressionTokensPerHour === "number" ? Math.max(0, Math.floor(cfg.maxCompressionTokensPerHour)) : 1500,
+    ...parseActiveContextFields(cfg),
     behaviorLoopAutoTuneEnabled: cfg.behaviorLoopAutoTuneEnabled === true,
     behaviorLoopLearningWindowDays: typeof cfg.behaviorLoopLearningWindowDays === "number" ? Math.max(0, Math.floor(cfg.behaviorLoopLearningWindowDays)) : 14,
     behaviorLoopMinSignalCount: typeof cfg.behaviorLoopMinSignalCount === "number" ? Math.max(0, Math.floor(cfg.behaviorLoopMinSignalCount)) : 10,
@@ -4445,4 +4449,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-DPNXADEI.js.map
+//# sourceMappingURL=chunk-7WOWGRAU.js.map