@remnic/core 10.0.13 → 10.0.15

package/dist/chunk-4O6WRBGE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/search/document-scanner.ts"],"sourcesContent":["import path from \"node:path\";\nimport { lstat, readdir, readFile, realpath } from \"node:fs/promises\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { assertPathInsideRoot } from \"../utils/path-containment.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\n\nexport interface IndexableDocument {\n  /** Memory ID from frontmatter or filename stem */\n  docid: string;\n  /** Absolute file path */\n  path: string;\n  /** Markdown body (no YAML frontmatter) */\n  content: string;\n  /** First ~200 chars for display */\n  snippet: string;\n}\n\n/**\n * Parse YAML frontmatter from a markdown string.\n * Returns the frontmatter key-value pairs and body, or null if no frontmatter block.\n */\nfunction parseFrontmatter(raw: string): { data: Record<string, string>; body: string } | null {\n  // Support both LF and CRLF line endings\n  const normalized = raw.replace(/\\r\\n/g, \"\\n\");\n  const match = normalized.match(/^---\\n([\\s\\S]*?)\\n---\\n?([\\s\\S]*)$/);\n  if (!match) return null;\n\n  const fmBlock = match[1];\n  const body = (match[2] ?? \"\").trim();\n  const data: Record<string, string> = {};\n\n  for (const line of fmBlock.split(\"\\n\")) {\n    const colonIdx = line.indexOf(\":\");\n    if (colonIdx === -1) continue;\n    const key = line.slice(0, colonIdx).trim();\n    const value = line.slice(colonIdx + 1).trim();\n    data[key] = value;\n  }\n\n  return { data, body };\n}\n\n/**\n * Recursively scan a directory for `.md` files and return IndexableDocuments.\n */\nasync function scanDir(dir: string, memoryRootReal: string): Promise<IndexableDocument[]> {\n  const docs: IndexableDocument[] = [];\n  try {\n    const dirStat = await lstat(dir);\n    if (dirStat.isSymbolicLink()) {\n      throw new Error(`Refusing to scan symlinked memory category directory: ${dir}`);\n    }\n    if (!dirStat.isDirectory()) {\n      const error = new Error(`Memory category path is not a directory: ${dir}`) as NodeJS.ErrnoException;\n      error.code = \"ENOTDIR\";\n      throw error;\n    }\n    assertPathInsideRoot(memoryRootReal, await realpath(dir), dir);\n\n    const entries = await readdir(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      if (entry.isSymbolicLink()) continue;\n      const fullPath = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);\n        const sub = await scanDir(fullPath, memoryRootReal);\n        docs.push(...sub);\n      } else if (entry.name.endsWith(\".md\")) {\n        try {\n          assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);\n          const raw = await readFile(fullPath, \"utf-8\");\n          const parsed = parseFrontmatter(raw);\n          const body = parsed ? parsed.body : raw.trim();\n          const docid = parsed?.data.id || path.basename(entry.name, \".md\");\n          docs.push({\n            docid,\n            path: fullPath,\n            content: body,\n            snippet: body.slice(0, 200),\n          });\n        } catch {\n          // Skip unreadable files\n        }\n      }\n    }\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) {\n      // Optional category directories may not exist yet.\n      return docs;\n    }\n    throw err;\n  }\n  return docs;\n}\n\n/**\n * Scan every recall category subdir of memoryDir for indexable markdown\n * documents. The directory set is derived from `RECALL_FALLBACK_DIRS`\n * (utils/category-dir.ts → ALL_CATEGORY_DIRS minus non-recall queue dirs) —\n * the single source of truth — so adding a new category never requires\n * touching this scanner. Non-QMD backends (Orama / Meilisearch / LanceDB)\n * build their index through this helper; deriving from RECALL_FALLBACK_DIRS\n * keeps them in parity with writeMemory's category-dir routing (issue #1546)\n * and the QMD filesystem-fallback corpus. reasoning-traces/ and the other\n * category dirs are covered automatically (issue #564 PR 3 no longer needs a\n * hand-maintained list). scanDir tolerates missing dirs (ENOENT), so category\n * dirs that do not exist yet are skipped.\n */\nexport async function scanMemoryDir(memoryDir: string): Promise<IndexableDocument[]> {\n  let memoryRootReal: string;\n  try {\n    memoryRootReal = await realpath(memoryDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) {\n      return [];\n    }\n    throw err;\n  }\n  const perDir = await Promise.all(\n    RECALL_FALLBACK_DIRS.map((dir) => scanDir(path.join(memoryDir, dir), memoryRootReal)),\n  );\n  return perDir.flat();\n}\n"],"mappings":";;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,OAAO,SAAS,UAAU,gBAAgB;AAoBnD,SAAS,iBAAiB,KAAoE;AAE5F,QAAM,aAAa,IAAI,QAAQ,SAAS,IAAI;AAC5C,QAAM,QAAQ,WAAW,MAAM,oCAAoC;AACnE,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,UAAU,MAAM,CAAC;AACvB,QAAM,QAAQ,MAAM,CAAC,KAAK,IAAI,KAAK;AACnC,QAAM,OAA+B,CAAC;AAEtC,aAAW,QAAQ,QAAQ,MAAM,IAAI,GAAG;AACtC,UAAM,WAAW,KAAK,QAAQ,GAAG;AACjC,QAAI,aAAa,GAAI;AACrB,UAAM,MAAM,KAAK,MAAM,GAAG,QAAQ,EAAE,KAAK;AACzC,UAAM,QAAQ,KAAK,MAAM,WAAW,CAAC,EAAE,KAAK;AAC5C,SAAK,GAAG,IAAI;AAAA,EACd;AAEA,SAAO,EAAE,MAAM,KAAK;AACtB;AAKA,eAAe,QAAQ,KAAa,gBAAsD;AACxF,QAAM,OAA4B,CAAC;AACnC,MAAI;AACF,UAAM,UAAU,MAAM,MAAM,GAAG;AAC/B,QAAI,QAAQ,eAAe,GAAG;AAC5B,YAAM,IAAI,MAAM,yDAAyD,GAAG,EAAE;AAAA,IAChF;AACA,QAAI,CAAC,QAAQ,YAAY,GAAG;AAC1B,YAAM,QAAQ,IAAI,MAAM,4CAA4C,GAAG,EAAE;AACzE,YAAM,OAAO;AACb,YAAM;AAAA,IACR;AACA,yBAAqB,gBAAgB,MAAM,SAAS,GAAG,GAAG,GAAG;AAE7D,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAC1D,eAAW,SAAS,SAAS;AAC3B,UAAI,MAAM,eAAe,EAAG;AAC5B,YAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,UAAI,MAAM,YAAY,GAAG;AACvB,6BAAqB,gBAAgB,MAAM,SAAS,QAAQ,GAAG,QAAQ;AACvE,cAAM,MAAM,MAAM,QAAQ,UAAU,cAAc;AAClD,aAAK,KAAK,GAAG,GAAG;AAAA,MAClB,WAAW,MAAM,KAAK,SAAS,KAAK,GAAG;AACrC,YAAI;AACF,+BAAqB,gBAAgB,MAAM,SAAS,QAAQ,GAAG,QAAQ;AACvE,gBAAM,MAAM,MAAM,SAAS,UAAU,OAAO;AAC5C,gBAAM,SAAS,iBAAiB,GAAG;AACnC,gBAAM,OAAO,SAAS,OAAO,OAAO,IAAI,KAAK;AAC7C,gBAAM,QAAQ,QAAQ,KAAK,MAAM,KAAK,SAAS,MAAM,MAAM,KAAK;AAChE,eAAK,KAAK;AAAA,YACR;AAAA,YACA,MAAM;AAAA,YACN,SAAS;AAAA,YACT,SAAS,KAAK,MAAM,GAAG,GAAG;AAAA,UAC5B,CAAC;AAAA,QACH,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF,SAAS,KAAK;AACZ,QAAI,YAAY,KAAK,QAAQ,GAAG;AAE9B,aAAO;AAAA,IACT;AACA,UAAM;AAAA,EACR;AACA,SAAO;AACT;AAeA,eAAsB,cAAc,WAAiD;AACnF,MAAI;AACJ,MAAI;AACF,qBAAiB,MAAM,SAAS,SAAS;AAAA,EAC3C,SAAS,KAAK;AACZ,QAAI,YAAY,KAAK,QAAQ,GAAG;AAC9B,aAAO,CAAC;AAAA,IACV;AACA,UAAM;AAAA,EACR;AACA,QAAM,SAAS,MAAM,QAAQ;AAAA,IAC3B,qBAAqB,IAAI,CAAC,QAAQ,QAAQ,KAAK,KAAK,WAAW,GAAG,GAAG,cAAc,CAAC;AAAA,EACtF;AACA,SAAO,OAAO,KAAK;AACrB;","names":[]}

package/dist/chunk-6MINUTGJ.js

@@ -1,64 +0,0 @@
-// src/converge-config.ts
-var CONVERGE_CONFLICT_POLICIES = [
-  "newest-wins",
-  "manual"
-];
-var DEFAULT_CONVERGE_CONFLICT_POLICY = "newest-wins";
-var DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS = 3e4;
-var MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS = 36e5;
-function normalizeConvergePeerRequestTimeoutMs(value, label) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    throw new Error(`${label} must be a positive integer number of milliseconds; got ${JSON.stringify(value)}`);
-  }
-  return Math.min(value, MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS);
-}
-function envConvergePeerRequestTimeoutMs() {
-  const raw = process.env.REMNIC_CONVERGE_PEER_TIMEOUT_MS;
-  if (raw === void 0 || raw.trim() === "") return DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS;
-  return normalizeConvergePeerRequestTimeoutMs(Number(raw), "REMNIC_CONVERGE_PEER_TIMEOUT_MS");
-}
-function parsePeerRequestTimeoutMs(value, label) {
-  if (value === void 0) return DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS;
-  return normalizeConvergePeerRequestTimeoutMs(value, label);
-}
-function parseConvergeConfig(block) {
-  if (block === void 0) {
-    return { conflictPolicy: DEFAULT_CONVERGE_CONFLICT_POLICY };
-  }
-  if (block === null || typeof block !== "object" || Array.isArray(block)) {
-    throw new Error("converge must be a plain object");
-  }
-  const prototype = Object.getPrototypeOf(block);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new Error("converge must be a plain object");
-  }
-  const { conflictPolicy: rawConflictPolicy, peerRequestTimeoutMs, ...unknown } = block;
-  let conflictPolicy = rawConflictPolicy;
-  const unknownKey = Object.keys(unknown)[0];
-  if (unknownKey !== void 0) {
-    throw new Error(`converge contains unknown key ${JSON.stringify(unknownKey)}`);
-  }
-  if (conflictPolicy === void 0) {
-    conflictPolicy = DEFAULT_CONVERGE_CONFLICT_POLICY;
-  }
-  if (typeof conflictPolicy === "string" && CONVERGE_CONFLICT_POLICIES.includes(conflictPolicy)) {
-    return {
-      conflictPolicy,
-      ...peerRequestTimeoutMs !== void 0 ? { peerRequestTimeoutMs: parsePeerRequestTimeoutMs(peerRequestTimeoutMs, "converge.peerRequestTimeoutMs") } : {}
-    };
-  }
-  throw new Error(
-    `converge.conflictPolicy must be one of ${CONVERGE_CONFLICT_POLICIES.join(", ")}; got ${JSON.stringify(conflictPolicy)}`
-  );
-}
-
-export {
-  CONVERGE_CONFLICT_POLICIES,
-  DEFAULT_CONVERGE_CONFLICT_POLICY,
-  DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS,
-  MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS,
-  normalizeConvergePeerRequestTimeoutMs,
-  envConvergePeerRequestTimeoutMs,
-  parseConvergeConfig
-};
-//# sourceMappingURL=chunk-6MINUTGJ.js.map

package/dist/chunk-6MINUTGJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/converge-config.ts"],"sourcesContent":["import type { ConvergeConfig, ConvergeConflictPolicy } from \"./types.js\";\n\nexport const CONVERGE_CONFLICT_POLICIES = [\n  \"newest-wins\",\n  \"manual\",\n] as const satisfies readonly ConvergeConflictPolicy[];\n\nexport const DEFAULT_CONVERGE_CONFLICT_POLICY: ConvergeConflictPolicy = \"newest-wins\";\n\n/** Default per-request peer HTTP timeout. Boot-scale corpora (100k+ files in one\n *  namespace) can take well over 30s to serve a manifest snapshot. */\nexport const DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS = 30_000;\n/** Ceiling for the configured timeout — a peer that has not answered in an hour\n *  is unreachable, not slow. */\nexport const MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS = 3_600_000;\n/**\n * ONE normalization policy for every override source (config JSON, env, CLI\n * flag, programmatic options): malformed values are rejected, valid values\n * clamped to the one-hour ceiling. Returns the clamped ms value.\n */\nexport function normalizeConvergePeerRequestTimeoutMs(value: unknown, label: string): number {\n  if (typeof value !== \"number\" || !Number.isInteger(value) || value <= 0) {\n    throw new Error(`${label} must be a positive integer number of milliseconds; got ${JSON.stringify(value)}`);\n  }\n  return Math.min(value, MAX_CONVERGE_PEER_REQUEST_TIMEOUT_MS);\n}\n\n/** Env override, evaluated lazily so tests control time. Junk is rejected. */\nexport function envConvergePeerRequestTimeoutMs(): number {\n  const raw = process.env.REMNIC_CONVERGE_PEER_TIMEOUT_MS;\n  if (raw === undefined || raw.trim() === \"\") return DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS;\n  return normalizeConvergePeerRequestTimeoutMs(Number(raw), \"REMNIC_CONVERGE_PEER_TIMEOUT_MS\");\n}\n\n/** Config-block value: absent -> default, present -> normalized. */\nfunction parsePeerRequestTimeoutMs(value: unknown, label: string): number {\n  if (value === undefined) return DEFAULT_CONVERGE_PEER_REQUEST_TIMEOUT_MS;\n  return normalizeConvergePeerRequestTimeoutMs(value, label);\n}\n\nexport function parseConvergeConfig(block: unknown): ConvergeConfig {\n  if (block === undefined) {\n    return { conflictPolicy: DEFAULT_CONVERGE_CONFLICT_POLICY };\n  }\n  if (block === null || typeof block !== \"object\" || Array.isArray(block)) {\n    throw new Error(\"converge must be a plain object\");\n  }\n  const prototype = Object.getPrototypeOf(block);\n  if (prototype !== Object.prototype && prototype !== null) {\n    throw new Error(\"converge must be a plain object\");\n  }\n  const { conflictPolicy: rawConflictPolicy, peerRequestTimeoutMs, ...unknown } = block as Record<string, unknown>;\n  let conflictPolicy: unknown = rawConflictPolicy;\n  const unknownKey = Object.keys(unknown)[0];\n  if (unknownKey !== undefined) {\n    throw new Error(`converge contains unknown key ${JSON.stringify(unknownKey)}`);\n  }\n  if (conflictPolicy === undefined) {\n    conflictPolicy = DEFAULT_CONVERGE_CONFLICT_POLICY;\n  }\n  if (\n    typeof conflictPolicy === \"string\" &&\n    CONVERGE_CONFLICT_POLICIES.includes(conflictPolicy as ConvergeConflictPolicy)\n  ) {\n    return {\n      conflictPolicy: conflictPolicy as ConvergeConflictPolicy,\n      ...(peerRequestTimeoutMs !== undefined\n        ? { peerRequestTimeoutMs: parsePeerRequestTimeoutMs(peerRequestTimeoutMs, \"converge.peerRequestTimeoutMs\") }\n        : {}),\n    };\n  }\n\n  throw new Error(\n    `converge.conflictPolicy must be one of ${CONVERGE_CONFLICT_POLICIES.join(\", \")}; got ${JSON.stringify(conflictPolicy)}`\n  );\n}\n"],"mappings":";AAEO,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AACF;AAEO,IAAM,mCAA2D;AAIjE,IAAM,2CAA2C;AAGjD,IAAM,uCAAuC;AAM7C,SAAS,sCAAsC,OAAgB,OAAuB;AAC3F,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,UAAU,KAAK,KAAK,SAAS,GAAG;AACvE,UAAM,IAAI,MAAM,GAAG,KAAK,2DAA2D,KAAK,UAAU,KAAK,CAAC,EAAE;AAAA,EAC5G;AACA,SAAO,KAAK,IAAI,OAAO,oCAAoC;AAC7D;AAGO,SAAS,kCAA0C;AACxD,QAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,QAAQ,UAAa,IAAI,KAAK,MAAM,GAAI,QAAO;AACnD,SAAO,sCAAsC,OAAO,GAAG,GAAG,iCAAiC;AAC7F;AAGA,SAAS,0BAA0B,OAAgB,OAAuB;AACxE,MAAI,UAAU,OAAW,QAAO;AAChC,SAAO,sCAAsC,OAAO,KAAK;AAC3D;AAEO,SAAS,oBAAoB,OAAgC;AAClE,MAAI,UAAU,QAAW;AACvB,WAAO,EAAE,gBAAgB,iCAAiC;AAAA,EAC5D;AACA,MAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GAAG;AACvE,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,QAAM,YAAY,OAAO,eAAe,KAAK;AAC7C,MAAI,cAAc,OAAO,aAAa,cAAc,MAAM;AACxD,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,QAAM,EAAE,gBAAgB,mBAAmB,sBAAsB,GAAG,QAAQ,IAAI;AAChF,MAAI,iBAA0B;AAC9B,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,CAAC;AACzC,MAAI,eAAe,QAAW;AAC5B,UAAM,IAAI,MAAM,iCAAiC,KAAK,UAAU,UAAU,CAAC,EAAE;AAAA,EAC/E;AACA,MAAI,mBAAmB,QAAW;AAChC,qBAAiB;AAAA,EACnB;AACA,MACE,OAAO,mBAAmB,YAC1B,2BAA2B,SAAS,cAAwC,GAC5E;AACA,WAAO;AAAA,MACL;AAAA,MACA,GAAI,yBAAyB,SACzB,EAAE,sBAAsB,0BAA0B,sBAAsB,+BAA+B,EAAE,IACzG,CAAC;AAAA,IACP;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,0CAA0C,2BAA2B,KAAK,IAAI,CAAC,SAAS,KAAK,UAAU,cAAc,CAAC;AAAA,EACxH;AACF;","names":[]}

package/dist/chunk-7LEQREP2.js

@@ -1,9 +0,0 @@
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export {
-  sleep
-};
-//# sourceMappingURL=chunk-7LEQREP2.js.map

package/dist/chunk-7LEQREP2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/sleep.ts"],"sourcesContent":["/** Wait without cancellation; keep the timer referenced so awaited polling can finish. */\nexport function sleep(ms: number): Promise<void> {\n  // Constructor form keeps this reachable utility compatible with ES2022 adapter type graphs.\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AACO,SAAS,MAAM,IAA2B;AAE/C,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;","names":[]}

package/dist/chunk-B6O2YLUR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/json-store.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type { Dirent } from \"node:fs\";\nimport {\n  lstat,\n  mkdir,\n  open,\n  readFile,\n  readdir,\n  rename,\n  unlink,\n  utimes,\n  writeFile,\n  type FileHandle,\n} from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { isErrnoCode } from \"./utils/errno.js\";\n\nasync function listJsonFilesStrictInner(dir: string, allowMissingDirectory: boolean): Promise<string[]> {\n  let entries: Dirent[];\n  try {\n    entries = await readdir(dir, { withFileTypes: true });\n  } catch (error) {\n    if (allowMissingDirectory && isErrnoCode(error, \"ENOENT\")) return [];\n    throw error;\n  }\n  const out: string[] = [];\n  for (const entry of entries) {\n    const fullPath = path.join(dir, entry.name);\n    if (entry.isDirectory()) {\n      out.push(...(await listJsonFilesStrictInner(fullPath, false)));\n    } else if (entry.isFile() && entry.name.endsWith(\".json\")) {\n      out.push(fullPath);\n    }\n  }\n  return out.sort();\n}\n\nexport async function listJsonFilesStrict(\n  dir: string,\n  options: { allowMissingDirectory?: boolean } = {}\n): Promise<string[]> {\n  return listJsonFilesStrictInner(dir, options.allowMissingDirectory === true);\n}\n\nexport async function listJsonFiles(dir: string): Promise<string[]> {\n  try {\n    return await listJsonFilesStrict(dir);\n  } catch {\n    return [];\n  }\n}\n\nexport async function listNamedFiles(dir: string, fileName: string): Promise<string[]> {\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    const out: string[] = [];\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        out.push(...(await listNamedFiles(fullPath, fileName)));\n      } else if (entry.isFile() && entry.name === fileName) {\n        out.push(fullPath);\n      }\n    }\n    return out.sort();\n  } catch {\n    return [];\n  }\n}\n\nconst jsonStoreMutationTails = new Map<string, Promise<void>>();\n\nconst JSON_STORE_LOCK_RETRY_MS = 25;\nconst JSON_STORE_LOCK_STALE_MS = 60_000;\nconst JSON_STORE_LOCK_TIMEOUT_MS = 10_000;\n\ntype JsonStoreMutationLockTestHooks = {\n  beforeLockOwnerWrite?: (lockPath: string, ownerToken: string) => Promise<void> | void;\n  beforeLockOwnershipConfirm?: (lockPath: string, ownerToken: string) => Promise<void> | void;\n  afterReclaimGuardWrite?: (reclaimPath: string, ownerToken: string) => Promise<void> | void;\n  retryMs?: number;\n  staleLockMs?: number;\n  timeoutMs?: number;\n};\n\nlet jsonStoreMutationLockTestHooks: JsonStoreMutationLockTestHooks | null = null;\n\nexport function setJsonStoreMutationLockTestHooks(hooks: JsonStoreMutationLockTestHooks | null): void {\n  jsonStoreMutationLockTestHooks = hooks;\n}\n\nfunction jsonStoreLockRetryMs(): number {\n  return jsonStoreMutationLockTestHooks?.retryMs ?? JSON_STORE_LOCK_RETRY_MS;\n}\n\nfunction jsonStoreLockStaleMs(): number {\n  return jsonStoreMutationLockTestHooks?.staleLockMs ?? JSON_STORE_LOCK_STALE_MS;\n}\n\nfunction jsonStoreLockTimeoutMs(): number {\n  return jsonStoreMutationLockTestHooks?.timeoutMs ?? JSON_STORE_LOCK_TIMEOUT_MS;\n}\n\nasync function closeAndRemoveJsonStoreReclaimGuard(reclaimPath: string, reclaimHandle: FileHandle): Promise<void> {\n  await reclaimHandle.close().catch(() => undefined);\n  await unlink(reclaimPath).catch((error) => {\n    if (!isErrnoCode(error, \"ENOENT\")) throw error;\n  });\n}\n\nasync function removeStaleJsonStoreReclaimGuard(reclaimPath: string): Promise<void> {\n  let initial: JsonStoreLockState;\n  try {\n    initial = await readJsonStoreLockState(reclaimPath);\n  } catch (error) {\n    if (isErrnoCode(error, \"ENOENT\")) return;\n    throw error;\n  }\n  if (Date.now() - initial.mtimeMs <= jsonStoreLockStaleMs()) return;\n\n  let ownerPid: number | undefined;\n  try {\n    const metadata = JSON.parse(initial.content) as { pid?: unknown };\n    ownerPid = typeof metadata.pid === \"number\" && Number.isInteger(metadata.pid) ? metadata.pid : undefined;\n  } catch {\n    ownerPid = undefined;\n  }\n  if (ownerPid !== undefined && processIsRunning(ownerPid)) return;\n\n  let confirmed: JsonStoreLockState;\n  try {\n    confirmed = await readJsonStoreLockState(reclaimPath);\n  } catch (error) {\n    if (isErrnoCode(error, \"ENOENT\")) return;\n    throw error;\n  }\n  if (!sameJsonStoreLockState(initial, confirmed)) return;\n  await unlink(reclaimPath).catch((error) => {\n    if (!isErrnoCode(error, \"ENOENT\")) throw error;\n  });\n}\n\nasync function acquireJsonStoreReclaimGuard(reclaimPath: string): Promise<FileHandle | undefined> {\n  try {\n    return await open(reclaimPath, \"wx\", 0o600);\n  } catch (error) {\n    if (!isErrnoCode(error, \"EEXIST\")) throw error;\n    await removeStaleJsonStoreReclaimGuard(reclaimPath);\n    try {\n      return await open(reclaimPath, \"wx\", 0o600);\n    } catch (retryError) {\n      if (isErrnoCode(retryError, \"EEXIST\")) return undefined;\n      throw retryError;\n    }\n  }\n}\n\nfunction waitForJsonStoreLock(): Promise<void> {\n  const { promise, resolve } = Promise.withResolvers<void>();\n  setTimeout(resolve, jsonStoreLockRetryMs());\n  return promise;\n}\n\nfunction processIsRunning(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    return !isErrnoCode(error, \"ESRCH\");\n  }\n}\n\ntype JsonStoreLockState = {\n  mtimeMs: number;\n  size: number;\n  ino: number | undefined;\n  content: string;\n};\n\nasync function readJsonStoreLockState(lockPath: string): Promise<JsonStoreLockState> {\n  const lockStat = await lstat(lockPath);\n  if (!lockStat.isFile()) {\n    throw new Error(`JSON store mutation lock is not a regular file: ${lockPath}`);\n  }\n  return {\n    mtimeMs: lockStat.mtimeMs,\n    size: lockStat.size,\n    ino: typeof lockStat.ino === \"number\" ? lockStat.ino : undefined,\n    content: await readFile(lockPath, \"utf8\"),\n  };\n}\n\nfunction sameJsonStoreLockState(left: JsonStoreLockState, right: JsonStoreLockState): boolean {\n  return (\n    left.mtimeMs === right.mtimeMs &&\n    left.size === right.size &&\n    left.ino === right.ino &&\n    left.content === right.content\n  );\n}\n\nasync function removeJsonStoreMutationLockIfOwned(lockPath: string, token: string): Promise<void> {\n  try {\n    const state = await readJsonStoreLockState(lockPath);\n    const metadata = JSON.parse(state.content) as { token?: unknown };\n    if (metadata.token === token) await unlink(lockPath);\n  } catch (error) {\n    if (!isErrnoCode(error, \"ENOENT\") && !(error instanceof SyntaxError)) throw error;\n  }\n}\n\nasync function removeStaleJsonStoreLock(lockPath: string): Promise<void> {\n  const reclaimPath = `${lockPath}.reclaim`;\n  const reclaimHandle = await acquireJsonStoreReclaimGuard(reclaimPath);\n  if (!reclaimHandle) return;\n  try {\n    await reclaimHandle.writeFile(JSON.stringify({ pid: process.pid }), \"utf8\");\n    await jsonStoreMutationLockTestHooks?.afterReclaimGuardWrite?.(reclaimPath, String(process.pid));\n\n    let initial: JsonStoreLockState;\n    try {\n      initial = await readJsonStoreLockState(lockPath);\n    } catch (error) {\n      if (isErrnoCode(error, \"ENOENT\")) return;\n      throw error;\n    }\n    if (Date.now() - initial.mtimeMs <= jsonStoreLockStaleMs()) return;\n    let ownerPid: number | undefined;\n    try {\n      const metadata = JSON.parse(initial.content) as { pid?: unknown };\n      ownerPid = typeof metadata.pid === \"number\" && Number.isInteger(metadata.pid) ? metadata.pid : undefined;\n    } catch {\n      ownerPid = undefined;\n    }\n    if (ownerPid !== undefined && processIsRunning(ownerPid)) return;\n\n    let confirmed: JsonStoreLockState;\n    try {\n      confirmed = await readJsonStoreLockState(lockPath);\n    } catch (error) {\n      if (isErrnoCode(error, \"ENOENT\")) return;\n      throw error;\n    }\n    if (!sameJsonStoreLockState(initial, confirmed)) return;\n    await unlink(lockPath).catch((error) => {\n      if (!isErrnoCode(error, \"ENOENT\")) throw error;\n    });\n  } finally {\n    await closeAndRemoveJsonStoreReclaimGuard(reclaimPath, reclaimHandle);\n  }\n}\n\nasync function confirmJsonStoreMutationLockOwnership(\n  lockPath: string,\n  token: string,\n  deadline: number\n): Promise<boolean> {\n  const reclaimPath = `${lockPath}.reclaim`;\n  while (true) {\n    const reclaimHandle = await acquireJsonStoreReclaimGuard(reclaimPath);\n    if (!reclaimHandle) {\n      if (Date.now() >= deadline) return false;\n      await waitForJsonStoreLock();\n      continue;\n    }\n    try {\n      try {\n        const state = await readJsonStoreLockState(lockPath);\n        const metadata = JSON.parse(state.content) as { token?: unknown };\n        return metadata.token === token;\n      } catch (error) {\n        if (isErrnoCode(error, \"ENOENT\") || error instanceof SyntaxError) return false;\n        throw error;\n      }\n    } finally {\n      await closeAndRemoveJsonStoreReclaimGuard(reclaimPath, reclaimHandle);\n    }\n  }\n}\n\nasync function acquireJsonStoreMutationFileLock(key: string): Promise<() => Promise<void>> {\n  const lockPath = `${path.resolve(key)}.mutation.lock`;\n  await mkdir(path.dirname(lockPath), { recursive: true });\n  const token = randomUUID();\n  const deadline = Date.now() + jsonStoreLockTimeoutMs();\n  while (true) {\n    let handle: FileHandle;\n    try {\n      handle = await open(lockPath, \"wx\", 0o600);\n    } catch (error) {\n      if (!isErrnoCode(error, \"EEXIST\")) throw error;\n      await removeStaleJsonStoreLock(lockPath).catch((staleError) => {\n        if (!isErrnoCode(staleError, \"ENOENT\")) throw staleError;\n      });\n      if (Date.now() >= deadline) {\n        throw new Error(`Timed out acquiring JSON store mutation lock: ${lockPath}`);\n      }\n      await waitForJsonStoreLock();\n      continue;\n    }\n    try {\n      await jsonStoreMutationLockTestHooks?.beforeLockOwnerWrite?.(lockPath, token);\n      await handle.writeFile(JSON.stringify({ pid: process.pid, token }), \"utf8\");\n    } finally {\n      await handle.close().catch(() => undefined);\n    }\n    await jsonStoreMutationLockTestHooks?.beforeLockOwnershipConfirm?.(lockPath, token);\n\n    if (!(await confirmJsonStoreMutationLockOwnership(lockPath, token, deadline))) {\n      await removeJsonStoreMutationLockIfOwned(lockPath, token);\n      if (Date.now() >= deadline) {\n        throw new Error(`Timed out acquiring JSON store mutation lock: ${lockPath}`);\n      }\n      await waitForJsonStoreLock();\n      continue;\n    }\n\n    const heartbeat = setInterval(\n      () => {\n        void readFile(lockPath, \"utf8\")\n          .then((content) => {\n            const metadata = JSON.parse(content) as { token?: unknown };\n            if (metadata.token !== token) return;\n            const now = new Date();\n            return utimes(lockPath, now, now);\n          })\n          .catch(() => undefined);\n      },\n      Math.max(1, Math.floor(jsonStoreLockStaleMs() / 3))\n    );\n    heartbeat.unref();\n    return async () => {\n      clearInterval(heartbeat);\n      try {\n        const metadata = JSON.parse(await readFile(lockPath, \"utf8\")) as { token?: unknown };\n        if (metadata.token === token) await unlink(lockPath);\n      } catch (error) {\n        if (!isErrnoCode(error, \"ENOENT\")) throw error;\n      }\n    };\n  }\n}\n\nexport async function withJsonStoreMutationLock<T>(key: string, operation: () => Promise<T>): Promise<T> {\n  const normalizedKey = path.resolve(key);\n  const previous = jsonStoreMutationTails.get(normalizedKey) ?? Promise.resolve();\n  const { promise: current, resolve: release } = Promise.withResolvers<void>();\n  const tail = previous.catch(() => undefined).then(() => current);\n  jsonStoreMutationTails.set(normalizedKey, tail);\n  await previous.catch(() => undefined);\n  let releaseFileLock: (() => Promise<void>) | undefined;\n  try {\n    releaseFileLock = await acquireJsonStoreMutationFileLock(normalizedKey);\n    return await operation();\n  } finally {\n    try {\n      await releaseFileLock?.();\n    } finally {\n      release();\n      if (jsonStoreMutationTails.get(normalizedKey) === tail) {\n        jsonStoreMutationTails.delete(normalizedKey);\n      }\n    }\n  }\n}\n\nexport async function readJsonFile(filePath: string): Promise<unknown> {\n  return JSON.parse(await readFile(filePath, \"utf8\")) as unknown;\n}\n\nexport async function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void> {\n  await mkdir(path.dirname(filePath), { recursive: true });\n  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;\n  try {\n    await writeFile(tempPath, JSON.stringify(value, null, 2), \"utf8\");\n    await rename(tempPath, filePath);\n  } catch (error) {\n    await unlink(tempPath).catch(() => undefined);\n    throw error;\n  }\n}\n"],"mappings":";;;;;AAAA,SAAS,kBAAkB;AAE3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,OAAO,UAAU;AAGjB,eAAe,yBAAyB,KAAa,uBAAmD;AACtG,MAAI;AACJ,MAAI;AACF,cAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAAA,EACtD,SAAS,OAAO;AACd,QAAI,yBAAyB,YAAY,OAAO,QAAQ,EAAG,QAAO,CAAC;AACnE,UAAM;AAAA,EACR;AACA,QAAM,MAAgB,CAAC;AACvB,aAAW,SAAS,SAAS;AAC3B,UAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,QAAI,MAAM,YAAY,GAAG;AACvB,UAAI,KAAK,GAAI,MAAM,yBAAyB,UAAU,KAAK,CAAE;AAAA,IAC/D,WAAW,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,OAAO,GAAG;AACzD,UAAI,KAAK,QAAQ;AAAA,IACnB;AAAA,EACF;AACA,SAAO,IAAI,KAAK;AAClB;AAEA,eAAsB,oBACpB,KACA,UAA+C,CAAC,GAC7B;AACnB,SAAO,yBAAyB,KAAK,QAAQ,0BAA0B,IAAI;AAC7E;AAEA,eAAsB,cAAc,KAAgC;AAClE,MAAI;AACF,WAAO,MAAM,oBAAoB,GAAG;AAAA,EACtC,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,eAAe,KAAa,UAAqC;AACrF,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAC1D,UAAM,MAAgB,CAAC;AACvB,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,UAAI,MAAM,YAAY,GAAG;AACvB,YAAI,KAAK,GAAI,MAAM,eAAe,UAAU,QAAQ,CAAE;AAAA,MACxD,WAAW,MAAM,OAAO,KAAK,MAAM,SAAS,UAAU;AACpD,YAAI,KAAK,QAAQ;AAAA,MACnB;AAAA,IACF;AACA,WAAO,IAAI,KAAK;AAAA,EAClB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,IAAM,yBAAyB,oBAAI,IAA2B;AAE9D,IAAM,2BAA2B;AACjC,IAAM,2BAA2B;AACjC,IAAM,6BAA6B;AAWnC,IAAI,iCAAwE;AAErE,SAAS,kCAAkC,OAAoD;AACpG,mCAAiC;AACnC;AAEA,SAAS,uBAA+B;AACtC,SAAO,gCAAgC,WAAW;AACpD;AAEA,SAAS,uBAA+B;AACtC,SAAO,gCAAgC,eAAe;AACxD;AAEA,SAAS,yBAAiC;AACxC,SAAO,gCAAgC,aAAa;AACtD;AAEA,eAAe,oCAAoC,aAAqB,eAA0C;AAChH,QAAM,cAAc,MAAM,EAAE,MAAM,MAAM,MAAS;AACjD,QAAM,OAAO,WAAW,EAAE,MAAM,CAAC,UAAU;AACzC,QAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AAAA,EAC3C,CAAC;AACH;AAEA,eAAe,iCAAiC,aAAoC;AAClF,MAAI;AACJ,MAAI;AACF,cAAU,MAAM,uBAAuB,WAAW;AAAA,EACpD,SAAS,OAAO;AACd,QAAI,YAAY,OAAO,QAAQ,EAAG;AAClC,UAAM;AAAA,EACR;AACA,MAAI,KAAK,IAAI,IAAI,QAAQ,WAAW,qBAAqB,EAAG;AAE5D,MAAI;AACJ,MAAI;AACF,UAAM,WAAW,KAAK,MAAM,QAAQ,OAAO;AAC3C,eAAW,OAAO,SAAS,QAAQ,YAAY,OAAO,UAAU,SAAS,GAAG,IAAI,SAAS,MAAM;AAAA,EACjG,QAAQ;AACN,eAAW;AAAA,EACb;AACA,MAAI,aAAa,UAAa,iBAAiB,QAAQ,EAAG;AAE1D,MAAI;AACJ,MAAI;AACF,gBAAY,MAAM,uBAAuB,WAAW;AAAA,EACtD,SAAS,OAAO;AACd,QAAI,YAAY,OAAO,QAAQ,EAAG;AAClC,UAAM;AAAA,EACR;AACA,MAAI,CAAC,uBAAuB,SAAS,SAAS,EAAG;AACjD,QAAM,OAAO,WAAW,EAAE,MAAM,CAAC,UAAU;AACzC,QAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AAAA,EAC3C,CAAC;AACH;AAEA,eAAe,6BAA6B,aAAsD;AAChG,MAAI;AACF,WAAO,MAAM,KAAK,aAAa,MAAM,GAAK;AAAA,EAC5C,SAAS,OAAO;AACd,QAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AACzC,UAAM,iCAAiC,WAAW;AAClD,QAAI;AACF,aAAO,MAAM,KAAK,aAAa,MAAM,GAAK;AAAA,IAC5C,SAAS,YAAY;AACnB,UAAI,YAAY,YAAY,QAAQ,EAAG,QAAO;AAC9C,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAEA,SAAS,uBAAsC;AAC7C,QAAM,EAAE,SAAS,QAAQ,IAAI,QAAQ,cAAoB;AACzD,aAAW,SAAS,qBAAqB,CAAC;AAC1C,SAAO;AACT;AAEA,SAAS,iBAAiB,KAAsB;AAC9C,MAAI;AACF,YAAQ,KAAK,KAAK,CAAC;AACnB,WAAO;AAAA,EACT,SAAS,OAAO;AACd,WAAO,CAAC,YAAY,OAAO,OAAO;AAAA,EACpC;AACF;AASA,eAAe,uBAAuB,UAA+C;AACnF,QAAM,WAAW,MAAM,MAAM,QAAQ;AACrC,MAAI,CAAC,SAAS,OAAO,GAAG;AACtB,UAAM,IAAI,MAAM,mDAAmD,QAAQ,EAAE;AAAA,EAC/E;AACA,SAAO;AAAA,IACL,SAAS,SAAS;AAAA,IAClB,MAAM,SAAS;AAAA,IACf,KAAK,OAAO,SAAS,QAAQ,WAAW,SAAS,MAAM;AAAA,IACvD,SAAS,MAAM,SAAS,UAAU,MAAM;AAAA,EAC1C;AACF;AAEA,SAAS,uBAAuB,MAA0B,OAAoC;AAC5F,SACE,KAAK,YAAY,MAAM,WACvB,KAAK,SAAS,MAAM,QACpB,KAAK,QAAQ,MAAM,OACnB,KAAK,YAAY,MAAM;AAE3B;AAEA,eAAe,mCAAmC,UAAkB,OAA8B;AAChG,MAAI;AACF,UAAM,QAAQ,MAAM,uBAAuB,QAAQ;AACnD,UAAM,WAAW,KAAK,MAAM,MAAM,OAAO;AACzC,QAAI,SAAS,UAAU,MAAO,OAAM,OAAO,QAAQ;AAAA,EACrD,SAAS,OAAO;AACd,QAAI,CAAC,YAAY,OAAO,QAAQ,KAAK,EAAE,iBAAiB,aAAc,OAAM;AAAA,EAC9E;AACF;AAEA,eAAe,yBAAyB,UAAiC;AACvE,QAAM,cAAc,GAAG,QAAQ;AAC/B,QAAM,gBAAgB,MAAM,6BAA6B,WAAW;AACpE,MAAI,CAAC,cAAe;AACpB,MAAI;AACF,UAAM,cAAc,UAAU,KAAK,UAAU,EAAE,KAAK,QAAQ,IAAI,CAAC,GAAG,MAAM;AAC1E,UAAM,gCAAgC,yBAAyB,aAAa,OAAO,QAAQ,GAAG,CAAC;AAE/F,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,uBAAuB,QAAQ;AAAA,IACjD,SAAS,OAAO;AACd,UAAI,YAAY,OAAO,QAAQ,EAAG;AAClC,YAAM;AAAA,IACR;AACA,QAAI,KAAK,IAAI,IAAI,QAAQ,WAAW,qBAAqB,EAAG;AAC5D,QAAI;AACJ,QAAI;AACF,YAAM,WAAW,KAAK,MAAM,QAAQ,OAAO;AAC3C,iBAAW,OAAO,SAAS,QAAQ,YAAY,OAAO,UAAU,SAAS,GAAG,IAAI,SAAS,MAAM;AAAA,IACjG,QAAQ;AACN,iBAAW;AAAA,IACb;AACA,QAAI,aAAa,UAAa,iBAAiB,QAAQ,EAAG;AAE1D,QAAI;AACJ,QAAI;AACF,kBAAY,MAAM,uBAAuB,QAAQ;AAAA,IACnD,SAAS,OAAO;AACd,UAAI,YAAY,OAAO,QAAQ,EAAG;AAClC,YAAM;AAAA,IACR;AACA,QAAI,CAAC,uBAAuB,SAAS,SAAS,EAAG;AACjD,UAAM,OAAO,QAAQ,EAAE,MAAM,CAAC,UAAU;AACtC,UAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AAAA,IAC3C,CAAC;AAAA,EACH,UAAE;AACA,UAAM,oCAAoC,aAAa,aAAa;AAAA,EACtE;AACF;AAEA,eAAe,sCACb,UACA,OACA,UACkB;AAClB,QAAM,cAAc,GAAG,QAAQ;AAC/B,SAAO,MAAM;AACX,UAAM,gBAAgB,MAAM,6BAA6B,WAAW;AACpE,QAAI,CAAC,eAAe;AAClB,UAAI,KAAK,IAAI,KAAK,SAAU,QAAO;AACnC,YAAM,qBAAqB;AAC3B;AAAA,IACF;AACA,QAAI;AACF,UAAI;AACF,cAAM,QAAQ,MAAM,uBAAuB,QAAQ;AACnD,cAAM,WAAW,KAAK,MAAM,MAAM,OAAO;AACzC,eAAO,SAAS,UAAU;AAAA,MAC5B,SAAS,OAAO;AACd,YAAI,YAAY,OAAO,QAAQ,KAAK,iBAAiB,YAAa,QAAO;AACzE,cAAM;AAAA,MACR;AAAA,IACF,UAAE;AACA,YAAM,oCAAoC,aAAa,aAAa;AAAA,IACtE;AAAA,EACF;AACF;AAEA,eAAe,iCAAiC,KAA2C;AACzF,QAAM,WAAW,GAAG,KAAK,QAAQ,GAAG,CAAC;AACrC,QAAM,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AACvD,QAAM,QAAQ,WAAW;AACzB,QAAM,WAAW,KAAK,IAAI,IAAI,uBAAuB;AACrD,SAAO,MAAM;AACX,QAAI;AACJ,QAAI;AACF,eAAS,MAAM,KAAK,UAAU,MAAM,GAAK;AAAA,IAC3C,SAAS,OAAO;AACd,UAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AACzC,YAAM,yBAAyB,QAAQ,EAAE,MAAM,CAAC,eAAe;AAC7D,YAAI,CAAC,YAAY,YAAY,QAAQ,EAAG,OAAM;AAAA,MAChD,CAAC;AACD,UAAI,KAAK,IAAI,KAAK,UAAU;AAC1B,cAAM,IAAI,MAAM,iDAAiD,QAAQ,EAAE;AAAA,MAC7E;AACA,YAAM,qBAAqB;AAC3B;AAAA,IACF;AACA,QAAI;AACF,YAAM,gCAAgC,uBAAuB,UAAU,KAAK;AAC5E,YAAM,OAAO,UAAU,KAAK,UAAU,EAAE,KAAK,QAAQ,KAAK,MAAM,CAAC,GAAG,MAAM;AAAA,IAC5E,UAAE;AACA,YAAM,OAAO,MAAM,EAAE,MAAM,MAAM,MAAS;AAAA,IAC5C;AACA,UAAM,gCAAgC,6BAA6B,UAAU,KAAK;AAElF,QAAI,CAAE,MAAM,sCAAsC,UAAU,OAAO,QAAQ,GAAI;AAC7E,YAAM,mCAAmC,UAAU,KAAK;AACxD,UAAI,KAAK,IAAI,KAAK,UAAU;AAC1B,cAAM,IAAI,MAAM,iDAAiD,QAAQ,EAAE;AAAA,MAC7E;AACA,YAAM,qBAAqB;AAC3B;AAAA,IACF;AAEA,UAAM,YAAY;AAAA,MAChB,MAAM;AACJ,aAAK,SAAS,UAAU,MAAM,EAC3B,KAAK,CAAC,YAAY;AACjB,gBAAM,WAAW,KAAK,MAAM,OAAO;AACnC,cAAI,SAAS,UAAU,MAAO;AAC9B,gBAAM,MAAM,oBAAI,KAAK;AACrB,iBAAO,OAAO,UAAU,KAAK,GAAG;AAAA,QAClC,CAAC,EACA,MAAM,MAAM,MAAS;AAAA,MAC1B;AAAA,MACA,KAAK,IAAI,GAAG,KAAK,MAAM,qBAAqB,IAAI,CAAC,CAAC;AAAA,IACpD;AACA,cAAU,MAAM;AAChB,WAAO,YAAY;AACjB,oBAAc,SAAS;AACvB,UAAI;AACF,cAAM,WAAW,KAAK,MAAM,MAAM,SAAS,UAAU,MAAM,CAAC;AAC5D,YAAI,SAAS,UAAU,MAAO,OAAM,OAAO,QAAQ;AAAA,MACrD,SAAS,OAAO;AACd,YAAI,CAAC,YAAY,OAAO,QAAQ,EAAG,OAAM;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAsB,0BAA6B,KAAa,WAAyC;AACvG,QAAM,gBAAgB,KAAK,QAAQ,GAAG;AACtC,QAAM,WAAW,uBAAuB,IAAI,aAAa,KAAK,QAAQ,QAAQ;AAC9E,QAAM,EAAE,SAAS,SAAS,SAAS,QAAQ,IAAI,QAAQ,cAAoB;AAC3E,QAAM,OAAO,SAAS,MAAM,MAAM,MAAS,EAAE,KAAK,MAAM,OAAO;AAC/D,yBAAuB,IAAI,eAAe,IAAI;AAC9C,QAAM,SAAS,MAAM,MAAM,MAAS;AACpC,MAAI;AACJ,MAAI;AACF,sBAAkB,MAAM,iCAAiC,aAAa;AACtE,WAAO,MAAM,UAAU;AAAA,EACzB,UAAE;AACA,QAAI;AACF,YAAM,kBAAkB;AAAA,IAC1B,UAAE;AACA,cAAQ;AACR,UAAI,uBAAuB,IAAI,aAAa,MAAM,MAAM;AACtD,+BAAuB,OAAO,aAAa;AAAA,MAC7C;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAsB,aAAa,UAAoC;AACrE,SAAO,KAAK,MAAM,MAAM,SAAS,UAAU,MAAM,CAAC;AACpD;AAEA,eAAsB,oBAAoB,UAAkB,OAA+B;AACzF,QAAM,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AACvD,QAAM,WAAW,GAAG,QAAQ,IAAI,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAChG,MAAI;AACF,UAAM,UAAU,UAAU,KAAK,UAAU,OAAO,MAAM,CAAC,GAAG,MAAM;AAChE,UAAM,OAAO,UAAU,QAAQ;AAAA,EACjC,SAAS,OAAO;AACd,UAAM,OAAO,QAAQ,EAAE,MAAM,MAAM,MAAS;AAC5C,UAAM;AAAA,EACR;AACF;","names":[]}

package/dist/chunk-BLVHDY2U.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/profiling.ts"],"sourcesContent":["// Performance profiling collector for recall and extraction traces.\n// Zero external dependencies — uses only node:fs and node:path.\n\nimport {\n  existsSync,\n  mkdirSync,\n  writeFileSync,\n  promises as fsp,\n} from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { log } from \"./logger.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface ProfileSpan {\n  name: string;\n  startOffsetMs: number;\n  durationMs: number;\n}\n\nexport interface ProfileParallelGroupMember {\n  name: string;\n  durationMs: number;\n  resolvedIndex: number;\n}\n\nexport interface ProfileParallelGroup {\n  name: string;\n  startOffsetMs: number;\n  wallMs: number;\n  members: ProfileParallelGroupMember[];\n}\n\nexport interface ProfileTrace {\n  ts: string;\n  kind: \"recall\" | \"extraction\";\n  traceId: string;\n  sessionKey?: string;\n  totalMs: number;\n  spans: ProfileSpan[];\n  parallelGroups?: ProfileParallelGroup[];\n  configSnapshot?: Record<string, unknown>;\n}\n\nexport interface ProfilingConfig {\n  enabled: boolean;\n  storageDir: string;\n  maxTraces: number;\n}\n\nexport interface ParallelGroupHandle {\n  name: string;\n  startOffsetMs: number;\n  traceId?: string;\n}\n\nexport interface ProfilingStats {\n  byKind: Record<string, { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number }>;\n  bySpan: Record<string, { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number }>;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction percentile(sorted: number[], p: number): number {\n  if (sorted.length === 0) return 0;\n  const idx = Math.ceil((p / 100) * sorted.length) - 1;\n  return sorted[Math.max(0, Math.min(idx, sorted.length - 1))];\n}\n\nfunction aggregateStats(values: number[]): { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number } {\n  const count = values.length;\n  if (count === 0) return { count: 0, avgMs: 0, p50Ms: 0, p95Ms: 0, maxMs: 0 };\n  const sorted = [...values].sort((a, b) => a - b);\n  const sum = sorted.reduce((s, v) => s + v, 0);\n  return {\n    count,\n    avgMs: Math.round(sum / count),\n    p50Ms: Math.round(percentile(sorted, 50)),\n    p95Ms: Math.round(percentile(sorted, 95)),\n    maxMs: sorted[sorted.length - 1],\n  };\n}\n\nlet traceCounter = 0;\n\n// ---------------------------------------------------------------------------\n// ProfilingCollector\n// ---------------------------------------------------------------------------\n\nexport class ProfilingCollector {\n  private enabled: boolean;\n  private storageDir: string;\n  private maxTraces: number;\n  private traces: ProfileTrace[] = [];\n  private prunePromise: Promise<void> | null = null;\n\n  // Active trace state — keyed by traceId so concurrent pipelines are isolated.\n  private activeTraces = new Map<\n    string,\n    {\n      kind: \"recall\" | \"extraction\";\n      start: number;\n      sessionKey?: string;\n      configSnapshot?: Record<string, unknown>;\n      spans: ProfileSpan[];\n      spanStarts: Map<string, number>;\n      parallelGroups: ProfileParallelGroup[];\n    }\n  >();\n  private latestTraceId = \"\";\n\n  constructor(config: ProfilingConfig) {\n    this.enabled = config.enabled;\n    this.storageDir = config.storageDir;\n    this.maxTraces = Math.max(0, config.maxTraces);\n  }\n\n  get isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  // ---- Trace lifecycle ---------------------------------------------------\n\n  startTrace(kind: \"recall\" | \"extraction\", sessionKey?: string, configSnapshot?: Record<string, unknown>): string {\n    if (!this.enabled) return \"\";\n    traceCounter++;\n    const traceId = `t${traceCounter}-${Date.now().toString(36)}`;\n    this.activeTraces.set(traceId, {\n      kind,\n      start: Date.now(),\n      sessionKey,\n      configSnapshot,\n      spans: [],\n      spanStarts: new Map(),\n      parallelGroups: [],\n    });\n    this.latestTraceId = traceId;\n    log.debug(`profiling: started trace ${traceId} kind=${kind}`);\n    return traceId;\n  }\n\n  startSpan(name: string, traceId?: string): void {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n    const offset = Date.now() - t.start;\n    t.spanStarts.set(name, Date.now());\n    log.debug(`profiling: span ${name} started at +${offset}ms (trace=${tid})`);\n  }\n\n  endSpan(name: string, traceId?: string): void {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n    const start = t.spanStarts.get(name);\n    if (start === undefined) return;\n    const duration = Date.now() - start;\n    const startOffset = start - t.start;\n    t.spans.push({ name, startOffsetMs: startOffset, durationMs: duration });\n    t.spanStarts.delete(name);\n    log.debug(`profiling: span ${name} ended ${duration}ms (trace=${tid})`);\n  }\n\n  endTrace(traceId?: string): ProfileTrace | null {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return null;\n\n    // Auto-close any spans still open when the trace finalizes.\n    const now = Date.now();\n    for (const [name, start] of t.spanStarts) {\n      const duration = now - start;\n      const startOffset = start - t.start;\n      t.spans.push({ name, startOffsetMs: startOffset, durationMs: duration });\n      log.debug(`profiling: auto-closed span ${name} at trace end (${duration}ms, trace=${tid})`);\n    }\n    t.spanStarts.clear();\n\n    const trace: ProfileTrace = {\n      ts: new Date().toISOString(),\n      kind: t.kind,\n      traceId: tid,\n      totalMs: Date.now() - t.start,\n      spans: t.spans,\n      configSnapshot: t.configSnapshot,\n    };\n\n    if (t.sessionKey) {\n      trace.sessionKey = t.sessionKey;\n    }\n    if (t.parallelGroups.length > 0) {\n      trace.parallelGroups = t.parallelGroups;\n    }\n\n    // Remove from active map.\n    this.activeTraces.delete(tid);\n\n    if (!this.enabled) {\n      log.debug(\"profiling: trace discarded (disabled)\");\n      return null;\n    }\n\n    // Persist.\n    this.persistTrace(trace);\n\n    // Buffer in memory (FIFO).\n    this.traces.push(trace);\n    if (this.traces.length > this.maxTraces) {\n      this.traces.shift();\n    }\n\n    // Single-flight: if a prune is already running, piggyback on it;\n    // otherwise start one.  This prevents concurrent prunes from racing\n    // on stale directory snapshots.\n    if (!this.prunePromise) {\n      this.prunePromise = this.pruneFiles().finally(() => {\n        this.prunePromise = null;\n      });\n    }\n    log.debug(`profiling: trace ${trace.traceId} finalized totalMs=${trace.totalMs}`);\n    return trace;\n  }\n\n  // ---- Parallel group tracking -------------------------------------------\n\n  startParallelGroup(name: string, traceId?: string): ParallelGroupHandle {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    const startOffsetMs = t ? Date.now() - t.start : 0;\n    return { name, startOffsetMs, traceId: tid };\n  }\n\n  async endParallelGroup(\n    handle: ParallelGroupHandle,\n    members: Array<{ name: string; promise: Promise<unknown> }>,\n  ): Promise<void> {\n    const wallStart = Date.now();\n\n    let nextResolvedIndex = 0;\n    const resolutionOrder = new Map<string, number>();\n\n    const timed = members.map(async (m) => {\n      const t0 = Date.now();\n      try {\n        await m.promise;\n      } catch {\n        // settled — still record order\n      }\n      resolutionOrder.set(m.name, nextResolvedIndex++);\n      return { name: m.name, durationMs: Date.now() - t0 };\n    });\n    const timedResults = await Promise.allSettled(timed);\n\n    const tid = handle.traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n\n    const wallMs = Date.now() - wallStart;\n\n    const groupMembers: ProfileParallelGroupMember[] = members.map((m, i) => {\n      const timedResult = timedResults[i].status === \"fulfilled\"\n        ? timedResults[i].value\n        : { name: m.name, durationMs: wallMs };\n      return {\n        name: timedResult.name,\n        durationMs: timedResult.durationMs,\n        resolvedIndex: resolutionOrder.get(m.name) ?? i,\n      };\n    });\n\n    t.parallelGroups.push({\n      name: handle.name,\n      startOffsetMs: handle.startOffsetMs,\n      wallMs,\n      members: groupMembers,\n    });\n\n    log.debug(`profiling: parallel group ${handle.name} wallMs=${wallMs} (trace=${tid})`);\n  }\n\n  // ---- Query methods -----------------------------------------------------\n\n  getRecentTraces(limit?: number): ProfileTrace[] {\n    if (limit === undefined || limit === Infinity) {\n      return [...this.traces];\n    }\n    if (!Number.isFinite(limit)) {\n      return [];\n    }\n    const n = Math.floor(limit);\n    if (n <= 0) {\n      return [];\n    }\n    return this.traces.slice(-n);\n  }\n\n  getStats(): ProfilingStats {\n    const byKind: Record<string, number[]> = {};\n    const bySpan: Record<string, number[]> = {};\n\n    for (const trace of this.traces) {\n      if (!byKind[trace.kind]) byKind[trace.kind] = [];\n      byKind[trace.kind].push(trace.totalMs);\n\n      for (const span of trace.spans) {\n        if (!bySpan[span.name]) bySpan[span.name] = [];\n        bySpan[span.name].push(span.durationMs);\n      }\n    }\n\n    const result: ProfilingStats = { byKind: {}, bySpan: {} };\n    for (const [k, v] of Object.entries(byKind)) {\n      result.byKind[k] = aggregateStats(v);\n    }\n    for (const [k, v] of Object.entries(bySpan)) {\n      result.bySpan[k] = aggregateStats(v);\n    }\n    return result;\n  }\n\n  identifyBottleneck(): string | null {\n    if (this.traces.length === 0) return null;\n    const latest = this.traces[this.traces.length - 1];\n    if (latest.spans.length === 0) return null;\n    let slowest = latest.spans[0];\n    for (const span of latest.spans) {\n      if (span.durationMs > slowest.durationMs) slowest = span;\n    }\n    return slowest.name;\n  }\n\n  // ---- Persistence -------------------------------------------------------\n\n  private persistTrace(trace: ProfileTrace): void {\n    const filename = `${trace.kind}-${trace.traceId}.jsonl`;\n    const filepath = join(this.storageDir, filename);\n    try {\n      // Created on first persist, never at construction: constructing a\n      // collector (plugin registration, a discovery pass, CLI metadata) must\n      // not touch the operator's memory dir when no trace is ever written.\n      if (!existsSync(this.storageDir)) {\n        mkdirSync(this.storageDir, { recursive: true });\n        log.debug(`profiling: created storage dir ${this.storageDir}`);\n      }\n      writeFileSync(filepath, JSON.stringify(trace) + \"\\n\", \"utf-8\");\n      log.debug(`profiling: persisted ${filename}`);\n    } catch (err) {\n      log.warn(`profiling: failed to persist ${filename}`, err);\n    }\n  }\n\n  async pruneFiles(): Promise<void> {\n    try {\n      const dir = this.storageDir;\n      const entries = await fsp.readdir(dir);\n      const jsonlFiles = entries.filter((f) => f.endsWith(\".jsonl\"));\n      const withMtime = await Promise.all(\n        jsonlFiles.map(async (f) => ({\n          name: f,\n          mtime: (await fsp.stat(join(dir, f))).mtimeMs,\n        })),\n      );\n      const files = withMtime.sort((a, b) => a.mtime - b.mtime).map((f) => f.name);\n\n      while (files.length > this.maxTraces) {\n        const oldest = files.shift()!;\n        await fsp.unlink(join(dir, oldest));\n        log.debug(`profiling: pruned ${oldest}`);\n      }\n    } catch (err) {\n      log.warn(\"profiling: prune failed\", err);\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// ASCII formatter\n// ---------------------------------------------------------------------------\n\nexport function formatProfileTraceAscii(trace: ProfileTrace): string {\n  const lines: string[] = [];\n  const BAR_WIDTH = 40;\n\n  lines.push(`=== Profile: ${trace.kind} ===`);\n  lines.push(`Trace ID : ${trace.traceId}`);\n  lines.push(`Total    : ${trace.totalMs}ms`);\n  if (trace.sessionKey) lines.push(`Session  : ${trace.sessionKey}`);\n  lines.push(\"\");\n\n  // Identify bottleneck.\n  let bottleneckName: string | null = null;\n  if (trace.spans.length > 0) {\n    let slowest = trace.spans[0];\n    for (const s of trace.spans) {\n      if (s.durationMs > slowest.durationMs) slowest = s;\n    }\n    bottleneckName = slowest.name;\n  }\n\n  // Spans.\n  if (trace.spans.length > 0) {\n    const maxDuration = Math.max(...trace.spans.map((s) => s.durationMs), 1);\n    lines.push(\"Spans:\");\n    for (const span of trace.spans) {\n      const barLen = Math.max(1, Math.round((span.durationMs / maxDuration) * BAR_WIDTH));\n      const bar = \"\\u2588\".repeat(barLen);\n      const suffix = span.name === bottleneckName ? \" \\u2190 bottleneck\" : \"\";\n      lines.push(`  ${span.name.padEnd(30)} ${String(span.durationMs).padStart(6)}ms ${bar}${suffix}`);\n    }\n    lines.push(\"\");\n  }\n\n  // Parallel groups.\n  if (trace.parallelGroups && trace.parallelGroups.length > 0) {\n    lines.push(\"Parallel Groups:\");\n    for (const group of trace.parallelGroups) {\n      lines.push(`  ${group.name}:`);\n      lines.push(`    Wall time    : ${group.wallMs}ms`);\n      const efficiency = parallelEfficiency(group);\n      if (efficiency !== null) {\n        lines.push(`    Efficiency   : ${efficiency}%`);\n      }\n      for (const member of group.members) {\n        lines.push(`    [${String(member.resolvedIndex).padStart(2)}] ${member.name.padEnd(28)} ${String(member.durationMs).padStart(6)}ms`);\n      }\n    }\n    lines.push(\"\");\n  }\n\n  lines.push(\"---\");\n  return lines.join(\"\\n\");\n}\n\nfunction parallelEfficiency(group: ProfileParallelGroup): number | null {\n  if (group.members.length <= 1) return null;\n  const idealMs = Math.max(...group.members.map((m) => m.durationMs));\n  if (group.wallMs === 0) return null;\n  return Math.round((idealMs / group.wallMs) * 100);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-EQWEIIKQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/maintenance/dreams-ledger.ts"],"sourcesContent":["/**\n * dreams-ledger.ts — per-phase telemetry for the Dreams consolidation pipeline.\n *\n * Every scheduled or manual phase run appends one JSONL entry to\n *   <memoryDir>/state/dreams-ledger.jsonl\n *\n * The entry records which phase ran, how long it took, and a small\n * itemsProcessed counter so `remnic dreams status` can aggregate the last\n * 24-hour window without scanning the full memory corpus.\n *\n * This module is intentionally side-effect-free on import (no fs calls at\n * module load time) so tests can import it without touching the filesystem.\n */\n\nimport path from \"node:path\";\nimport { createReadStream, type ReadStream } from \"node:fs\";\nimport { appendFile, lstat, mkdir, readdir, readFile } from \"node:fs/promises\";\nimport { createInterface } from \"node:readline\";\n\n// ── Types ─────────────────────────────────────────────────────────────────────\n\n/** The three named phases of the Dreams consolidation pipeline. */\nexport type DreamsPhase = \"lightSleep\" | \"rem\" | \"deepSleep\";\n\n/**\n * One entry written to the dreams ledger for every phase run.\n * Older entries that predate this field simply won't have it (no backfill).\n */\nexport interface DreamsLedgerEntry {\n  /** Schema version — always 1 for entries written by this module. */\n  schemaVersion: 1;\n  /** ISO-8601 timestamp when the phase run started. */\n  startedAt: string;\n  /** ISO-8601 timestamp when the phase run completed. */\n  completedAt: string;\n  /** Wall-clock duration in milliseconds. */\n  durationMs: number;\n  /**\n   * Which Dreams phase this entry represents.\n   * - `lightSleep` — recent activity scoring + clustering\n   * - `rem`        — cross-session synthesis, supersession, consolidation\n   * - `deepSleep`  — tier migration, page-version snapshots, archive\n   */\n  phase: DreamsPhase;\n  /** How many memory items were evaluated (scored / clustered / migrated). */\n  itemsProcessed: number;\n  /** Whether this was a dry-run (no writes committed). */\n  dryRun: boolean;\n  /**\n   * How the phase was triggered.\n   * - `scheduled` — invoked by the governance cron or orchestrator maintenance pass\n   * - `manual`    — invoked via `remnic dreams run`\n   */\n  trigger: \"scheduled\" | \"manual\";\n  /** Free-form notes for debugging (optional, never required). */\n  notes?: string;\n}\n\n/** Aggregated stats for a single phase over a time window. */\nexport interface DreamsPhaseStatus {\n  phase: DreamsPhase;\n  /** Number of phase runs in the window. */\n  runCount: number;\n  /** Total wall-clock milliseconds across all runs in the window. */\n  totalDurationMs: number;\n  /** Total items processed across all runs in the window. */\n  totalItemsProcessed: number;\n  /** ISO-8601 timestamp of the most recent completed run, or null if none. */\n  lastRunAt: string | null;\n  /** Duration of the most recent run in ms, or null if none. */\n  lastDurationMs: number | null;\n}\n\n/** Shape returned by `getDreamsStatus` — the canonical telemetry response. */\nexport interface DreamsStatusResult {\n  /** ISO-8601 start of the query window (inclusive). */\n  windowStart: string;\n  /** ISO-8601 end of the query window (exclusive). */\n  windowEnd: string;\n  /** Per-phase summaries, always present for all three phases. */\n  phases: {\n    lightSleep: DreamsPhaseStatus;\n    rem: DreamsPhaseStatus;\n    deepSleep: DreamsPhaseStatus;\n  };\n}\n\n// ── Path helpers ──────────────────────────────────────────────────────────────\n\nexport function dreamsLedgerPath(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"dreams-ledger.jsonl\");\n}\n\n// ── Writer ────────────────────────────────────────────────────────────────────\n\n/**\n * Append a single entry to the dreams ledger.\n * Creates the file (and its parent directory) if needed.\n * Uses `appendFile` (O_APPEND) so concurrent callers never overwrite each other.\n */\nexport async function appendDreamsLedgerEntry(\n  memoryDir: string,\n  entry: DreamsLedgerEntry,\n): Promise<void> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  await mkdir(path.dirname(ledgerPath), { recursive: true });\n  await appendFile(ledgerPath, JSON.stringify(entry) + \"\\n\", \"utf-8\");\n}\n\n// ── Reader ────────────────────────────────────────────────────────────────────\n\n/**\n * Parse and validate one ledger line into a `DreamsLedgerEntry`, or `null` when\n * blank/malformed/incomplete. Shared by the streaming reader and the windowed\n * status aggregator so both apply the identical fail-open guard.\n */\nfunction parseDreamsLedgerLine(line: string): DreamsLedgerEntry | null {\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n  let parsed: Record<string, unknown>;\n  try {\n    const raw = JSON.parse(trimmed);\n    if (typeof raw !== \"object\" || raw === null) return null;\n    parsed = raw as Record<string, unknown>;\n  } catch {\n    return null; // Malformed JSON — skip (fail-open).\n  }\n\n  // Required, strongly-typed fields. A row missing or mistyping any of these is\n  // not a usable telemetry entry.\n  const phase = parsed.phase;\n  if (phase !== \"lightSleep\" && phase !== \"rem\" && phase !== \"deepSleep\") return null;\n  if (\n    typeof parsed.startedAt !== \"string\" ||\n    typeof parsed.completedAt !== \"string\" ||\n    typeof parsed.durationMs !== \"number\" ||\n    typeof parsed.itemsProcessed !== \"number\"\n  ) {\n    return null;\n  }\n\n  // Optional fields: absence is tolerated (older entries predate them, no\n  // backfill), but a PRESENT value with the wrong type/value marks the row\n  // malformed and skips it — never silently coerced to a default (issue #1910).\n  if (\"schemaVersion\" in parsed && parsed.schemaVersion !== 1) return null;\n  if (\"dryRun\" in parsed && typeof parsed.dryRun !== \"boolean\") return null;\n  if (\"trigger\" in parsed && parsed.trigger !== \"manual\" && parsed.trigger !== \"scheduled\") {\n    return null;\n  }\n\n  return {\n    schemaVersion: 1,\n    startedAt: parsed.startedAt,\n    completedAt: parsed.completedAt,\n    durationMs: parsed.durationMs,\n    phase,\n    itemsProcessed: parsed.itemsProcessed,\n    dryRun: parsed.dryRun === true,\n    trigger: parsed.trigger === \"manual\" ? \"manual\" : \"scheduled\",\n    notes: typeof parsed.notes === \"string\" ? parsed.notes : undefined,\n  };\n}\n\n/**\n * Stream the dreams ledger line-by-line. The ledger is plaintext `appendFile`\n * (never encrypted), so a raw line stream is safe at any size — heap stays\n * O(1) in the file, unlike the previous whole-file `readFile` + `split`.\n * Yields nothing when the ledger does not exist yet.\n */\nexport async function* streamDreamsLedgerLines(memoryDir: string): AsyncGenerator<string> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  let input: ReadStream;\n  try {\n    input = createReadStream(ledgerPath, { encoding: \"utf8\" });\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  }\n  const rl = createInterface({ input, crlfDelay: Infinity });\n  try {\n    for await (const line of rl) yield line;\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  } finally {\n    // Close the readline interface AND destroy the underlying stream. When a\n    // consumer stops early (e.g. `getDreamsStatus` breaks out), the generator's\n    // `.return()` runs this finally; `rl.close()` alone leaves the file\n    // descriptor open, so destroy the stream to release it (issue #1910).\n    rl.close();\n    input.destroy();\n  }\n}\n\n/**\n * Parse all valid `DreamsLedgerEntry` rows from the ledger file. Thin wrapper\n * over the line stream so any caller that genuinely needs every row still\n * works; `getDreamsStatus` streams directly and filters in-window instead.\n * Malformed lines are silently skipped (resilience over strictness for\n * telemetry).\n */\nexport async function readDreamsLedgerEntries(memoryDir: string): Promise<DreamsLedgerEntry[]> {\n  const entries: DreamsLedgerEntry[] = [];\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (entry) entries.push(entry);\n  }\n  return entries;\n}\n\n// ── Aggregator ────────────────────────────────────────────────────────────────\n\nconst ALL_PHASES: DreamsPhase[] = [\"lightSleep\", \"rem\", \"deepSleep\"];\nconst MAX_WINDOW_HOURS = 24 * 365 * 100;\n\nexport function normalizeDreamsStatusWindowHours(value: unknown, fallback = 24): number {\n  const raw = value === undefined || value === null ? fallback : value;\n  if (\n    typeof raw !== \"number\" ||\n    !Number.isFinite(raw) ||\n    !Number.isInteger(raw) ||\n    raw < 1 ||\n    raw > MAX_WINDOW_HOURS\n  ) {\n    throw new RangeError(`windowHours must be a positive integer no greater than ${MAX_WINDOW_HOURS}`);\n  }\n  return raw;\n}\n\n/**\n * Build per-phase 24-hour summary.\n *\n * @param memoryDir   The memory directory (parent of `state/`).\n * @param windowHours How many hours to look back (default 24).\n * @param now         Reference time (default `new Date()`).\n */\nexport async function getDreamsStatus(\n  memoryDir: string,\n  windowHours = 24,\n  now: Date = new Date(),\n): Promise<DreamsStatusResult> {\n  const boundedWindowHours = normalizeDreamsStatusWindowHours(windowHours);\n  const nowMs = now.getTime();\n  if (!Number.isFinite(nowMs)) {\n    throw new RangeError(\"now must be a valid Date\");\n  }\n  const windowMs = boundedWindowHours * 60 * 60 * 1000;\n  const windowStart = new Date(nowMs - windowMs);\n  const windowEnd = now;\n  if (!Number.isFinite(windowStart.getTime())) {\n    throw new RangeError(\"windowHours produces an invalid status window\");\n  }\n\n  const windowStartMs = windowStart.getTime();\n  const windowEndMs = windowEnd.getTime();\n\n  const statusMap = new Map<DreamsPhase, DreamsPhaseStatus>();\n  for (const phase of ALL_PHASES) {\n    statusMap.set(phase, {\n      phase,\n      runCount: 0,\n      totalDurationMs: 0,\n      totalItemsProcessed: 0,\n      lastRunAt: null,\n      lastDurationMs: null,\n    });\n  }\n\n  // Stream the ledger and aggregate every in-window row inline, so heap use is\n  // O(number of phases) regardless of window or file size (issue #1910) — no\n  // per-row array and no row cap, so a large in-window window is still counted\n  // in full rather than truncated.\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (!entry) continue;\n    const ts = Date.parse(entry.completedAt);\n    if (!Number.isFinite(ts) || ts < windowStartMs || ts >= windowEndMs) continue;\n    const status = statusMap.get(entry.phase);\n    if (!status) continue;\n    status.runCount += 1;\n    status.totalDurationMs += entry.durationMs;\n    status.totalItemsProcessed += entry.itemsProcessed;\n    // Track the most recent run (by completedAt).\n    if (status.lastRunAt === null || ts > Date.parse(status.lastRunAt)) {\n      status.lastRunAt = entry.completedAt;\n      status.lastDurationMs = entry.durationMs;\n    }\n  }\n\n  return {\n    windowStart: windowStart.toISOString(),\n    windowEnd: windowEnd.toISOString(),\n    phases: {\n      lightSleep: statusMap.get(\"lightSleep\")!,\n      rem: statusMap.get(\"rem\")!,\n      deepSleep: statusMap.get(\"deepSleep\")!,\n    },\n  };\n}\n\n// ── Phase runner (PR 4/4: manual invocation) ─────────────────────────────────\n\nexport interface DreamsRunOptions {\n  memoryDir: string;\n  phase: DreamsPhase;\n  dryRun?: boolean;\n}\n\n/** Public result shape — identical to what HTTP, MCP, and CLI surfaces expose. */\nexport interface DreamsRunResult {\n  phase: DreamsPhase;\n  dryRun: boolean;\n  durationMs: number;\n  itemsProcessed: number;\n  notes?: string;\n}\n\n/** Internal result shape returned by `runDreamsPhase` — includes the raw ledger entry. */\nexport interface DreamsRunResultInternal extends DreamsRunResult {\n  ledgerEntry?: DreamsLedgerEntry;\n}\n\nexport async function recordDreamsPhaseRun(options: {\n  memoryDir: string;\n  phase: DreamsPhase;\n  trigger: DreamsLedgerEntry[\"trigger\"];\n  dryRun?: boolean;\n  itemsProcessed: number;\n  notes?: string;\n  startedAt?: string;\n  completedAt?: string;\n}): Promise<DreamsLedgerEntry> {\n  const startedAt = options.startedAt ?? new Date().toISOString();\n  const completedAt = options.completedAt ?? new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  const ledgerEntry: DreamsLedgerEntry = {\n    schemaVersion: 1,\n    startedAt,\n    completedAt,\n    durationMs: Number.isFinite(durationMs) ? durationMs : 0,\n    phase: options.phase,\n    itemsProcessed: Math.max(0, Math.floor(options.itemsProcessed)),\n    dryRun: options.dryRun === true,\n    trigger: options.trigger,\n    notes: options.notes,\n  };\n  if (!ledgerEntry.dryRun) {\n    await appendDreamsLedgerEntry(options.memoryDir, ledgerEntry);\n  }\n  return ledgerEntry;\n}\n\n/**\n * Manually invoke a single Dreams phase pass.\n *\n * For light sleep and REM: runs a lightweight scan against the observation\n * ledger and returns a count of items that would be (or were, if not dry-run)\n * processed.  The actual heavy consolidation is long-running and orchestrator-\n * bound; the manual surface delegates to existing ledger utilities and returns\n * the phase telemetry so callers get the same shape as a scheduled run.\n *\n * For deep sleep: delegates to the memory governance run (shadow mode when\n * dryRun is true, apply mode otherwise).\n */\nexport async function runDreamsPhase(\n  options: DreamsRunOptions,\n  governanceRunner?: (opts: { memoryDir: string; dryRun: boolean }) => Promise<{ scannedMemories: number; appliedActionCount: number; notes?: string }>,\n  phaseRunner?: (opts: { memoryDir: string; phase: Exclude<DreamsPhase, \"deepSleep\"> }) => Promise<{ itemsProcessed: number; notes?: string }>,\n): Promise<DreamsRunResultInternal> {\n  const { memoryDir, phase, dryRun = false } = options;\n  const startedAt = new Date().toISOString();\n\n  let itemsProcessed = 0;\n  let notes: string | undefined;\n\n  if (phase === \"lightSleep\") {\n    // Dry-run light sleep counts recent observation entries as a preview.\n    // Live runs must be backed by the orchestrator phase runner so the command\n    // never reports success without executing the phase.\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"light-sleep manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `scored ${itemsProcessed} memories`;\n    } else {\n      // Light sleep: count observation ledger entries from the last 24h as a\n      // proxy for \"items scored\". The live value-scoring pass runs through the\n      // phase runner above.\n      try {\n        const ledgerPath = path.join(memoryDir, \"state\", \"observation-ledger\", \"rebuilt-observations.jsonl\");\n        let raw = \"\";\n        try {\n          raw = await readFile(ledgerPath, \"utf-8\");\n        } catch {\n          // No ledger yet — zero items.\n        }\n        const lines = raw.split(\"\\n\").filter((l) => l.trim().length > 0);\n        const nowMs = Date.now();\n        const cutoff = nowMs - 24 * 60 * 60 * 1000;\n        itemsProcessed = lines.filter((line) => {\n          try {\n            const obj = JSON.parse(line) as {\n              hour?: string;\n              timestamp?: string;\n              ts?: string;\n            };\n            const timestamp = typeof obj.hour === \"string\"\n              ? obj.hour\n              : typeof obj.ts === \"string\"\n                ? obj.ts\n                : typeof obj.timestamp === \"string\"\n                  ? obj.timestamp\n                  : null;\n            if (!timestamp) return false;\n            const ms = Date.parse(timestamp);\n            return Number.isFinite(ms) && ms >= cutoff && ms < nowMs;\n          } catch {\n            return false;\n          }\n        }).length;\n        notes = `dry-run: would score ${itemsProcessed} observation entries`;\n      } catch (err) {\n        throw new Error(`light-sleep scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else if (phase === \"rem\") {\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"REM manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `REM pass assessed ${itemsProcessed} memories`;\n    } else {\n      // REM dry-runs estimate candidates without synthesizing or archiving.\n      try {\n        const stateFilePath = path.join(memoryDir, \"state\", \"semantic-consolidation-last-run.json\");\n        let lastRunAt: string | null = null;\n        try {\n          const stateRaw = await readFile(stateFilePath, \"utf-8\");\n          const stateData = JSON.parse(stateRaw) as { lastRunAt?: string };\n          lastRunAt = stateData.lastRunAt ?? null;\n        } catch {\n          // No state file — never run.\n        }\n        const memFiles = await listMemoryFiles(memoryDir);\n        itemsProcessed = memFiles.length;\n        notes = `dry-run: ${itemsProcessed} memories would enter REM consolidation pass${lastRunAt ? ` (last run: ${lastRunAt})` : \" (never run)\"}`;\n      } catch (err) {\n        throw new Error(`REM scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else {\n    // deep sleep\n    if (governanceRunner) {\n      try {\n        const result = await governanceRunner({ memoryDir, dryRun });\n        itemsProcessed = result.scannedMemories;\n        notes = result.notes ?? (dryRun ? `dry-run: ${result.appliedActionCount} actions proposed` : `${result.appliedActionCount} actions applied`);\n      } catch (err) {\n        throw new Error(`deep-sleep governance run failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    } else {\n      // Fallback: count memory files.\n      const memFiles = await listMemoryFiles(memoryDir);\n      itemsProcessed = memFiles.length;\n      notes = dryRun\n        ? `dry-run: ${itemsProcessed} memories eligible for deep-sleep governance`\n        : `assessed ${itemsProcessed} memories for deep-sleep governance`;\n    }\n  }\n\n  const completedAt = new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  let ledgerEntry: DreamsLedgerEntry | undefined;\n  try {\n    ledgerEntry = await recordDreamsPhaseRun({\n      memoryDir,\n      startedAt,\n      completedAt,\n      phase,\n      itemsProcessed,\n      dryRun,\n      trigger: \"manual\",\n      notes,\n    });\n  } catch {\n    // Telemetry is best-effort: the phase work has already completed.\n  }\n\n  return {\n    phase,\n    dryRun,\n    durationMs: ledgerEntry?.durationMs ?? durationMs,\n    itemsProcessed,\n    notes,\n    ledgerEntry,\n  };\n}\n\n// ── Shared governance result mapping ──────────────────────────────────────────\n\nexport function summarizeGovernanceResultForDreams(\n  govResult: {\n    summary?: { scannedMemories?: number };\n    proposedActions: unknown[];\n    appliedActions: unknown[];\n    reviewQueue: unknown[];\n  },\n  dryRun: boolean,\n): { scannedMemories: number; appliedActionCount: number; notes?: string } {\n  const proposedCount = govResult.proposedActions.length;\n  const appliedCount = govResult.appliedActions.length;\n  const scannedCount =\n    typeof govResult.summary?.scannedMemories === \"number\" &&\n    Number.isFinite(govResult.summary.scannedMemories)\n      ? Math.max(0, Math.floor(govResult.summary.scannedMemories))\n      : govResult.reviewQueue.length;\n  return {\n    scannedMemories: scannedCount,\n    appliedActionCount: appliedCount,\n    notes: dryRun\n      ? `shadow mode: ${proposedCount} actions proposed`\n      : `applied ${appliedCount} actions`,\n  };\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────────────\n\nasync function listMemoryFiles(memoryDir: string): Promise<string[]> {\n  const out: string[] = [];\n  try {\n    const root = await lstat(memoryDir);\n    if (root.isSymbolicLink()) {\n      throw new Error(`memoryDir must not be a symlink: ${memoryDir}`);\n    }\n    if (!root.isDirectory()) return out;\n  } catch (err) {\n    if (err instanceof Error && /must not be a symlink/.test(err.message)) {\n      throw err;\n    }\n    return out;\n  }\n\n  async function walk(dir: string): Promise<void> {\n    let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean; isSymbolicLink(): boolean }>;\n    try {\n      entries = (await readdir(dir, { withFileTypes: true })) as typeof entries;\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.isSymbolicLink()) continue;\n      const full = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        // Skip state/ and archive/ subdirs.\n        if (\n          entry.name === \"state\" ||\n          entry.name === \"archive\" ||\n          entry.name === \"namespaces\" ||\n          entry.name === \".git\"\n        ) continue;\n        await walk(full);\n      } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n        out.push(full);\n      }\n    }\n  }\n\n  await walk(memoryDir);\n  return out;\n}\n"],"mappings":";AAcA,OAAO,UAAU;AACjB,SAAS,wBAAyC;AAClD,SAAS,YAAY,OAAO,OAAO,SAAS,gBAAgB;AAC5D,SAAS,uBAAuB;AAwEzB,SAAS,iBAAiB,WAA2B;AAC1D,SAAO,KAAK,KAAK,WAAW,SAAS,qBAAqB;AAC5D;AASA,eAAsB,wBACpB,WACA,OACe;AACf,QAAM,aAAa,iBAAiB,SAAS;AAC7C,QAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,QAAM,WAAW,YAAY,KAAK,UAAU,KAAK,IAAI,MAAM,OAAO;AACpE;AASA,SAAS,sBAAsB,MAAwC;AACrE,QAAM,UAAU,KAAK,KAAK;AAC1B,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,KAAK,MAAM,OAAO;AAC9B,QAAI,OAAO,QAAQ,YAAY,QAAQ,KAAM,QAAO;AACpD,aAAS;AAAA,EACX,QAAQ;AACN,WAAO;AAAA,EACT;AAIA,QAAM,QAAQ,OAAO;AACrB,MAAI,UAAU,gBAAgB,UAAU,SAAS,UAAU,YAAa,QAAO;AAC/E,MACE,OAAO,OAAO,cAAc,YAC5B,OAAO,OAAO,gBAAgB,YAC9B,OAAO,OAAO,eAAe,YAC7B,OAAO,OAAO,mBAAmB,UACjC;AACA,WAAO;AAAA,EACT;AAKA,MAAI,mBAAmB,UAAU,OAAO,kBAAkB,EAAG,QAAO;AACpE,MAAI,YAAY,UAAU,OAAO,OAAO,WAAW,UAAW,QAAO;AACrE,MAAI,aAAa,UAAU,OAAO,YAAY,YAAY,OAAO,YAAY,aAAa;AACxF,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,eAAe;AAAA,IACf,WAAW,OAAO;AAAA,IAClB,aAAa,OAAO;AAAA,IACpB,YAAY,OAAO;AAAA,IACnB;AAAA,IACA,gBAAgB,OAAO;AAAA,IACvB,QAAQ,OAAO,WAAW;AAAA,IAC1B,SAAS,OAAO,YAAY,WAAW,WAAW;AAAA,IAClD,OAAO,OAAO,OAAO,UAAU,WAAW,OAAO,QAAQ;AAAA,EAC3D;AACF;AAQA,gBAAuB,wBAAwB,WAA2C;AACxF,QAAM,aAAa,iBAAiB,SAAS;AAC7C,MAAI;AACJ,MAAI;AACF,YAAQ,iBAAiB,YAAY,EAAE,UAAU,OAAO,CAAC;AAAA,EAC3D,SAAS,KAAK;AACZ,QAAK,IAA8B,SAAS,SAAU;AACtD,UAAM;AAAA,EACR;AACA,QAAM,KAAK,gBAAgB,EAAE,OAAO,WAAW,SAAS,CAAC;AACzD,MAAI;AACF,qBAAiB,QAAQ,GAAI,OAAM;AAAA,EACrC,SAAS,KAAK;AACZ,QAAK,IAA8B,SAAS,SAAU;AACtD,UAAM;AAAA,EACR,UAAE;AAKA,OAAG,MAAM;AACT,UAAM,QAAQ;AAAA,EAChB;AACF;AASA,eAAsB,wBAAwB,WAAiD;AAC7F,QAAM,UAA+B,CAAC;AACtC,mBAAiB,QAAQ,wBAAwB,SAAS,GAAG;AAC3D,UAAM,QAAQ,sBAAsB,IAAI;AACxC,QAAI,MAAO,SAAQ,KAAK,KAAK;AAAA,EAC/B;AACA,SAAO;AACT;AAIA,IAAM,aAA4B,CAAC,cAAc,OAAO,WAAW;AACnE,IAAM,mBAAmB,KAAK,MAAM;AAE7B,SAAS,iCAAiC,OAAgB,WAAW,IAAY;AACtF,QAAM,MAAM,UAAU,UAAa,UAAU,OAAO,WAAW;AAC/D,MACE,OAAO,QAAQ,YACf,CAAC,OAAO,SAAS,GAAG,KACpB,CAAC,OAAO,UAAU,GAAG,KACrB,MAAM,KACN,MAAM,kBACN;AACA,UAAM,IAAI,WAAW,0DAA0D,gBAAgB,EAAE;AAAA,EACnG;AACA,SAAO;AACT;AASA,eAAsB,gBACpB,WACA,cAAc,IACd,MAAY,oBAAI,KAAK,GACQ;AAC7B,QAAM,qBAAqB,iCAAiC,WAAW;AACvE,QAAM,QAAQ,IAAI,QAAQ;AAC1B,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,WAAW,0BAA0B;AAAA,EACjD;AACA,QAAM,WAAW,qBAAqB,KAAK,KAAK;AAChD,QAAM,cAAc,IAAI,KAAK,QAAQ,QAAQ;AAC7C,QAAM,YAAY;AAClB,MAAI,CAAC,OAAO,SAAS,YAAY,QAAQ,CAAC,GAAG;AAC3C,UAAM,IAAI,WAAW,+CAA+C;AAAA,EACtE;AAEA,QAAM,gBAAgB,YAAY,QAAQ;AAC1C,QAAM,cAAc,UAAU,QAAQ;AAEtC,QAAM,YAAY,oBAAI,IAAoC;AAC1D,aAAW,SAAS,YAAY;AAC9B,cAAU,IAAI,OAAO;AAAA,MACnB;AAAA,MACA,UAAU;AAAA,MACV,iBAAiB;AAAA,MACjB,qBAAqB;AAAA,MACrB,WAAW;AAAA,MACX,gBAAgB;AAAA,IAClB,CAAC;AAAA,EACH;AAMA,mBAAiB,QAAQ,wBAAwB,SAAS,GAAG;AAC3D,UAAM,QAAQ,sBAAsB,IAAI;AACxC,QAAI,CAAC,MAAO;AACZ,UAAM,KAAK,KAAK,MAAM,MAAM,WAAW;AACvC,QAAI,CAAC,OAAO,SAAS,EAAE,KAAK,KAAK,iBAAiB,MAAM,YAAa;AACrE,UAAM,SAAS,UAAU,IAAI,MAAM,KAAK;AACxC,QAAI,CAAC,OAAQ;AACb,WAAO,YAAY;AACnB,WAAO,mBAAmB,MAAM;AAChC,WAAO,uBAAuB,MAAM;AAEpC,QAAI,OAAO,cAAc,QAAQ,KAAK,KAAK,MAAM,OAAO,SAAS,GAAG;AAClE,aAAO,YAAY,MAAM;AACzB,aAAO,iBAAiB,MAAM;AAAA,IAChC;AAAA,EACF;AAEA,SAAO;AAAA,IACL,aAAa,YAAY,YAAY;AAAA,IACrC,WAAW,UAAU,YAAY;AAAA,IACjC,QAAQ;AAAA,MACN,YAAY,UAAU,IAAI,YAAY;AAAA,MACtC,KAAK,UAAU,IAAI,KAAK;AAAA,MACxB,WAAW,UAAU,IAAI,WAAW;AAAA,IACtC;AAAA,EACF;AACF;AAwBA,eAAsB,qBAAqB,SASZ;AAC7B,QAAM,YAAY,QAAQ,cAAa,oBAAI,KAAK,GAAE,YAAY;AAC9D,QAAM,cAAc,QAAQ,gBAAe,oBAAI,KAAK,GAAE,YAAY;AAClE,QAAM,aAAa,KAAK,IAAI,GAAG,KAAK,MAAM,WAAW,IAAI,KAAK,MAAM,SAAS,CAAC;AAC9E,QAAM,cAAiC;AAAA,IACrC,eAAe;AAAA,IACf;AAAA,IACA;AAAA,IACA,YAAY,OAAO,SAAS,UAAU,IAAI,aAAa;AAAA,IACvD,OAAO,QAAQ;AAAA,IACf,gBAAgB,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,cAAc,CAAC;AAAA,IAC9D,QAAQ,QAAQ,WAAW;AAAA,IAC3B,SAAS,QAAQ;AAAA,IACjB,OAAO,QAAQ;AAAA,EACjB;AACA,MAAI,CAAC,YAAY,QAAQ;AACvB,UAAM,wBAAwB,QAAQ,WAAW,WAAW;AAAA,EAC9D;AACA,SAAO;AACT;AAcA,eAAsB,eACpB,SACA,kBACA,aACkC;AAClC,QAAM,EAAE,WAAW,OAAO,SAAS,MAAM,IAAI;AAC7C,QAAM,aAAY,oBAAI,KAAK,GAAE,YAAY;AAEzC,MAAI,iBAAiB;AACrB,MAAI;AAEJ,MAAI,UAAU,cAAc;AAI1B,QAAI,CAAC,QAAQ;AACX,UAAI,CAAC,aAAa;AAChB,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE;AACA,YAAM,SAAS,MAAM,YAAY,EAAE,WAAW,MAAM,CAAC;AACrD,uBAAiB,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,cAAc,CAAC;AAC9D,cAAQ,OAAO,SAAS,UAAU,cAAc;AAAA,IAClD,OAAO;AAIL,UAAI;AACF,cAAM,aAAa,KAAK,KAAK,WAAW,SAAS,sBAAsB,4BAA4B;AACnG,YAAI,MAAM;AACV,YAAI;AACF,gBAAM,MAAM,SAAS,YAAY,OAAO;AAAA,QAC1C,QAAQ;AAAA,QAER;AACA,cAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC;AAC/D,cAAM,QAAQ,KAAK,IAAI;AACvB,cAAM,SAAS,QAAQ,KAAK,KAAK,KAAK;AACtC,yBAAiB,MAAM,OAAO,CAAC,SAAS;AACtC,cAAI;AACF,kBAAM,MAAM,KAAK,MAAM,IAAI;AAK3B,kBAAM,YAAY,OAAO,IAAI,SAAS,WAClC,IAAI,OACJ,OAAO,IAAI,OAAO,WAChB,IAAI,KACJ,OAAO,IAAI,cAAc,WACvB,IAAI,YACJ;AACR,gBAAI,CAAC,UAAW,QAAO;AACvB,kBAAM,KAAK,KAAK,MAAM,SAAS;AAC/B,mBAAO,OAAO,SAAS,EAAE,KAAK,MAAM,UAAU,KAAK;AAAA,UACrD,QAAQ;AACN,mBAAO;AAAA,UACT;AAAA,QACF,CAAC,EAAE;AACH,gBAAQ,wBAAwB,cAAc;AAAA,MAChD,SAAS,KAAK;AACZ,cAAM,IAAI,MAAM,4BAA4B,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,EAAE;AAAA,MAChG;AAAA,IACF;AAAA,EACF,WAAW,UAAU,OAAO;AAC1B,QAAI,CAAC,QAAQ;AACX,UAAI,CAAC,aAAa;AAChB,cAAM,IAAI,MAAM,wCAAwC;AAAA,MAC1D;AACA,YAAM,SAAS,MAAM,YAAY,EAAE,WAAW,MAAM,CAAC;AACrD,uBAAiB,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,cAAc,CAAC;AAC9D,cAAQ,OAAO,SAAS,qBAAqB,cAAc;AAAA,IAC7D,OAAO;AAEL,UAAI;AACF,cAAM,gBAAgB,KAAK,KAAK,WAAW,SAAS,sCAAsC;AAC1F,YAAI,YAA2B;AAC/B,YAAI;AACF,gBAAM,WAAW,MAAM,SAAS,eAAe,OAAO;AACtD,gBAAM,YAAY,KAAK,MAAM,QAAQ;AACrC,sBAAY,UAAU,aAAa;AAAA,QACrC,QAAQ;AAAA,QAER;AACA,cAAM,WAAW,MAAM,gBAAgB,SAAS;AAChD,yBAAiB,SAAS;AAC1B,gBAAQ,YAAY,cAAc,+CAA+C,YAAY,eAAe,SAAS,MAAM,cAAc;AAAA,MAC3I,SAAS,KAAK;AACZ,cAAM,IAAI,MAAM,oBAAoB,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,EAAE;AAAA,MACxF;AAAA,IACF;AAAA,EACF,OAAO;AAEL,QAAI,kBAAkB;AACpB,UAAI;AACF,cAAM,SAAS,MAAM,iBAAiB,EAAE,WAAW,OAAO,CAAC;AAC3D,yBAAiB,OAAO;AACxB,gBAAQ,OAAO,UAAU,SAAS,YAAY,OAAO,kBAAkB,sBAAsB,GAAG,OAAO,kBAAkB;AAAA,MAC3H,SAAS,KAAK;AACZ,cAAM,IAAI,MAAM,qCAAqC,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,EAAE;AAAA,MACzG;AAAA,IACF,OAAO;AAEL,YAAM,WAAW,MAAM,gBAAgB,SAAS;AAChD,uBAAiB,SAAS;AAC1B,cAAQ,SACJ,YAAY,cAAc,iDAC1B,YAAY,cAAc;AAAA,IAChC;AAAA,EACF;AAEA,QAAM,eAAc,oBAAI,KAAK,GAAE,YAAY;AAC3C,QAAM,aAAa,KAAK,IAAI,GAAG,KAAK,MAAM,WAAW,IAAI,KAAK,MAAM,SAAS,CAAC;AAC9E,MAAI;AACJ,MAAI;AACF,kBAAc,MAAM,qBAAqB;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,MACT;AAAA,IACF,CAAC;AAAA,EACH,QAAQ;AAAA,EAER;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,YAAY,aAAa,cAAc;AAAA,IACvC;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAIO,SAAS,mCACd,WAMA,QACyE;AACzE,QAAM,gBAAgB,UAAU,gBAAgB;AAChD,QAAM,eAAe,UAAU,eAAe;AAC9C,QAAM,eACJ,OAAO,UAAU,SAAS,oBAAoB,YAC9C,OAAO,SAAS,UAAU,QAAQ,eAAe,IAC7C,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,QAAQ,eAAe,CAAC,IACzD,UAAU,YAAY;AAC5B,SAAO;AAAA,IACL,iBAAiB;AAAA,IACjB,oBAAoB;AAAA,IACpB,OAAO,SACH,gBAAgB,aAAa,sBAC7B,WAAW,YAAY;AAAA,EAC7B;AACF;AAIA,eAAe,gBAAgB,WAAsC;AACnE,QAAM,MAAgB,CAAC;AACvB,MAAI;AACF,UAAM,OAAO,MAAM,MAAM,SAAS;AAClC,QAAI,KAAK,eAAe,GAAG;AACzB,YAAM,IAAI,MAAM,oCAAoC,SAAS,EAAE;AAAA,IACjE;AACA,QAAI,CAAC,KAAK,YAAY,EAAG,QAAO;AAAA,EAClC,SAAS,KAAK;AACZ,QAAI,eAAe,SAAS,wBAAwB,KAAK,IAAI,OAAO,GAAG;AACrE,YAAM;AAAA,IACR;AACA,WAAO;AAAA,EACT;AAEA,iBAAe,KAAK,KAA4B;AAC9C,QAAI;AACJ,QAAI;AACF,gBAAW,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAAA,IACvD,QAAQ;AACN;AAAA,IACF;AACA,eAAW,SAAS,SAAS;AAC3B,UAAI,MAAM,eAAe,EAAG;AAC5B,YAAM,OAAO,KAAK,KAAK,KAAK,MAAM,IAAI;AACtC,UAAI,MAAM,YAAY,GAAG;AAEvB,YACE,MAAM,SAAS,WACf,MAAM,SAAS,aACf,MAAM,SAAS,gBACf,MAAM,SAAS,OACf;AACF,cAAM,KAAK,IAAI;AAAA,MACjB,WAAW,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,KAAK,GAAG;AACvD,YAAI,KAAK,IAAI;AAAA,MACf;AAAA,IACF;AAAA,EACF;AAEA,QAAM,KAAK,SAAS;AACpB,SAAO;AACT;","names":[]}

package/dist/chunk-HT2C4EXO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/consolidation-provenance-check.ts"],"sourcesContent":["/**\n * Consolidation provenance integrity check (issue #561 PR 4).\n *\n * Validates that every memory carrying consolidation provenance frontmatter\n * (`derived_from`, `derived_via`) resolves to real data:\n *\n *   - Each `derived_from` entry `\"<path>:<version>\"` must name a\n *     page-version snapshot that exists on disk (via the sidecar layout\n *     documented in `page-versioning.ts`).\n *   - Each `derived_via` must be one of the known\n *     `ConsolidationOperator` values — malformed values are surfaced as\n *     warnings rather than crashes so legacy or future operators survive a\n *     rollback.\n *\n * Non-fatal: every failure renders a warning with the offending file path\n * and a human-readable reason.  Integrity problems are informational for\n * now — we do not auto-heal or archive broken memories.\n */\n\nimport path from \"node:path\";\nimport { lstat, readdir, readFile, realpath, stat } from \"node:fs/promises\";\nimport { constants as fsConstants } from \"node:fs\";\nimport type { StorageManager } from \"./storage.js\";\nimport {\n  DERIVED_FROM_MEMORY_ID_RE,\n  isConsolidationOperator,\n} from \"./consolidation-operator.js\";\n// Import the canonical `sidecarKey` from page-versioning (PR #634\n// review, cursor Medium) so a future key-format change stays in\n// lock-step with the doctor scan.\nimport { sidecarKey } from \"./page-versioning.js\";\nimport { RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\n\n/**\n * Regex to spot a `derived_via: <value>` line in the raw YAML frontmatter\n * between the opening and first closing `---` delimiters.  We use the raw\n * text rather than the parsed `frontmatter.derived_via` because the\n * read-path parser coerces unknown values back to `undefined` — that\n * would silently hide corrupted-or-future operators from the doctor scan\n * (PR #634 review feedback, codex P2).\n */\n// Allow empty capture groups so truncated/blank `derived_via:` and\n// `derived_from:` lines (key present, no value) are distinguishable\n// from \"key missing entirely\" (regex returns null).  Optional\n// leading whitespace accepts indented keys which `parseFrontmatter`\n// also accepts (PR #634 round-6 review, codex P2).\nconst DERIVED_VIA_RAW_RE = /^[\\t ]*derived_via:[\\t ]*(.*)$/mu;\nconst DERIVED_FROM_RAW_RE = /^[\\t ]*derived_from:[\\t ]*(.*)$/mu;\n\n/**\n * Tokenize a YAML-block-style list under `key:` in the given\n * frontmatter slice.  Looks for lines matching `^  - <value>` after a\n * `key:` line and before the next non-list line.  Returns `null` when\n * the key is missing or the value is a scalar / flow list (no block\n * entries found).\n *\n * Only used for the mixed-list malformed-entry detection — it does\n * not try to decode YAML escape sequences since we only need the\n * entry count + raw token text to compare against the parsed array.\n */\nfunction tokenizeRawBlockList(fmSlice: string, key: string): string[] | null {\n  const lines = fmSlice.split(\"\\n\");\n  // Accept indented keys too — parseFrontmatter does (PR #634 round-7\n  // review, codex P2 / cursor Low).\n  const keyRe = new RegExp(`^[\\\\t ]*${key}:[\\\\t ]*(.*)$`, \"u\");\n  let startIdx = -1;\n  for (let i = 0; i < lines.length; i++) {\n    const m = lines[i].match(keyRe);\n    if (m) {\n      if (m[1].trim().length === 0) {\n        startIdx = i + 1;\n      }\n      break;\n    }\n  }\n  if (startIdx < 0) return null;\n  const items: string[] = [];\n  for (let i = startIdx; i < lines.length; i++) {\n    const line = lines[i];\n    if (!/^\\s+-/.test(line)) break; // not a block-list entry\n    const m = line.match(/^\\s+-\\s*(.*)$/u);\n    if (!m) break;\n    let tok = m[1].trim();\n    if (\n      (tok.startsWith('\"') && tok.endsWith('\"') && tok.length >= 2) ||\n      (tok.startsWith(\"'\") && tok.endsWith(\"'\") && tok.length >= 2)\n    ) {\n      tok = tok.slice(1, -1);\n    }\n    items.push(tok);\n  }\n  return items.length > 0 ? items : null;\n}\n\n/**\n * Tokenize a YAML-flow-style list (`[\"a\", \"b\", ...]`) into a flat\n * string array.  Returns `null` when the input isn't a flow list.\n * Best-effort — we don't implement a full YAML parser, just enough to\n * detect mixed valid/invalid entries for the doctor integrity check.\n */\nfunction tokenizeRawFlowList(raw: string): string[] | null {\n  const trimmed = raw.trim();\n  if (!trimmed.startsWith(\"[\") || !trimmed.endsWith(\"]\")) return null;\n  const inner = trimmed.slice(1, -1);\n  const parts: string[] = [];\n  let current = \"\";\n  let inSingle = false;\n  let inDouble = false;\n  for (let i = 0; i < inner.length; i++) {\n    const ch = inner[i];\n    if (inDouble) {\n      if (ch === \"\\\\\" && i + 1 < inner.length) {\n        current += inner[++i];\n        continue;\n      }\n      if (ch === '\"') {\n        inDouble = false;\n        continue;\n      }\n      current += ch;\n    } else if (inSingle) {\n      if (ch === \"'\" && inner[i + 1] === \"'\") {\n        current += \"'\";\n        i++;\n        continue;\n      }\n      if (ch === \"'\") {\n        inSingle = false;\n        continue;\n      }\n      current += ch;\n    } else if (ch === '\"') {\n      inDouble = true;\n    } else if (ch === \"'\") {\n      inSingle = true;\n    } else if (ch === \",\") {\n      parts.push(current.trim());\n      current = \"\";\n    } else {\n      current += ch;\n    }\n  }\n  if (current.trim().length > 0 || parts.length > 0) {\n    parts.push(current.trim());\n  }\n  return parts;\n}\n\n/**\n * One integrity warning attached to a specific memory.\n */\nexport interface ConsolidationProvenanceIssue {\n  /** Absolute path to the memory markdown file. */\n  memoryPath: string;\n  /** Memory id from frontmatter. */\n  memoryId: string;\n  /** Type of integrity issue. */\n  kind:\n    | \"derived_from_missing_snapshot\"\n    | \"derived_from_malformed_entry\"\n    | \"derived_via_unknown_operator\";\n  /** Human-readable detail — includes the offending value when relevant. */\n  detail: string;\n}\n\n/**\n * Summary of a provenance-integrity scan.  Used by the operator-doctor\n * report and surfaced in the CLI output.\n */\nexport interface ConsolidationProvenanceReport {\n  /** Total memories inspected. */\n  scanned: number;\n  /** Memories that carry `derived_from` and/or `derived_via`. */\n  withProvenance: number;\n  /** One entry per problem detected (may be empty). */\n  issues: ConsolidationProvenanceIssue[];\n}\n\nconst DERIVED_FROM_ENTRY_RE = /^(.+):(\\d+)$/;\n\n/**\n * Build the on-disk snapshot path for a `\"<relpath>:<version>\"` entry,\n * relative to the given memory directory.  Mirrors the layout documented\n * in `page-versioning.ts`:\n *\n *   memoryDir/<sidecarDir>/<sidecarKey>/<version><ext>\n */\nfunction resolveSnapshotPath(\n  memoryDir: string,\n  sidecarDir: string,\n  entry: string,\n): { ok: true; snapshotPath: string } | { ok: false; reason: string } {\n  const match = entry.match(DERIVED_FROM_ENTRY_RE);\n  if (!match) {\n    return { ok: false, reason: `malformed entry (expected \"<path>:<version>\")` };\n  }\n  const pagePath = match[1];\n  const versionId = match[2];\n  const ext = path.extname(pagePath) || \".md\";\n  const key = sidecarKey(pagePath);\n  const snapshotPath = path.join(memoryDir, sidecarDir, key, `${versionId}${ext}`);\n  return { ok: true, snapshotPath };\n}\n\n/**\n * Scan every memory under `storage` and flag consolidation-provenance\n * problems.  Does not throw on individual failures — collects them in the\n * returned report.\n */\nexport async function runConsolidationProvenanceCheck(options: {\n  storage: StorageManager;\n  memoryDir: string;\n  /**\n   * Page-versioning sidecar directory name.  Defaults to `.versions` —\n   * matches the baked-in default used by `setVersioningConfig` when\n   * versioning is enabled via config.\n   */\n  sidecarDir?: string;\n}): Promise<ConsolidationProvenanceReport> {\n  const { storage, memoryDir } = options;\n  const sidecarDir = options.sidecarDir ?? \".versions\";\n\n  const report: ConsolidationProvenanceReport = {\n    scanned: 0,\n    withProvenance: 0,\n    issues: [],\n  };\n\n  let memories;\n  try {\n    memories = await storage.readAllMemories();\n  } catch {\n    // If we can't enumerate memories at all, surface a single synthetic\n    // issue rather than throwing — the doctor wrapper treats an empty\n    // issues list as \"ok\" and we don't want a filesystem hiccup to crash\n    // the whole diagnostic.\n    return {\n      scanned: 0,\n      withProvenance: 0,\n      issues: [\n        {\n          memoryPath: memoryDir,\n          memoryId: \"(unreadable)\",\n          kind: \"derived_from_malformed_entry\",\n          detail: \"Could not enumerate memory directory to scan provenance.\",\n        },\n      ],\n    };\n  }\n\n  for (const memory of memories) {\n    report.scanned += 1;\n    const fm = memory.frontmatter;\n    const derivedFrom = fm.derived_from;\n    const derivedVia = fm.derived_via;\n\n    // Raw frontmatter values from disk — the read-path parser coerces\n    // malformed `derived_from` and unknown `derived_via` back to\n    // `undefined`, which would silently hide on-disk corruption from\n    // the doctor scan (PR #634 review feedback, codex P2).  We\n    // re-extract both via regex so integrity issues are reported even\n    // when the parser normalized them away.  `rawDerivedVia` /\n    // `rawDerivedFrom` being `\"\"` (empty string) represents a\n    // corrupted file with the key present but the value truncated —\n    // that's distinct from \"key missing entirely\" (undefined).\n    let rawDerivedVia: string | undefined;\n    let rawDerivedFrom: string | undefined;\n    let rawDerivedViaKeyPresent = false;\n    let rawDerivedFromKeyPresent = false;\n    let duplicateViaKeys = false;\n    let duplicateFromKeys = false;\n    let viaMatchCount = 0;\n    let fromMatchCount = 0;\n    let fmSlice = \"\";\n    try {\n      const raw = await readFile(memory.path, \"utf-8\");\n      const frontmatterEnd = raw.indexOf(\"\\n---\", raw.indexOf(\"---\") + 3);\n      fmSlice = frontmatterEnd > 0 ? raw.slice(0, frontmatterEnd) : raw;\n      // Use matchAll to find ALL occurrences of `derived_via` / `derived_from`\n      // in the raw YAML.  `parseFrontmatter` keeps the LAST assignment when\n      // duplicate keys appear, so the doctor must read the last occurrence\n      // to match what the storage reader actually uses (PR #634 review,\n      // codex P2 — duplicate `derived_via` keys caused false-clean or\n      // false-unknown-operator warnings depending on order).\n      const viaMatches = [...fmSlice.matchAll(new RegExp(DERIVED_VIA_RAW_RE.source, DERIVED_VIA_RAW_RE.flags + \"g\"))];\n      viaMatchCount = viaMatches.length;\n      duplicateViaKeys = viaMatches.length > 1;\n      if (viaMatches.length > 0) {\n        rawDerivedViaKeyPresent = true;\n        // Use the last occurrence — `parseFrontmatter` keeps the last\n        // assignment when duplicate keys appear, so the doctor must\n        // match that behavior to produce accurate warnings (PR #634\n        // review, codex P2).\n        const lastVia = viaMatches[viaMatches.length - 1];\n        let val = lastVia[1].trim();\n        if (\n          (val.startsWith('\"') && val.endsWith('\"')) ||\n          (val.startsWith(\"'\") && val.endsWith(\"'\"))\n        ) {\n          val = val.slice(1, -1);\n        }\n        rawDerivedVia = val;\n      }\n      const fromMatches = [...fmSlice.matchAll(new RegExp(DERIVED_FROM_RAW_RE.source, DERIVED_FROM_RAW_RE.flags + \"g\"))];\n      fromMatchCount = fromMatches.length;\n      duplicateFromKeys = fromMatches.length > 1;\n      if (fromMatches.length > 0) {\n        rawDerivedFromKeyPresent = true;\n        const lastFrom = fromMatches[fromMatches.length - 1];\n        rawDerivedFrom = lastFrom[1].trim();\n      }\n    } catch {\n      // Fall through to the parsed values.\n    }\n\n    const hasFrom = Array.isArray(derivedFrom) && derivedFrom.length > 0;\n    const hasVia = derivedVia !== undefined && derivedVia !== null;\n    const hasRawVia = rawDerivedVia !== undefined && rawDerivedVia.length > 0;\n    // A raw `derived_from` that the parser dropped indicates on-disk\n    // corruption we must surface.  We detect this by: (a) the raw YAML\n    // contains a `derived_from:` key, AND (b) the parsed frontmatter\n    // has no valid array.  A scalar like `derived_from: facts/a.md:7`\n    // (list brackets omitted) or a blank `derived_from:` both hit this\n    // branch.\n    const hasRawMalformedFrom = rawDerivedFromKeyPresent && !hasFrom;\n    // A blank `derived_via:` with no value is also corrupt — the\n    // parser drops it to undefined, but the raw key is still present\n    // on disk (PR #634 round-3 review, codex P2).\n    const hasBlankRawVia =\n      rawDerivedViaKeyPresent &&\n      (rawDerivedVia === undefined || rawDerivedVia.length === 0) &&\n      !hasVia;\n    if (\n      !hasFrom && !hasVia && !hasRawVia &&\n      !hasRawMalformedFrom && !hasBlankRawVia\n    ) continue;\n    report.withProvenance += 1;\n\n    // Duplicate-key detection (PR #634 review, codex P2): when the raw\n    // YAML contains multiple `derived_via` or `derived_from` lines,\n    // `parseFrontmatter` silently uses the last one.  Flag this as a\n    // malformed entry so operators can inspect and fix the file.\n    if (duplicateViaKeys) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: `raw YAML contains ${viaMatchCount} \"derived_via\" keys; parseFrontmatter uses the last occurrence`,\n      });\n    }\n    if (duplicateFromKeys) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_from_malformed_entry\",\n        detail: `raw YAML contains ${fromMatchCount} \"derived_from\" keys; parseFrontmatter uses the last occurrence`,\n      });\n    }\n\n    if (hasRawMalformedFrom) {\n      const display = rawDerivedFrom ?? \"(blank)\";\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_from_malformed_entry\",\n        detail: `raw YAML \"derived_from: ${display}\" could not be parsed as a list`,\n      });\n    }\n\n    // Mixed-list detection (PR #634 round-4 + round-5 review, codex\n    // P2): when the parser DID return a valid list but the raw YAML\n    // includes additional tokens that got dropped, flag those as\n    // malformed.  Handles both flow-style (`[\"a\", \"\", \"b\"]`) and\n    // block-style (`\\n  - a\\n  - \\n  - b`) YAML lists.\n    if (hasFrom && rawDerivedFromKeyPresent) {\n      let rawList: string[] | null = null;\n      if (rawDerivedFrom && rawDerivedFrom.length > 0) {\n        rawList = tokenizeRawFlowList(rawDerivedFrom);\n      }\n      if (rawList === null) {\n        // Fall back to block-list tokenization by re-reading the full\n        // frontmatter (already loaded above as `raw`) and scanning\n        // the lines following `derived_from:`.\n        rawList = tokenizeRawBlockList(fmSlice, \"derived_from\");\n      }\n      if (rawList !== null && rawList.length > derivedFrom!.length) {\n        for (const tok of rawList) {\n          if (tok.length === 0) {\n            report.issues.push({\n              memoryPath: memory.path,\n              memoryId: fm.id,\n              kind: \"derived_from_malformed_entry\",\n              detail: `raw YAML derived_from contains an empty entry (mixed list)`,\n            });\n            continue;\n          }\n          if (!derivedFrom!.includes(tok)) {\n            // Accept either the snapshot format `<path>:<version>` or\n            // a bare memory id (issue #687 PR 2/4 — pattern\n            // reinforcement uses ID-shaped entries).  PR #730\n            // review feedback, Codex P2.\n            if (\n              !/^(.+):(\\d+)$/u.test(tok) &&\n              !DERIVED_FROM_MEMORY_ID_RE.test(tok)\n            ) {\n              report.issues.push({\n                memoryPath: memory.path,\n                memoryId: fm.id,\n                kind: \"derived_from_malformed_entry\",\n                detail: `raw YAML derived_from contains a malformed entry: ${JSON.stringify(tok)}`,\n              });\n            }\n          }\n        }\n      }\n    }\n    if (hasBlankRawVia) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: \"raw YAML has `derived_via:` key with empty value\",\n      });\n    }\n\n    if (hasFrom) {\n      for (const entry of derivedFrom!) {\n        // Pattern-reinforcement (issue #687 PR 2/4) records source\n        // memory IDs directly in `derived_from` rather than\n        // page-versioning snapshot references.  Memory IDs may\n        // contain `:` for namespace-prefixed forms like\n        // `global:fact-abc-123`, but never `/` or `.` — those remain\n        // exclusive to snapshot paths (PR #730 review feedback,\n        // Codex P1).  For ID-shaped entries we skip the snapshot\n        // file check entirely — but ONLY when the operator is\n        // `pattern-reinforcement`, which is the sole operator that\n        // legitimately stores IDs rather than snapshot references.\n        // Allowing the bypass for split/merge/update would weaken\n        // validation on those existing consolidation paths (PR #730\n        // review, Codex P2).\n        if (\n          derivedVia === \"pattern-reinforcement\" &&\n          DERIVED_FROM_MEMORY_ID_RE.test(entry)\n        ) {\n          continue;\n        }\n        const resolved = resolveSnapshotPath(memoryDir, sidecarDir, entry);\n        if (!resolved.ok) {\n          report.issues.push({\n            memoryPath: memory.path,\n            memoryId: fm.id,\n            kind: \"derived_from_malformed_entry\",\n            detail: `${JSON.stringify(entry)}: ${resolved.reason}`,\n          });\n          continue;\n        }\n        // Require a regular file at the snapshot path (PR #634\n        // round-8 review, codex P2) — a directory or device node at\n        // that path means the sidecar was corrupted and the snapshot\n        // is effectively missing.\n        let snapshotOk = false;\n        try {\n          const st = await stat(resolved.snapshotPath);\n          snapshotOk = st.isFile();\n        } catch {\n          snapshotOk = false;\n        }\n        if (!snapshotOk) {\n          report.issues.push({\n            memoryPath: memory.path,\n            memoryId: fm.id,\n            kind: \"derived_from_missing_snapshot\",\n            detail: `${entry} → ${resolved.snapshotPath} (not a regular file)`,\n          });\n        }\n      }\n    }\n\n    // Check the RAW YAML value for unknown operators.  The parsed value\n    // (`fm.derived_via`) is always known-good because the read-path\n    // normalizer dropped anything else to undefined.\n    if (hasRawVia && !isConsolidationOperator(rawDerivedVia)) {\n      report.issues.push({\n        memoryPath: memory.path,\n        memoryId: fm.id,\n        kind: \"derived_via_unknown_operator\",\n        detail: `unknown operator: ${JSON.stringify(rawDerivedVia)}`,\n      });\n    }\n  }\n\n  // Parse-failure detection (PR #634 round-4 review, codex P2):\n  // `readAllMemories()` silently drops files whose frontmatter\n  // doesn't parse.  Walk every recall category directory for `.md` files\n  // that DO reference provenance frontmatter but didn't come back from the\n  // reader — those are the corruption cases the doctor is meant to surface.\n  // Uses RECALL_FALLBACK_DIRS (the single source of truth) so newly-routed\n  // categories (decisions/, preferences/, ...) are scanned too (#1546).\n  try {\n    const seenPaths = new Set(memories.map((m) => m.path));\n    for (const rootName of RECALL_FALLBACK_DIRS) {\n      const rootPath = path.join(memoryDir, rootName);\n      for await (const file of walkMarkdownFiles(rootPath, memoryDir)) {\n        if (seenPaths.has(file)) continue;\n        try {\n          const raw = await readFile(file, \"utf-8\");\n          if (\n            DERIVED_FROM_RAW_RE.test(raw) ||\n            DERIVED_VIA_RAW_RE.test(raw)\n          ) {\n            report.withProvenance += 1;\n            report.issues.push({\n              memoryPath: file,\n              memoryId: \"(parse failed)\",\n              kind: \"derived_from_malformed_entry\",\n              detail:\n                \"frontmatter could not be parsed by storage reader; provenance fields visible in raw YAML\",\n            });\n          }\n        } catch {\n          // Unreadable file — skip.\n        }\n      }\n    }\n  } catch {\n    // Best-effort; don't fail the whole scan on a filesystem hiccup.\n  }\n\n  return report;\n}\n\n/**\n * Recursively yield all `.md` file paths under `root`.  Silent on\n * missing directories — the facts/corrections dirs may not exist in\n * fresh installs.  Symlinked roots/directories are skipped so the\n * best-effort parse-failure pass cannot escape `memoryDir`.\n */\nasync function* walkMarkdownFiles(root: string, memoryDir: string): AsyncGenerator<string> {\n  let entries;\n  let memoryDirReal: string;\n  try {\n    const rootStat = await lstat(root);\n    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return;\n    memoryDirReal = await realpath(memoryDir);\n    const rootReal = await realpath(root);\n    if (!isPathWithin(rootReal, memoryDirReal)) return;\n    entries = await readdir(root, { withFileTypes: true });\n  } catch {\n    return;\n  }\n  for (const entry of entries) {\n    const full = path.join(root, entry.name);\n    if (entry.isSymbolicLink()) continue;\n    if (entry.isDirectory()) {\n      yield* walkMarkdownFiles(full, memoryDirReal);\n    } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n      try {\n        const fileReal = await realpath(full);\n        if (!isPathWithin(fileReal, memoryDirReal)) continue;\n      } catch {\n        continue;\n      }\n      yield full;\n    }\n  }\n}\n\nfunction isPathWithin(candidate: string, root: string): boolean {\n  const relative = path.relative(root, candidate);\n  return relative === \"\" || (!!relative && !relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-KI6UOSNR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/storage/content-hash-index.ts"],"sourcesContent":["// Content-hash dedup index for facts, extracted from storage.ts (issue #1909 /\n// PR #2016 write-hot-paths). Self-contained: cross-process locked reconcile /\n// rebuild saves plus the deferred durable-retry machinery. storage.ts imports\n// these back and re-exports the class + companion types that were previously\n// part of its public API.\nimport { mkdir, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { computeContentHash, normalizeContent } from \"../content-hash.js\";\nimport { log } from \"../logger.js\";\nimport { SecureStoreLockedError, readMaybeEncryptedFile, writeMaybeEncryptedFile } from \"../secure-store/secure-fs.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\nimport { withHeldFileLock } from \"../utils/serialize-mutations.js\";\n\n/**\n * Stale threshold (ms) for the per-file advisory lock guarding a fact-hash\n * index merge-save (issue #1909 review round 7). The critical section is a\n * single read+atomic-rewrite of one index file (≤ a few MB), so a holder older\n * than this is treated as crashed. Generous to tolerate slow/encrypted disks\n * without breaking a legitimately in-progress publish.\n */\nconst CONTENT_HASH_INDEX_LOCK_STALE_MS = 30_000;\n/** Version marker for the normalized Unicode hash index format. */\nconst CONTENT_HASH_INDEX_FORMAT_HEADER = \"# remnic-content-hash-index:v2\";\n\nfunction parseHashIndex(raw: string): { versioned: boolean; hashes: Set<string> } {\n  const lines = raw\n    .split(\"\\n\")\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n  if (lines[0] !== CONTENT_HASH_INDEX_FORMAT_HEADER) {\n    return { versioned: false, hashes: new Set() };\n  }\n  return { versioned: true, hashes: new Set(lines.slice(1)) };\n}\n\nfunction serializeHashIndex(hashes: Set<string>): string {\n  return `${CONTENT_HASH_INDEX_FORMAT_HEADER}\\n${[...hashes].join(\"\\n\")}\\n`;\n}\n\n/**\n * Durable-retry policy for a deferred content-hash reconcile save whose\n * cross-process lock acquire timed out (issue #1909 / PR #2016). When the lock\n * is contended past `withHeldFileLock`'s bounded wait, the added hashes are held\n * only in this process's memory; relying on \"some later batch save\" is not\n * durable (the run may be the last before idle/shutdown), and a long-lived peer\n * that already built its authoritative in-memory index will not see the write.\n * So we schedule a bounded, exponentially-backed-off background retry that keeps\n * re-attempting the locked publish until it lands. Bounded because the durable\n * fact `.md` is already on disk and a process restart rebuilds the index from\n * the corpus regardless — exhausting retries degrades to that rebuild safety\n * net, never to data loss or a fatal append failure.\n */\nconst CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS = 5;\n/** Base backoff (ms) before the first deferred reconcile-save retry; doubles each attempt. */\nconst CONTENT_HASH_INDEX_RETRY_BASE_MS = 500;\n/** Ceiling (ms) for the exponential reconcile-save retry backoff. */\nexport const CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS = 5_000;\n\n/**\n * Tuning for {@link ContentHashIndex} cross-process lock waits and the\n * deferred reconcile-save durable retry (issue #1909 / PR #2016). All optional;\n * production uses the module defaults. Tests inject small values so the\n * lock-timeout + retry path is exercised deterministically without real\n * multi-second waits.\n */\nexport interface ContentHashIndexLockOptions {\n  /** Bounded wait to acquire the per-file advisory lock; passed to `withHeldFileLock` (default 5000ms). */\n  readonly maxWaitMs?: number;\n  /** Poll interval while waiting for a busy lock (default 50ms). */\n  readonly pollMs?: number;\n  /** Base backoff before the first deferred-save retry (default 500ms). */\n  readonly retryBaseMs?: number;\n  /** Max deferred-save retries before falling back to the corpus-rebuild safety net (default 5). */\n  readonly retryMaxAttempts?: number;\n}\n\n/**\n * Thrown when the fact-hash index cannot be made authoritative — the\n * cross-process rebuild lock could not be acquired within the bounded retry\n * budget (PR #2016). Callers that require an authoritative dedup answer surface\n * this instead of silently trusting a stale loaded snapshot.\n */\nexport class FactHashIndexNotAuthoritativeError extends Error {\n  constructor(stateDir: string) {\n    super(\n      `fact-hash index is not authoritative: the cross-process rebuild lock for ${stateDir} could not be acquired within the bounded retry budget`\n    );\n    this.name = \"FactHashIndexNotAuthoritativeError\";\n  }\n}\n\ntype DiskFingerprint = {\n  mtimeMs: number;\n  size: number;\n  dev: number;\n  ino: number;\n  ctimeMs: number;\n  birthtimeMs: number;\n};\nexport interface ContentHashPathEntry {\n  readonly path: string;\n  readonly contentHash: string;\n}\n\n/**\n * Content-hash dedup index for facts.\n * Normalizes content (lowercase, strip punctuation, collapse whitespace),\n * computes SHA-256, and stores hashes in a line-delimited file.\n * Prevents writing semantically identical facts.\n */\nexport class ContentHashIndex {\n  private hashes: Set<string> = new Set();\n  /**\n   * Fact-ONLY hash partition (issue #2474). `hashes` above is category-blind\n   * (every write category registers there); this subset carries only\n   * `category === \"fact\"` hashes so fact-only membership checks\n   * (`hasFact*`) can never be satisfied by an unrelated decision/preference\n   * sharing the same normalized body. In-memory only — never serialized to\n   * fact-hashes.txt; `clear()` drops it and every authoritative rebuild\n   * repopulates it via `addFactByHash`. Subset invariant: `factHashes ⊆\n   * hashes` — `addFact*` registers in both, and the removal sites that drop\n   * a shared hash also drop the partition entry (removal stays caller-paired\n   * because shared-index removal is category-blind: archiving a non-fact\n   * must not evict an active fact's fact-only membership).\n   */\n  private factHashes: Set<string> = new Set();\n  private dirty = false;\n  /** True when load() found the pre-Unicode, markerless on-disk format. */\n  private formatMigrationRequired = false;\n  /**\n   * Hashes explicitly removed since the last successful save (issue #1909 review\n   * round 8 thread 3). Tracked separately so `saveMergingWithDisk` can be\n   * removal-AWARE: under the file lock it reads the latest on-disk set, DROPS\n   * these, then unions our additions — so a removal batch cannot resurrect a\n   * hash (union alone would) and cannot clobber a concurrent extraction's\n   * appended hash (blind overwrite would). Consumed + cleared by every save.\n   */\n  private removed: Set<string> = new Set();\n  /**\n   * Hashes added by THIS instance since the last successful save (issue #1909\n   * review round 9 finding 3). Tracked separately from the loaded snapshot so a\n   * reconciling save publishes `(on-disk \\ removed) ∪ added` — it re-applies only\n   * OUR additions, never the stale loaded entries. Without this, seeding the\n   * merge from `this.hashes` (loaded ∪ added) would resurrect a hash a peer\n   * removed on disk while this instance held a stale snapshot.\n   */\n  private added: Set<string> = new Set();\n  private readonly filePath: string;\n  private readonly secureStoreKeyProvider: () => Buffer | null;\n  private readonly secureStoreWriteKeyProvider: () => Buffer | null;\n  private readonly memoryDir: string;\n  private readonly lockOptions: ContentHashIndexLockOptions;\n  /**\n   * Deferred reconcile-save durable-retry state (issue #1909 / PR #2016). At\n   * most ONE retry is ever armed (`reconcileRetryTimer` is the reentrancy guard)\n   * so successive timed-out saves cannot stack duplicate/parallel retries.\n   * `reconcileRetryBarrier` resolves when the chain settles (published or gave\n   * up) — awaited by tests and any caller wanting the eventual result.\n   */\n  private reconcileRetryTimer: NodeJS.Timeout | null = null;\n  private reconcileRetryAttempts = 0;\n  private reconcileRetryBarrier: Promise<void> | null = null;\n  private reconcileRetryResolve: (() => void) | null = null;\n  /**\n   * On-disk fingerprint captured at the last point THIS instance's in-memory\n   * set matched disk — after `load()`, `save()`, or a reconcile publish. A peer\n   * process that advances the durable index changes its file generation even\n   * when byte size and mtime collide, so the freshness check remains safe\n   * without an O(file-size) read on the hot path.\n   */\n  private lastSyncedFingerprint: DiskFingerprint | null = null;\n  constructor(\n    stateDir: string,\n    secureStoreKeyProvider: () => Buffer | null = () => null,\n    secureStoreWriteKeyProvider: () => Buffer | null = secureStoreKeyProvider,\n    memoryDir: string = path.dirname(stateDir),\n    lockOptions: ContentHashIndexLockOptions = {}\n  ) {\n    this.filePath = path.join(stateDir, \"fact-hashes.txt\");\n    this.secureStoreKeyProvider = secureStoreKeyProvider;\n    this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;\n    this.memoryDir = memoryDir;\n    this.lockOptions = lockOptions;\n  }\n  /** Whether a caller with an authoritative corpus must rebuild this legacy index. */\n  get requiresFormatMigration(): boolean {\n    return this.formatMigrationRequired;\n  }\n\n  /** Load existing hashes from disk. Safe to call multiple times. */\n  async load(): Promise<void> {\n    try {\n      const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);\n      const parsed = parseHashIndex(raw);\n      this.formatMigrationRequired = !parsed.versioned;\n      if (!parsed.versioned) {\n        // Hashes from the pre-NFC format are unsafe after normalization changes.\n        // Ignore them until an authoritative corpus rebuild publishes v2.\n        this.hashes.clear();\n        log.warn(`content-hash index: ignored legacy unversioned index at ${this.filePath}`);\n      } else {\n        for (const hash of parsed.hashes) this.hashes.add(hash);\n      }\n      log.debug(`content-hash index: loaded ${this.hashes.size} hashes`);\n    } catch (err) {\n      if (err instanceof SecureStoreLockedError) throw err;\n      if (!isErrnoCode(err, \"ENOENT\")) throw err;\n      log.debug(\"content-hash index: no existing index — starting fresh\");\n    }\n    // The loaded set now reflects the on-disk file — baseline the fingerprint so\n    // a later peer write is detectable (PR #2016 review).\n    await this.captureSyncedFingerprint();\n  }\n\n  /** Cheap `stat` of the durable index file; null when it does not exist yet. */\n  private async statIndexFile(): Promise<DiskFingerprint | null> {\n    try {\n      const s = await stat(this.filePath);\n      return {\n        mtimeMs: s.mtimeMs,\n        size: s.size,\n        dev: s.dev,\n        ino: s.ino,\n        ctimeMs: s.ctimeMs,\n        birthtimeMs: s.birthtimeMs,\n      };\n    } catch (err) {\n      if (isErrnoCode(err, \"ENOENT\")) return null;\n      throw err;\n    }\n  }\n\n  /** Record the current on-disk fingerprint as this instance's synced baseline. */\n  private async captureSyncedFingerprint(): Promise<void> {\n    try {\n      this.lastSyncedFingerprint = await this.statIndexFile();\n    } catch (err) {\n      // A stat failure other than ENOENT leaves no baseline; the next freshness\n      // check reports non-current and the caller confirms against the corpus.\n      this.lastSyncedFingerprint = null;\n      log.debug(`content-hash index: could not fingerprint ${this.filePath}: ${err}`);\n    }\n  }\n\n  /**\n   * True when the durable index file is unchanged since this instance last\n   * synced it (load / save / reconcile). False when a peer advanced it, when\n   * the file appeared or vanished, or when freshness cannot be established\n   * (stat error) — the caller then treats the in-memory snapshot as\n   * non-authoritative and confirms a dedup miss against the durable corpus.\n   * The stat includes file identity and generation metadata so same-size,\n   * same-mtime atomic replacements are detected without reading the file body.\n   */\n  async isDiskFingerprintCurrent(): Promise<boolean> {\n    let current: DiskFingerprint | null;\n    try {\n      current = await this.statIndexFile();\n    } catch {\n      return false;\n    }\n    const last = this.lastSyncedFingerprint;\n    if (last === null || current === null) {\n      return last === null && current === null;\n    }\n    return (\n      current.mtimeMs === last.mtimeMs &&\n      current.size === last.size &&\n      current.dev === last.dev &&\n      current.ino === last.ino &&\n      current.ctimeMs === last.ctimeMs &&\n      current.birthtimeMs === last.birthtimeMs\n    );\n  }\n\n  /** Check if content already exists in the index. */\n  has(content: string): boolean {\n    return this.hashes.has(ContentHashIndex.computeHash(content));\n  }\n\n  /** Add content hash to the index. */\n  add(content: string): void {\n    const hash = ContentHashIndex.computeHash(content);\n    // A re-add supersedes a pending removal of the same hash (round 8 thread 3).\n    this.removed.delete(hash);\n    // Record OUR durable delta even when the local snapshot already holds the\n    // hash (PR #2016 thread SD-nG): local membership can be STALE — a peer\n    // removed this hash on disk while this instance kept it in memory. Skipping\n    // `added`/`dirty` on that path let the reconciling save compute\n    // (on-disk \\ removed) ∪ added and silently drop the reintroduced hash, so\n    // the peer never saw it again. Set semantics keep this idempotent (no\n    // duplicate entries) and the `removed.delete` above preserves remove/add\n    // ordering.\n    this.hashes.add(hash);\n    this.added.add(hash);\n    this.dirty = true;\n  }\n\n  get size(): number {\n    return this.hashes.size;\n  }\n\n  /** Clear all loaded hashes so the next save rewrites the index from scratch. */\n  clear(): void {\n    if (this.hashes.size > 0) {\n      this.hashes.clear();\n    }\n    // The fact-only partition is rebuilt with the shared set on every\n    // authoritative corpus rebuild, so it clears here too (issue #2474).\n    this.factHashes.clear();\n    // A full clear is always paired with a plain overwrite save() (rebuild);\n    // pending per-hash add/remove deltas are subsumed by writing the rebuilt set.\n    // Cancel any armed deferred-reconcile retry (PR #2016) so it cannot fire in\n    // the clear→rebuild→save window and union the pre-clear on-disk rows back.\n    this.added.clear();\n    this.removed.clear();\n    this.cancelReconcileRetry();\n    this.dirty = true;\n  }\n\n  /** Persist index to disk if changed (plain whole-file overwrite). */\n  async save(): Promise<void> {\n    if (!this.dirty) return;\n    await mkdir(path.dirname(this.filePath), { recursive: true });\n    // Snapshot the deltas + overwrite body THIS save publishes BEFORE the write\n    // yields the event loop. `writeMaybeEncryptedFile` materializes `serialized`\n    // eagerly, then the disk await lets a concurrent same-process add()/remove()\n    // land a late delta (PR #2016 thread PRRT_kwDORJXyws6SEBri). Clearing the\n    // LIVE added/removed sets afterward — as the previous unconditional\n    // clear()+`dirty = false` did — would drop that late hash from the index AND\n    // leave no retry, so peers never see it until a corpus rebuild. Consume only\n    // what we published; late deltas stay pending. Mirrors saveMergingWithDisk.\n    const publishedAdded = new Set<string>(this.added);\n    const publishedRemoved = new Set<string>(this.removed);\n    const serialized = serializeHashIndex(this.hashes);\n    await writeMaybeEncryptedFile(this.filePath, serialized, this.secureStoreWriteKeyProvider(), {}, this.memoryDir);\n    this.formatMigrationRequired = false;\n    // Consume ONLY the deltas this overwrite published; anything that arrived\n    // during the awaits above remains pending for the next save.\n    for (const h of publishedAdded) this.added.delete(h);\n    for (const h of publishedRemoved) this.removed.delete(h);\n    // Honest dirty state: true iff late deltas remain unpersisted.\n    this.dirty = this.added.size > 0 || this.removed.size > 0;\n    // This overwrite is now the on-disk state — re-baseline the freshness\n    // fingerprint so our own write is not later mistaken for a peer's (PR #2016).\n    await this.captureSyncedFingerprint();\n    if (this.dirty) {\n      // Late deltas landed mid-save: arm a bounded durable retry so they reach\n      // disk even without a further batch save — never a silent in-memory-only\n      // hash. The locked reconcile republishes only OUR delta onto the overwrite.\n      this.scheduleReconcileRetry();\n    } else {\n      // Clean overwrite supersedes any pending deferred reconcile work.\n      this.cancelReconcileRetry();\n    }\n    log.debug(`content-hash index: saved ${this.hashes.size} hashes`);\n  }\n\n  /**\n   * Persist the index by RECONCILING with the latest on-disk state under a\n   * cross-process lock (issue #1909). Used by the extraction-persist batch save\n   * for BOTH append and removal batches, so appends and removals to the same\n   * index serialize against each other:\n   *   final = (on-disk \\ this.removed) ∪ this.added\n   * Note it re-applies only OUR local additions (`added`), NOT the loaded\n   * snapshot (review round 9 finding 3): seeding from `this.hashes` would\n   * resurrect a hash a peer removed on disk while we held a stale snapshot. This\n   * preserves a concurrent writer's appended hashes (a blind overwrite would\n   * drop them), never resurrects a removed hash, and never loses our additions.\n   *\n   * Hardening:\n   *  - Dirty short-circuit (round 7 finding 3): when this instance neither added\n   *    nor removed anything this run, skip the O(file) read+rewrite entirely.\n   *  - Cross-process lock (round 7 finding 2): serialize the read→reconcile→write\n   *    window on a per-file advisory lock. If the lock is NOT acquired (timeout),\n   *    do NOT publish (round 9 finding 2): keep `dirty` set AND schedule a bounded\n   *    durable background retry (PR #2016) that keeps re-attempting the locked\n   *    publish until the deferred additions land — never an unlocked write that\n   *    could clobber a peer, and never a silent \"batch save complete\" that leaves\n   *    the addition in this process's memory only.\n   */\n  async saveMergingWithDisk(): Promise<void> {\n    if (!this.dirty) return;\n    // The advisory lock file lives beside the index — ensure the dir exists\n    // before acquiring it (the index dir may not exist on a first write).\n    await mkdir(path.dirname(this.filePath), { recursive: true });\n    const publish = async (): Promise<void> => {\n      // Snapshot the deltas this publish is responsible for. The read+rewrite\n      // below yields the event loop, so a concurrent add()/remove() can land\n      // new deltas while we await disk (PR #2016 thread SD7Tj). Consuming the\n      // LIVE sets afterward would drop those late deltas AND clear `dirty`,\n      // stranding them in no save at all. We consume only what we published;\n      // anything that arrived meanwhile stays pending for the next save.\n      const publishedAdded = new Set<string>(this.added);\n      const publishedRemoved = new Set<string>(this.removed);\n      const merged = new Set<string>(publishedAdded);\n      try {\n        const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);\n        const parsed = parseHashIndex(raw);\n        if (parsed.versioned) {\n          for (const hash of parsed.hashes) {\n            // Keep prior/concurrent on-disk hashes EXCEPT the ones we removed.\n            if (!publishedRemoved.has(hash)) merged.add(hash);\n          }\n        } else {\n          // Do not carry hashes from the pre-NFC format into a v2 write.\n          log.warn(`content-hash index: discarded legacy unversioned entries from ${this.filePath}`);\n        }\n      } catch (err) {\n        if (err instanceof SecureStoreLockedError) throw err;\n        if (!isErrnoCode(err, \"ENOENT\")) throw err;\n        // ENOENT → no on-disk index yet; write our additions as-is.\n      }\n      await mkdir(path.dirname(this.filePath), { recursive: true });\n      await writeMaybeEncryptedFile(\n        this.filePath,\n        serializeHashIndex(merged),\n        this.secureStoreWriteKeyProvider(),\n        {},\n        this.memoryDir\n      );\n      this.formatMigrationRequired = false;\n      // Consume ONLY the deltas we just published; deltas that arrived during\n      // the awaits above remain pending.\n      for (const h of publishedAdded) this.added.delete(h);\n      for (const h of publishedRemoved) this.removed.delete(h);\n      // Fold any still-pending deltas onto the reconciled set so the in-memory\n      // view stays consistent with what the next save will publish.\n      for (const h of this.added) merged.add(h);\n      for (const h of this.removed) merged.delete(h);\n      this.hashes = merged;\n      // Honest dirty state: true iff late deltas remain to be persisted. A\n      // subsequent batch save or the shutdown flush drains them.\n      this.dirty = this.added.size > 0 || this.removed.size > 0;\n      // The reconciled set is now the on-disk state — re-baseline the freshness\n      // fingerprint (captured under the held lock) so our own publish is not\n      // later mistaken for a peer's advance (PR #2016 review).\n      await this.captureSyncedFingerprint();\n    };\n    await withHeldFileLock(\n      `${this.filePath}.lock`,\n      {\n        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,\n        ...(this.lockOptions.maxWaitMs !== undefined ? { maxWaitMs: this.lockOptions.maxWaitMs } : {}),\n        ...(this.lockOptions.pollMs !== undefined ? { pollMs: this.lockOptions.pollMs } : {}),\n      },\n      async (acquired) => {\n        if (!acquired) {\n          // Never publish unlocked (round 9 finding 2): keep dirty AND schedule a\n          // durable background retry (PR #2016). Relying on an unguaranteed later\n          // batch save silently left the addition in this process's memory only;\n          // the retry keeps re-attempting the locked publish until the addition\n          // lands on disk.\n          log.warn(\n            `content-hash index: lock not acquired for ${this.filePath}; deferring reconcile save (dirty retained, scheduling durable retry)`\n          );\n          this.scheduleReconcileRetry();\n          return;\n        }\n        await publish();\n        if (this.dirty) {\n          // A concurrent add()/remove() landed during publish's disk awaits, so\n          // deltas remain unpersisted (PR #2016 thread SD7Tj). Arm a bounded\n          // durable retry so they reach disk even if no further batch save comes\n          // — never leave a settled barrier over pending work.\n          this.scheduleReconcileRetry();\n        } else {\n          // Published cleanly: any pending deferred retry is now satisfied.\n          this.cancelReconcileRetry();\n        }\n      }\n    );\n    log.debug(`content-hash index: reconcile-saved ${this.hashes.size} hashes`);\n  }\n\n  /**\n   * Rebuild-and-publish the index from an authoritative source (the durable\n   * corpus) under the SAME per-file cross-process lock the reconciling\n   * append/removal saves (`saveMergingWithDisk`) use (issue #1909 / PR #2016).\n   * The `populate` callback runs WHILE the lock is held and MUST repopulate this\n   * index from the corpus (`clear()` then `addByHash(...)` for every corpus\n   * hash); the rebuilt set is then published with a plain overwrite that is now\n   * serialized against every locked writer.\n   *\n   * This closes the finding where the previous unlocked clear→scan→save() could\n   * overwrite a peer's newer lock-merged or deferred additions: a locked writer\n   * that committed BEFORE the rebuild acquired the lock has its memory `.md` on\n   * disk and is re-scanned; one that commits AFTER the rebuild releases\n   * reconciles its additions on top of the freshly-published set. No union with\n   * the raw on-disk file is performed, so the rebuild keeps its\n   * garbage-collection property (orphaned hashes for deleted memories drop).\n   *\n   * Lock-acquisition failure is explicit and non-destructive: `populate` is NOT\n   * run and nothing is written (never an unlocked overwrite). Returns true when\n   * the rebuild was published under the lock, false when the lock timed out —\n   * the caller keeps the index non-authoritative and retries on next use. Uses\n   * the same non-reentrant file lock as the reconcile path, so it can never\n   * deadlock with the deferred reconcile-retry: a concurrent locked writer (or a\n   * fired retry) simply yields `acquired=false` after the bounded wait.\n   */\n  async rebuildUnderLock(populate: () => Promise<void>): Promise<boolean> {\n    // The advisory lock file lives beside the index — ensure the dir exists\n    // before acquiring it (the index dir may not exist on a first rebuild).\n    await mkdir(path.dirname(this.filePath), { recursive: true });\n    let published = false;\n    await withHeldFileLock(\n      `${this.filePath}.lock`,\n      {\n        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,\n        ...(this.lockOptions.maxWaitMs !== undefined ? { maxWaitMs: this.lockOptions.maxWaitMs } : {}),\n        ...(this.lockOptions.pollMs !== undefined ? { pollMs: this.lockOptions.pollMs } : {}),\n      },\n      async (acquired) => {\n        if (!acquired) {\n          // Never publish unlocked: a concurrent locked writer holds the lock,\n          // so overwriting now could clobber its addition. Leave the index as-is\n          // and let the caller retry the authoritative rebuild on next use.\n          log.warn(\n            `content-hash index: lock not acquired for ${this.filePath}; deferring authoritative rebuild (index left non-authoritative, retried on next use)`\n          );\n          return;\n        }\n        await populate();\n        // Publish under the held lock. save() takes no lock (no re-entrancy) and\n        // is a full overwrite that supersedes any pending add/remove deltas.\n        await this.save();\n        published = true;\n      }\n    );\n    return published;\n  }\n\n  /**\n   * True while a background durable reconcile-save retry is armed (PR #2016).\n   * Test/introspection hook.\n   */\n  get hasPendingReconcileRetry(): boolean {\n    return this.reconcileRetryTimer !== null;\n  }\n\n  /** True while this index has in-memory changes not yet published to disk. */\n  get hasPendingChanges(): boolean {\n    return this.dirty;\n  }\n\n  /**\n   * Resolve once any armed background reconcile-save retry chain has settled —\n   * either it published the deferred additions, or it exhausted its bounded\n   * attempts and fell back to the corpus-rebuild safety net. Resolves\n   * immediately when nothing is armed. Lets a caller (or a test) await the\n   * eventual durability outcome of a lock-timed-out save.\n   */\n  async whenReconcileRetrySettled(): Promise<void> {\n    await (this.reconcileRetryBarrier ?? Promise.resolve());\n  }\n\n  /**\n   * Drive any deferred lock-timeout reconcile save to completion INLINE at a\n   * lifecycle boundary (PR #2016 finding 3). The background retry timer is\n   * `unref`'d so it never keeps a long-lived daemon alive — but a short-lived\n   * writer (a one-shot CLI) can exit before it fires, leaving a durable fact\n   * `.md` whose hash never reached `fact-hashes.txt` for peers that already\n   * built their in-memory index. `orchestrator.destroy()` calls this so the\n   * addition publishes before the process exits; long-lived hosts only reach it\n   * at their own shutdown, so their in-flight retries keep running in the\n   * background until then. Bounded by the same attempt ceiling as the background\n   * retry; a permanently contended lock falls back to the corpus-rebuild-on-\n   * restart safety net (the fact `.md` is already durable). No deadlock: each\n   * attempt is the same non-reentrant, bounded-wait file lock.\n   */\n  async flushReconcileRetry(): Promise<void> {\n    if (!this.dirty) return;\n    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;\n    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;\n    for (let attempt = 0; this.dirty && attempt < maxAttempts; attempt += 1) {\n      // Cancel the unref'd background timer — we drive the locked publish inline.\n      if (this.reconcileRetryTimer) {\n        clearTimeout(this.reconcileRetryTimer);\n        this.reconcileRetryTimer = null;\n      }\n      await this.saveMergingWithDisk();\n      if (!this.dirty) break;\n      if (attempt < maxAttempts - 1) {\n        const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);\n        await new Promise<void>((resolve) => setTimeout(resolve, wait));\n      }\n    }\n    // Clear any timer the final saveMergingWithDisk armed and settle the barrier\n    // so awaiters unblock — the bounded inline drain has done its best.\n    if (this.reconcileRetryTimer) {\n      clearTimeout(this.reconcileRetryTimer);\n      this.reconcileRetryTimer = null;\n    }\n    this.reconcileRetryAttempts = 0;\n    this.settleReconcileRetry();\n  }\n\n  /**\n   * Schedule ONE bounded, exponentially-backed-off background retry of the\n   * deferred reconcile save (PR #2016). Reentrant-safe: an already-armed timer\n   * short-circuits, so successive timed-out saves never stack duplicate retries.\n   * When attempts are exhausted the chain settles without publishing — the\n   * durable fact `.md` is on disk and a process restart rebuilds the index from\n   * the corpus, so this degrades to that safety net, never a fatal failure.\n   */\n  private scheduleReconcileRetry(): void {\n    if (this.reconcileRetryTimer) return; // one retry in flight — no duplicate/reentrant retries\n    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;\n    if (this.reconcileRetryAttempts >= maxAttempts) {\n      log.warn(\n        `content-hash index: exhausted ${maxAttempts} deferred reconcile-save retries for ${this.filePath}; ` +\n          `${this.added.size} addition(s) remain dirty in-memory (a process restart rebuilds the index from the durable corpus)`\n      );\n      this.reconcileRetryAttempts = 0;\n      this.settleReconcileRetry();\n      return;\n    }\n    if (!this.reconcileRetryBarrier) {\n      this.reconcileRetryBarrier = new Promise<void>((resolve) => {\n        this.reconcileRetryResolve = resolve;\n      });\n    }\n    const attempt = this.reconcileRetryAttempts + 1;\n    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;\n    const delay = Math.min(baseMs * 2 ** (attempt - 1), CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);\n    this.reconcileRetryTimer = setTimeout(() => {\n      this.reconcileRetryTimer = null;\n      this.reconcileRetryAttempts = attempt;\n      void this.saveMergingWithDisk()\n        .catch((err) => {\n          // A publish-time I/O/encryption error (not a lock timeout) is best-effort:\n          // log and let the corpus-rebuild safety net cover it rather than loop.\n          log.warn(`content-hash index: deferred reconcile-save retry failed for ${this.filePath}: ${err}`);\n        })\n        .finally(() => {\n          // If the attempt neither published (dirty cleared → cancelReconcileRetry)\n          // nor re-armed a further retry, the chain has ended — settle the barrier.\n          if (this.dirty && !this.reconcileRetryTimer) this.settleReconcileRetry();\n        });\n    }, delay);\n    this.reconcileRetryTimer.unref?.();\n  }\n\n  /** Cancel any armed reconcile-save retry and settle the barrier (a publish landed). */\n  private cancelReconcileRetry(): void {\n    if (this.reconcileRetryTimer) {\n      clearTimeout(this.reconcileRetryTimer);\n      this.reconcileRetryTimer = null;\n    }\n    this.reconcileRetryAttempts = 0;\n    this.settleReconcileRetry();\n  }\n\n  /** Resolve and clear the retry barrier if one is outstanding. */\n  private settleReconcileRetry(): void {\n    const resolve = this.reconcileRetryResolve;\n    this.reconcileRetryBarrier = null;\n    this.reconcileRetryResolve = null;\n    resolve?.();\n  }\n\n  /** Remove a hash from the index (used when archiving/deleting). */\n  remove(content: string): void {\n    const hash = ContentHashIndex.computeHash(content);\n    // Record the removal (round 8 thread 3) even when the hash is not in our\n    // in-memory set — a reconciling save must still drop it from the latest\n    // on-disk state. A removal supersedes a pending add. Always mark dirty.\n    this.added.delete(hash);\n    this.removed.add(hash);\n    this.hashes.delete(hash);\n    this.dirty = true;\n  }\n\n  /**\n   * Remove a pre-computed SHA-256 hash directly from the index without\n   * re-hashing.  Use this when the caller already holds the stored hash\n   * (e.g. `memory.frontmatter.contentHash`) to avoid the double-hash bug\n   * where `remove(hash)` would compute `hash(hash)` and never match the\n   * entry.\n   */\n  removeByHash(hash: string): void {\n    this.added.delete(hash);\n    this.removed.add(hash);\n    this.hashes.delete(hash);\n    this.dirty = true;\n  }\n\n  /**\n   * Add a pre-computed SHA-256 hash directly to the index without re-hashing.\n   * Use this when the caller already holds the stored hash\n   * (e.g. `memory.frontmatter.contentHash`) so that the index records the raw\n   * content hash rather than re-hashing the citation-annotated body.\n   *\n   * @internal Only called from `StorageManager.ensureFactHashIndexAuthoritative`.\n   * Not part of the public API — prefer `add(content)` for external callers.\n   */\n  addByHash(hash: string): void {\n    // A re-add supersedes a pending removal of the same hash.\n    this.removed.delete(hash);\n    // Record OUR durable delta even when the local snapshot already holds the\n    // hash (PR #2016 thread PRRT_kwDORJXyws6SEHve). Outside a rebuild\n    // (StorageManager.addActiveFactContentHash on reactivation) local\n    // membership can be STALE: a peer removed this hash on disk while this\n    // instance kept it in memory. Skipping added/dirty on that path let the\n    // reconciling save compute (on-disk \\ removed) ∪ added and silently drop\n    // the reintroduced hash, so the peer never saw it again. Set semantics keep\n    // this idempotent (no duplicate entries) and the removed.delete above\n    // preserves remove/add ordering. Mirrors add().\n    this.hashes.add(hash);\n    this.added.add(hash);\n    this.dirty = true;\n  }\n\n  // ── Fact-only partition (issue #2474) ─────────────────────────────────\n  // Folded here from StorageManager's parallel `factOnlyHashes` set, which had\n  // to be kept in lockstep by hand on every add/remove/rebuild site. The\n  // partition lives on the index instance, so every path that mutates the\n  // shared set and needs fact-only truth mutates it in the same breath.\n\n  /** Register fact content in BOTH the shared index and the fact-only partition. */\n  addFact(content: string): void {\n    this.addFactByHash(ContentHashIndex.computeHash(content));\n  }\n\n  /** Register a pre-computed fact hash in both the shared index and the fact-only partition. */\n  addFactByHash(hash: string): void {\n    this.addByHash(hash);\n    this.factHashes.add(hash);\n  }\n\n  /** Fact-ONLY membership: has this content been registered as a fact? */\n  hasFact(content: string): boolean {\n    return this.factHashes.has(ContentHashIndex.computeHash(content));\n  }\n\n  /** Fact-ONLY membership for a pre-computed SHA-256 hash. */\n  hasFactByHash(hash: string): boolean {\n    return this.factHashes.has(hash);\n  }\n\n  /**\n   * Drop fact-only partition membership WITHOUT touching the shared index.\n   * The shared removal stays caller-owned: a shared hash is dropped only when\n   * no other active memory holds it, while fact-only membership follows the\n   * fact's own lifecycle (supersede/archive/promotion).\n   */\n  removeFactByHash(hash: string): void {\n    this.factHashes.delete(hash);\n  }\n\n  /**\n   * Resolve a pre-computed semantic hash to one deterministic corpus path.\n   *\n   * This lookup is separate from durable hash membership: `this.hashes` stays\n   * one hash per line and `has(content)` keeps its existing raw-content contract.\n   * Reconciliation supplies short-lived manifest rows where hash and path coexist.\n   */\n  static resolvePathByHash(hash: string, entries: Iterable<ContentHashPathEntry>): string | undefined {\n    const canonicalHash = hash.toLowerCase();\n    if (!/^[a-f0-9]{64}$/.test(canonicalHash)) return undefined;\n    let canonicalPath: string | undefined;\n    for (const entry of entries) {\n      if (entry.contentHash.toLowerCase() !== canonicalHash || entry.path.length === 0) continue;\n      if (canonicalPath === undefined || entry.path < canonicalPath) canonicalPath = entry.path;\n    }\n    return canonicalPath;\n  }\n\n  /** Normalize content (delegates to content-hash.ts for a single source of truth). */\n  static normalizeContent(content: string): string {\n    return normalizeContent(content);\n  }\n\n  /** Compute SHA-256 hash (delegates to content-hash.ts for a single source of truth). */\n  static computeHash(content: string): string {\n    return computeContentHash(content);\n  }\n}\n"],"mappings":"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","names":[]}