@remnic/core 9.7.8 → 9.7.10

package/dist/{chunk-XFTPUXCE.js → chunk-VRAD2FGO.js}

@@ -1,3 +1,12 @@
+import {
+  LcmSummarizer
+} from "./chunk-MTR7BZQN.js";
+import {
+  LcmArchive
+} from "./chunk-O7BBFJLP.js";
+import {
+  LcmDag
+} from "./chunk-7N4KAIGN.js";
 import {
   LcmWorkQueue
 } from "./chunk-TPDBFYEG.js";
@@ -8,15 +17,6 @@ import {
   ensureLcmStateDir,
   openLcmDatabase
 } from "./chunk-7N2RUBAP.js";
-import {
-  LcmSummarizer
-} from "./chunk-MTR7BZQN.js";
-import {
-  LcmArchive
-} from "./chunk-O7BBFJLP.js";
-import {
-  LcmDag
-} from "./chunk-7N4KAIGN.js";
 import {
   log
 } from "./chunk-37CTGERM.js";
@@ -526,4 +526,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-XFTPUXCE.js.map
+//# sourceMappingURL=chunk-VRAD2FGO.js.map

package/dist/{chunk-VF4XKTX3.js → chunk-VZ5OJE4X.js}

@@ -1,5 +1,9 @@
 import {
-  ALL_CATEGORY_DIRS
+  bumpMemoryCorpusVersionForDir
+} from "./chunk-OKUEZOGW.js";
+import {
+  ALL_CATEGORY_DIRS,
+  RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
 
 // src/page-versioning.ts
@@ -163,6 +167,10 @@ async function revertToVersion(pagePath, versionId, config, log = NOOP_LOGGER, m
     resolvedMemoryDir
   );
   await writeFile(pagePath, targetContent, "utf-8");
+  const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];
+  if (RECALL_FALLBACK_DIRS.includes(revertedTop)) {
+    bumpMemoryCorpusVersionForDir(resolvedMemoryDir);
+  }
   log.debug(`page-versioning: reverted ${pagePath} to version ${versionId}`);
   return version;
 }
@@ -263,4 +271,4 @@ export {
   revertToVersion,
   diffVersions
 };
-//# sourceMappingURL=chunk-VF4XKTX3.js.map
+//# sourceMappingURL=chunk-VZ5OJE4X.js.map

package/dist/chunk-VZ5OJE4X.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/page-versioning.ts"],"sourcesContent":["/**\n * Page-level versioning with history and revert (issue #371).\n *\n * Provides snapshot-based versioning for memory files using a sidecar\n * directory layout.  Each memory page gets a `.versions/<pageName>/`\n * subdirectory containing numbered snapshots and a `manifest.json` that\n * records the version history.\n *\n * Storage layout:\n *   memoryDir/\n *     facts/preferences.md              <- current file\n *     .versions/\n *       facts__preferences/\n *         manifest.json                  <- VersionHistory\n *         1.md                           <- version 1 snapshot\n *         2.md                           <- version 2 snapshot\n */\n\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport {\n  access,\n  mkdir,\n  readFile,\n  writeFile,\n  unlink,\n} from \"node:fs/promises\";\nimport { ALL_CATEGORY_DIRS, RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\nimport { bumpMemoryCorpusVersionForDir } from \"./memory-corpus-version.js\";\n\n// ---------------------------------------------------------------------------\n// Public interfaces\n// ---------------------------------------------------------------------------\n\nexport interface PageVersion {\n  versionId: string;\n  timestamp: string;\n  contentHash: string;\n  sizeBytes: number;\n  trigger: VersionTrigger;\n  note?: string;\n}\n\nexport type VersionTrigger = \"write\" | \"consolidation\" | \"revert\" | \"manual\";\n\nexport interface VersionHistory {\n  pagePath: string;\n  versions: PageVersion[];\n  currentVersion: string;\n}\n\nexport interface VersioningConfig {\n  enabled: boolean;\n  maxVersionsPerPage: number;\n  sidecarDir: string;\n}\n\n// ---------------------------------------------------------------------------\n// Logger interface (minimal, avoids coupling to the host logger)\n// ---------------------------------------------------------------------------\n\nexport interface VersioningLogger {\n  debug(msg: string): void;\n  warn(msg: string): void;\n}\n\nconst NOOP_LOGGER: VersioningLogger = {\n  debug: () => {},\n  warn: () => {},\n};\n\n// ---------------------------------------------------------------------------\n// Per-page write lock (promise-chain pattern, see gotcha #40)\n// ---------------------------------------------------------------------------\n\nconst writeLocks = new Map<string, Promise<void>>();\n\nfunction withPageLock<T>(pageKey: string, fn: () => Promise<T>): Promise<T> {\n  const prev = writeLocks.get(pageKey) ?? Promise.resolve();\n  const next = prev.then(fn, fn); // run fn after previous completes, even if previous failed\n  writeLocks.set(pageKey, next.then(() => {}, () => {})); // recover chain per gotcha #40\n  return next;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction contentHash(content: string): string {\n  return createHash(\"sha256\").update(content, \"utf-8\").digest(\"hex\");\n}\n\n/**\n * Derive a filesystem-safe sidecar key from a page path relative to memoryDir.\n *\n * `facts/2026-01-15/pref-001.md` -> `facts__2026-01-15__pref-001`\n *\n * Exported so the `remnic doctor` consolidation-provenance check (issue\n * #561 PR 4) resolves snapshot locations using the canonical algorithm\n * without re-implementing it — preventing silent drift if the key\n * format ever changes.\n */\nexport function sidecarKey(pagePath: string): string {\n  const withoutExt = pagePath.replace(/\\.md$/i, \"\");\n  return withoutExt.replace(/[\\\\/]/g, \"__\");\n}\n\nfunction sidecarDir(memoryDir: string, sidecar: string, pagePath: string): string {\n  return path.join(memoryDir, sidecar, sidecarKey(pagePath));\n}\n\nfunction manifestPath(memoryDir: string, sidecar: string, pagePath: string): string {\n  return path.join(sidecarDir(memoryDir, sidecar, pagePath), \"manifest.json\");\n}\n\nasync function fileExists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function readManifest(\n  memoryDir: string,\n  sidecar: string,\n  pagePath: string,\n): Promise<VersionHistory> {\n  const mp = manifestPath(memoryDir, sidecar, pagePath);\n  if (!(await fileExists(mp))) {\n    return { pagePath, versions: [], currentVersion: \"0\" };\n  }\n  try {\n    const raw = await readFile(mp, \"utf-8\");\n    const parsed: unknown = JSON.parse(raw);\n    if (typeof parsed !== \"object\" || parsed === null) {\n      throw new Error(\"manifest root must be an object\");\n    }\n    const obj = parsed as Record<string, unknown>;\n    if (!Array.isArray(obj.versions)) {\n      throw new Error(\"manifest versions must be an array\");\n    }\n    const versions = obj.versions.map((entry, index) => {\n      if (!entry || typeof entry !== \"object\" || Array.isArray(entry)) {\n        throw new Error(`manifest version ${index} must be an object`);\n      }\n      const version = entry as Record<string, unknown>;\n      if (\n        typeof version.versionId !== \"string\" ||\n        !/^\\d+$/.test(version.versionId) ||\n        typeof version.timestamp !== \"string\" ||\n        typeof version.contentHash !== \"string\" ||\n        typeof version.sizeBytes !== \"number\" ||\n        !Number.isFinite(version.sizeBytes) ||\n        ![\"write\", \"consolidation\", \"revert\", \"manual\"].includes(String(version.trigger))\n      ) {\n        throw new Error(`manifest version ${index} has invalid shape`);\n      }\n      return version as unknown as PageVersion;\n    });\n    if (typeof obj.currentVersion !== \"string\" || !/^\\d+$/.test(obj.currentVersion)) {\n      throw new Error(\"manifest currentVersion must be a numeric string\");\n    }\n    const currentVersion = obj.currentVersion;\n    return { pagePath: typeof obj.pagePath === \"string\" ? obj.pagePath : pagePath, versions, currentVersion };\n  } catch (error) {\n    throw new Error(`page-versioning: invalid manifest ${mp}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\nasync function writeManifest(\n  memoryDir: string,\n  sidecar: string,\n  pagePath: string,\n  history: VersionHistory,\n): Promise<void> {\n  const dir = sidecarDir(memoryDir, sidecar, pagePath);\n  await mkdir(dir, { recursive: true });\n  const mp = manifestPath(memoryDir, sidecar, pagePath);\n  await writeFile(mp, JSON.stringify(history, null, 2) + \"\\n\", \"utf-8\");\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Create a new version snapshot for a page.\n *\n * Call this BEFORE overwriting the current file so the previous content is\n * preserved. If the file does not exist yet (first write), the provided\n * `content` is snapshotted as version 1.\n *\n * Pruning: when the number of versions exceeds `config.maxVersionsPerPage`,\n * the oldest snapshots (and their files) are removed.\n */\nexport async function createVersion(\n  pagePath: string,\n  content: string,\n  trigger: VersionTrigger,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  note?: string,\n  memoryDir?: string,\n): Promise<PageVersion> {\n  const { sidecarDir: sidecar, maxVersionsPerPage } = config;\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const mPath = manifestPath(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n\n  return withPageLock(mPath, async () => {\n    const history = await readManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n    const nextId = String(history.versions.length > 0\n      ? Math.max(...history.versions.map((v) => Number(v.versionId))) + 1\n      : 1);\n\n    const hash = contentHash(content);\n    const version: PageVersion = {\n      versionId: nextId,\n      timestamp: new Date().toISOString(),\n      contentHash: hash,\n      sizeBytes: Buffer.byteLength(content, \"utf-8\"),\n      trigger,\n      ...(note !== undefined ? { note } : {}),\n    };\n\n    // Write snapshot file\n    const dir = sidecarDir(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n    await mkdir(dir, { recursive: true });\n    const ext = path.extname(pagePath) || \".md\";\n    const snapshotPath = path.join(dir, `${nextId}${ext}`);\n    await writeFile(snapshotPath, content, \"utf-8\");\n\n    history.versions.push(version);\n    history.currentVersion = nextId;\n\n    // Prune old versions if exceeding max\n    if (maxVersionsPerPage > 0 && history.versions.length > maxVersionsPerPage) {\n      const toRemove = history.versions.splice(0, history.versions.length - maxVersionsPerPage);\n      for (const old of toRemove) {\n        const oldPath = path.join(dir, `${old.versionId}${ext}`);\n        try {\n          await unlink(oldPath);\n        } catch {\n          log.debug(`page-versioning: could not remove old snapshot ${oldPath}`);\n        }\n      }\n    }\n\n    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);\n    log.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);\n\n    return version;\n  });\n}\n\n/**\n * List all versions for a page.\n */\nexport async function listVersions(\n  pagePath: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<VersionHistory> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const history = await readManifest(resolvedMemoryDir, config.sidecarDir, rel);\n  // Sort ascending by versionId (numeric)\n  history.versions.sort((a, b) => Number(a.versionId) - Number(b.versionId));\n  return history;\n}\n\n/**\n * Read the content of a specific version.\n */\nexport async function getVersion(\n  pagePath: string,\n  versionId: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<string> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const ext = path.extname(pagePath) || \".md\";\n  const dir = sidecarDir(resolvedMemoryDir, config.sidecarDir, rel);\n  const snapshotPath = path.join(dir, `${versionId}${ext}`);\n\n  if (!(await fileExists(snapshotPath))) {\n    throw new Error(`Version ${versionId} not found for ${pagePath}`);\n  }\n\n  return readFile(snapshotPath, \"utf-8\");\n}\n\n/**\n * Revert a page to a previous version.\n *\n * 1. Reads the target version's content.\n * 2. Snapshots the CURRENT content as a new version (trigger: \"revert\").\n * 3. Writes the reverted content to the page file.\n *\n * Returns the newly created version entry for the revert snapshot.\n */\nexport async function revertToVersion(\n  pagePath: string,\n  versionId: string,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  memoryDir?: string,\n): Promise<PageVersion> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n\n  // Read target version content\n  const targetContent = await getVersion(pagePath, versionId, config, resolvedMemoryDir);\n\n  // Snapshot current content before overwriting\n  let currentContent = \"\";\n  try {\n    currentContent = await readFile(pagePath, \"utf-8\");\n  } catch {\n    // File may not exist; that's okay\n  }\n\n  const version = await createVersion(\n    pagePath,\n    currentContent,\n    \"revert\",\n    config,\n    log,\n    `reverted to version ${versionId}`,\n    resolvedMemoryDir,\n  );\n\n  // Write the reverted content to the actual page\n  await writeFile(pagePath, targetContent, \"utf-8\");\n  // A revert overwrites a memory file out-of-band (not via a StorageManager\n  // mutation), so bump the corpus sentinel when the reverted page lives under a\n  // recall category dir — forcing a warm hot-memories cache to rescan on its\n  // next read (issue #1902, Codex P1). Non-recall pages (entities/artifacts/\n  // profiles) are not in the corpus scan, so they need no bump.\n  // The hot-memories corpus covers the RECALL corpus, which excludes the\n  // non-memory queue dirs (questions/). Use RECALL_FALLBACK_DIRS — a revert of a\n  // questions/ page must NOT bump the recall corpus sentinel and force a rescan.\n  const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];\n  if ((RECALL_FALLBACK_DIRS as readonly string[]).includes(revertedTop)) {\n    bumpMemoryCorpusVersionForDir(resolvedMemoryDir);\n  }\n  log.debug(`page-versioning: reverted ${pagePath} to version ${versionId}`);\n\n  return version;\n}\n\n/**\n * Simple line-based diff between two versions.\n *\n * Returns a unified-style diff string showing added (+) and removed (-) lines.\n */\nexport async function diffVersions(\n  pagePath: string,\n  v1: string,\n  v2: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<string> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const content1 = await getVersion(pagePath, v1, config, resolvedMemoryDir);\n  const content2 = await getVersion(pagePath, v2, config, resolvedMemoryDir);\n\n  const lines1 = content1.split(\"\\n\");\n  const lines2 = content2.split(\"\\n\");\n\n  const result: string[] = [];\n  result.push(`--- version ${v1}`);\n  result.push(`+++ version ${v2}`);\n\n  // Simple LCS-based diff\n  const lcs = computeLCS(lines1, lines2);\n  let i = 0;\n  let j = 0;\n  let k = 0;\n\n  while (k < lcs.length) {\n    // Emit removed lines before the next common line\n    while (i < lines1.length && lines1[i] !== lcs[k]) {\n      result.push(`-${lines1[i]}`);\n      i++;\n    }\n    // Emit added lines before the next common line\n    while (j < lines2.length && lines2[j] !== lcs[k]) {\n      result.push(`+${lines2[j]}`);\n      j++;\n    }\n    // Common line\n    result.push(` ${lcs[k]}`);\n    i++;\n    j++;\n    k++;\n  }\n  // Remaining removed lines\n  while (i < lines1.length) {\n    result.push(`-${lines1[i]}`);\n    i++;\n  }\n  // Remaining added lines\n  while (j < lines2.length) {\n    result.push(`+${lines2[j]}`);\n    j++;\n  }\n\n  return result.join(\"\\n\");\n}\n\n// ---------------------------------------------------------------------------\n// LCS helper for diffVersions\n// ---------------------------------------------------------------------------\n\nfunction computeLCS(a: string[], b: string[]): string[] {\n  const m = a.length;\n  const n = b.length;\n  // Build DP table\n  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));\n  for (let i = 1; i <= m; i++) {\n    for (let j = 1; j <= n; j++) {\n      if (a[i - 1] === b[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1] + 1;\n      } else {\n        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);\n      }\n    }\n  }\n  // Backtrack to build LCS\n  const result: string[] = [];\n  let i = m;\n  let j = n;\n  while (i > 0 && j > 0) {\n    if (a[i - 1] === b[j - 1]) {\n      result.unshift(a[i - 1]);\n      i--;\n      j--;\n    } else if (dp[i - 1][j] > dp[i][j - 1]) {\n      i--;\n    } else {\n      j--;\n    }\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Legacy fallback: given an absolute page path, heuristically resolve the\n * memory directory by walking up past known subdirectory names.\n *\n * Callers should always pass an explicit `memoryDir` instead of relying on\n * this heuristic.  It is retained only for backward compatibility when the\n * optional `memoryDir` parameter is omitted.\n */\nfunction resolveMemoryDir(pagePath: string): string {\n  // Derive the recall category dirs from ALL_CATEGORY_DIRS (single source of\n  // truth) so newly-routed categories (decisions/, preferences/, ...) are\n  // recognized when walking up to the memory root (#1546); the non-category\n  // subdirs are listed explicitly.\n  const knownSubdirs = new Set<string>([\n    ...ALL_CATEGORY_DIRS,\n    \"entities\",\n    \"state\",\n    \"artifacts\",\n    \"profiles\",\n  ]);\n\n  let dir = path.dirname(pagePath);\n  // Walk up past date directories (YYYY-MM-DD) and known subdirs\n  for (let depth = 0; depth < 5; depth++) {\n    const base = path.basename(dir);\n    if (knownSubdirs.has(base) || /^\\d{4}-\\d{2}-\\d{2}$/.test(base)) {\n      dir = path.dirname(dir);\n    } else {\n      break;\n    }\n  }\n  return dir;\n}\n\n/**\n * Compute relative path of a page within its memory directory.\n */\nfunction relPath(pagePath: string, memoryDir: string): string {\n  return path.relative(memoryDir, pagePath);\n}\n"],"mappings":"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","names":["i","j"]}

package/dist/{chunk-UVIQHSS7.js → chunk-WUDBMLC6.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-KTOH7EJE.js";
+} from "./chunk-KXLRMM35.js";
 
 // src/semantic-rule-promotion.ts
 import { createHash, randomUUID } from "crypto";
@@ -398,7 +398,13 @@ function normalizeRuleWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function stripTrailingClausePunctuation(value) {
-  return value.replace(/[,:;]+$/g, "").trim();
+  let end = value.length;
+  while (end > 0) {
+    const ch = value[end - 1];
+    if (ch === "," || ch === ":" || ch === ";") end--;
+    else break;
+  }
+  return value.slice(0, end).trim();
 }
 function canonicalizeRuleContent(value) {
   return extractExplicitIfThenRule(value) ?? normalizeRuleWhitespace(value);
@@ -529,4 +535,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-UVIQHSS7.js.map
+//# sourceMappingURL=chunk-WUDBMLC6.js.map

package/dist/chunk-WUDBMLC6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/semantic-rule-promotion.ts"],"sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\nimport { link, mkdir, readFile, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { setTimeout as sleep } from \"node:timers/promises\";\nimport { StorageManager } from \"./storage.js\";\nimport type { MemoryFile, MemoryLink } from \"./types.js\";\n\nexport interface SemanticRulePromotionCandidate {\n  id: string;\n  sourceMemoryId: string;\n  content: string;\n  confidence: number;\n  tags: string[];\n  memoryKind: \"note\";\n  lineage: string[];\n}\n\nexport interface SemanticRulePromotionSkip {\n  sourceMemoryId: string;\n  reason:\n    | \"disabled\"\n    | \"source-memory-missing\"\n    | \"source-memory-forgotten\"\n    | \"source-memory-not-episode\"\n    | \"no-explicit-rule\"\n    | \"duplicate-rule\";\n  existingRuleId?: string;\n}\n\nexport interface SemanticRulePromotionReport {\n  enabled: boolean;\n  dryRun: boolean;\n  promoted: SemanticRulePromotionCandidate[];\n  skipped: SemanticRulePromotionSkip[];\n}\n\nconst PROMOTION_LOCK_TIMEOUT_MS = 10 * 60 * 1000;\nconst PROMOTION_LOCK_RETRY_MS = 25;\nconst PROMOTION_LOCK_STALE_MS = 5 * 60 * 1000;\nconst PROMOTION_LOCK_OWNERLESS_GRACE_MS = 1000;\nconst PROMOTION_LOCK_HEARTBEAT_MS = 30 * 1000;\n\ntype SemanticRulePromotionTestHooks = {\n  beforeLockOwnerWrite?: (lockDir: string, ownerToken: string) => Promise<void> | void;\n  beforeLockRelease?: (lockDir: string, ownerToken: string) => Promise<void> | void;\n  beforePromotedRuleWrite?: (lockDir: string, ownerToken: string) => Promise<void> | void;\n  lockTimeoutMs?: number;\n  lockRetryMs?: number;\n  staleLockMs?: number;\n  ownerlessGraceMs?: number;\n  heartbeatMs?: number;\n};\n\nlet testHooks: SemanticRulePromotionTestHooks | null = null;\n\nexport function setSemanticRulePromotionTestHooks(hooks: SemanticRulePromotionTestHooks | null): void {\n  testHooks = hooks;\n}\n\nfunction promotionLockTimeoutMs(): number {\n  return testHooks?.lockTimeoutMs ?? PROMOTION_LOCK_TIMEOUT_MS;\n}\n\nfunction promotionLockRetryMs(): number {\n  return testHooks?.lockRetryMs ?? PROMOTION_LOCK_RETRY_MS;\n}\n\nfunction promotionLockStaleMs(): number {\n  return testHooks?.staleLockMs ?? PROMOTION_LOCK_STALE_MS;\n}\n\nfunction promotionLockOwnerlessGraceMs(): number {\n  return testHooks?.ownerlessGraceMs ?? PROMOTION_LOCK_OWNERLESS_GRACE_MS;\n}\n\nfunction promotionLockHeartbeatMs(): number {\n  return testHooks?.heartbeatMs ?? PROMOTION_LOCK_HEARTBEAT_MS;\n}\n\nfunction isErrnoCode(err: unknown, code: string): boolean {\n  return typeof err === \"object\" && err !== null && \"code\" in err && (err as { code?: unknown }).code === code;\n}\n\nfunction promotionLockDir(memoryDir: string, ruleKey: string): string {\n  const digest = createHash(\"sha256\").update(ruleKey).digest(\"hex\");\n  return path.join(path.resolve(memoryDir), \"state\", \"semantic-rule-promotion-locks\", `${digest}.lock`);\n}\n\nfunction promotionHeartbeatPath(lockDir: string, token: string): string {\n  return path.join(lockDir, `heartbeat.${token}.json`);\n}\n\nfunction promotionReapDir(lockDir: string): string {\n  return `${lockDir}.reap`;\n}\n\nfunction promotionReleaseDir(lockDir: string): string {\n  return `${lockDir}.release`;\n}\n\nasync function pathExists(targetPath: string): Promise<boolean> {\n  try {\n    await stat(targetPath);\n    return true;\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n}\n\nasync function readPromotionLockOwner(lockDir: string): Promise<{\n  acquiredAtMs: number | null;\n  heartbeatAtMs: number | null;\n  token: string | null;\n}> {\n  try {\n    const owner = JSON.parse(await readFile(path.join(lockDir, \"owner.json\"), \"utf8\")) as {\n      acquiredAt?: unknown;\n      heartbeatAt?: unknown;\n      token?: unknown;\n    };\n    const acquiredAtMs = typeof owner.acquiredAt === \"string\" ? Date.parse(owner.acquiredAt) : Number.NaN;\n    const heartbeatAtMs = typeof owner.heartbeatAt === \"string\" ? Date.parse(owner.heartbeatAt) : Number.NaN;\n    return {\n      acquiredAtMs: Number.isFinite(acquiredAtMs) ? acquiredAtMs : null,\n      heartbeatAtMs: Number.isFinite(heartbeatAtMs) ? heartbeatAtMs : null,\n      token: typeof owner.token === \"string\" ? owner.token : null,\n    };\n  } catch {\n    return {\n      acquiredAtMs: null,\n      heartbeatAtMs: null,\n      token: null,\n    };\n  }\n}\n\nasync function tryWritePromotionLockOwner(\n  lockDir: string,\n  owner: { token: string; acquiredAt: string }\n): Promise<boolean> {\n  const ownerPath = path.join(lockDir, \"owner.json\");\n  const tempPath = path.join(lockDir, `owner.${process.pid}.${randomUUID()}.tmp`);\n  await testHooks?.beforeLockOwnerWrite?.(lockDir, owner.token);\n  try {\n    await writeFile(\n      tempPath,\n      `${JSON.stringify(\n        {\n          pid: process.pid,\n          token: owner.token,\n          acquiredAt: owner.acquiredAt,\n        },\n        null,\n        2\n      )}\\n`\n    );\n    await link(tempPath, ownerPath);\n    return true;\n  } catch (err) {\n    if (isErrnoCode(err, \"EEXIST\") || isErrnoCode(err, \"ENOENT\")) {\n      return false;\n    }\n    throw err;\n  } finally {\n    await rm(tempPath, { force: true });\n  }\n}\n\nasync function writePromotionLockHeartbeat(lockDir: string, token: string): Promise<void> {\n  const heartbeatPath = promotionHeartbeatPath(lockDir, token);\n  const tempPath = path.join(lockDir, `heartbeat.${process.pid}.${randomUUID()}.tmp`);\n  try {\n    await writeFile(\n      tempPath,\n      `${JSON.stringify(\n        {\n          pid: process.pid,\n          token,\n          heartbeatAt: new Date().toISOString(),\n        },\n        null,\n        2\n      )}\\n`\n    );\n    await rename(tempPath, heartbeatPath);\n  } catch (err) {\n    await rm(tempPath, { force: true });\n    throw err;\n  }\n}\n\nasync function refreshPromotionLockHeartbeat(lockDir: string, token: string): Promise<boolean> {\n  const owner = await readPromotionLockOwner(lockDir);\n  if (owner.token !== token) {\n    return false;\n  }\n  await writePromotionLockHeartbeat(lockDir, token);\n  return true;\n}\n\nasync function readPromotionLockHeartbeatMs(lockDir: string, token: string | null): Promise<number | null> {\n  if (!token) return null;\n  try {\n    return (await stat(promotionHeartbeatPath(lockDir, token))).mtimeMs;\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return null;\n    throw err;\n  }\n}\n\nasync function reapAbandonedPromotionGuard(guardDir: string): Promise<boolean> {\n  let reapStat: { mtimeMs: number };\n  try {\n    reapStat = await stat(guardDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n  if (Date.now() - reapStat.mtimeMs < promotionLockStaleMs()) {\n    return false;\n  }\n\n  const staleReapDir = `${guardDir}.stale-${process.pid}-${randomUUID()}`;\n  try {\n    await rename(guardDir, staleReapDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n  await rm(staleReapDir, { recursive: true, force: true });\n  return true;\n}\n\nasync function reapAbandonedPromotionGuards(lockDir: string): Promise<boolean> {\n  const reapedReapGuard = await reapAbandonedPromotionGuard(promotionReapDir(lockDir));\n  const reapedReleaseGuard = await reapAbandonedPromotionGuard(promotionReleaseDir(lockDir));\n  return reapedReapGuard || reapedReleaseGuard;\n}\n\nasync function hasPromotionGuard(lockDir: string): Promise<boolean> {\n  return (await pathExists(promotionReapDir(lockDir))) || (await pathExists(promotionReleaseDir(lockDir)));\n}\n\nasync function reapStalePromotionLock(lockDir: string): Promise<boolean> {\n  if (await hasPromotionGuard(lockDir)) {\n    await reapAbandonedPromotionGuards(lockDir);\n    return false;\n  }\n\n  const reapDir = promotionReapDir(lockDir);\n  try {\n    await mkdir(reapDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"EEXIST\")) return false;\n    throw err;\n  }\n\n  let staleDir: string | null = null;\n  try {\n    return await reapStalePromotionLockWithGuard(lockDir, (value) => {\n      staleDir = value;\n    });\n  } finally {\n    if (staleDir) {\n      await rm(staleDir, { recursive: true, force: true });\n    }\n    await rm(reapDir, { recursive: true, force: true });\n  }\n}\n\nasync function reapStalePromotionLockWithGuard(\n  lockDir: string,\n  setStaleDir: (staleDir: string) => void\n): Promise<boolean> {\n  let lockStat: { mtimeMs: number };\n  try {\n    lockStat = await stat(lockDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n\n  const owner = await readPromotionLockOwner(lockDir);\n  const heartbeatMs = await readPromotionLockHeartbeatMs(lockDir, owner.token);\n  const lockedAtMs = heartbeatMs ?? owner.heartbeatAtMs ?? owner.acquiredAtMs ?? lockStat.mtimeMs;\n  const ownerlessLock = owner.token === null && owner.heartbeatAtMs === null && owner.acquiredAtMs === null;\n  const staleAfterMs = ownerlessLock ? promotionLockOwnerlessGraceMs() : promotionLockStaleMs();\n  if (Date.now() - lockedAtMs < staleAfterMs) {\n    return false;\n  }\n\n  const staleDir = `${lockDir}.stale-${process.pid}-${randomUUID()}`;\n  try {\n    await rename(lockDir, staleDir);\n    setStaleDir(staleDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n\n  const staleOwner = await readPromotionLockOwner(staleDir);\n  const staleHeartbeatMs = await readPromotionLockHeartbeatMs(staleDir, staleOwner.token);\n  const staleLockedAtMs = staleHeartbeatMs ?? staleOwner.heartbeatAtMs ?? staleOwner.acquiredAtMs ?? lockStat.mtimeMs;\n  const staleOwnerlessLock =\n    staleOwner.token === null && staleOwner.heartbeatAtMs === null && staleOwner.acquiredAtMs === null;\n  const staleAfterRecheckMs = staleOwnerlessLock ? promotionLockOwnerlessGraceMs() : promotionLockStaleMs();\n  if (Date.now() - staleLockedAtMs < staleAfterRecheckMs) {\n    await rename(staleDir, lockDir);\n    setStaleDir(\"\");\n    return false;\n  }\n\n  await rm(staleDir, { recursive: true, force: true });\n  setStaleDir(\"\");\n  return true;\n}\n\nasync function releasePromotionLock(lockDir: string, token: string): Promise<void> {\n  const releaseDir = promotionReleaseDir(lockDir);\n  const deadline = Date.now() + promotionLockTimeoutMs();\n  await testHooks?.beforeLockRelease?.(lockDir, token);\n  for (;;) {\n    try {\n      await mkdir(releaseDir);\n      break;\n    } catch (err) {\n      if (!isErrnoCode(err, \"EEXIST\")) {\n        throw err;\n      }\n      const owner = await readPromotionLockOwner(lockDir);\n      if (owner.token !== token) {\n        return;\n      }\n      await reapAbandonedPromotionGuard(releaseDir);\n      if (Date.now() >= deadline) {\n        throw new Error(\"Timed out releasing semantic rule promotion lock\");\n      }\n      await sleep(promotionLockRetryMs());\n    }\n  }\n\n  try {\n    const owner = await readPromotionLockOwner(lockDir);\n    if (owner.token !== token) {\n      return;\n    }\n    await rm(lockDir, { recursive: true, force: true });\n  } finally {\n    await rm(releaseDir, { recursive: true, force: true });\n  }\n}\n\ntype PromotionLockLease = {\n  assertHeld: () => Promise<void>;\n  beforePromotedRuleWrite: () => Promise<void>;\n};\n\nasync function withPromotionLock<T>(\n  memoryDir: string,\n  ruleKey: string,\n  fn: (lease: PromotionLockLease) => Promise<T>\n): Promise<T> {\n  const lockDir = promotionLockDir(memoryDir, ruleKey);\n  const lockRoot = path.dirname(lockDir);\n  const deadline = Date.now() + promotionLockTimeoutMs();\n  let lockToken: string | null = null;\n  let heartbeat: NodeJS.Timeout | null = null;\n\n  await mkdir(lockRoot, { recursive: true });\n  for (;;) {\n    try {\n      if (await hasPromotionGuard(lockDir)) {\n        await reapAbandonedPromotionGuards(lockDir);\n        if (Date.now() >= deadline) {\n          throw new Error(\"Timed out acquiring semantic rule promotion lock\");\n        }\n        await sleep(promotionLockRetryMs());\n        continue;\n      }\n      await mkdir(lockDir);\n      if (await hasPromotionGuard(lockDir)) {\n        await reapAbandonedPromotionGuards(lockDir);\n        if (Date.now() >= deadline) {\n          throw new Error(\"Timed out acquiring semantic rule promotion lock\");\n        }\n        await sleep(promotionLockRetryMs());\n        continue;\n      }\n      try {\n        lockToken = randomUUID();\n        const lockOwner = {\n          token: lockToken,\n          acquiredAt: new Date().toISOString(),\n        };\n        const wroteOwner = await tryWritePromotionLockOwner(lockDir, lockOwner);\n        if (!wroteOwner) {\n          lockToken = null;\n          if (Date.now() >= deadline) {\n            throw new Error(\"Timed out acquiring semantic rule promotion lock\");\n          }\n          await sleep(promotionLockRetryMs());\n          continue;\n        }\n        await writePromotionLockHeartbeat(lockDir, lockToken);\n        const heartbeatToken = lockToken;\n        const heartbeatMs = promotionLockHeartbeatMs();\n        if (heartbeatMs > 0) {\n          heartbeat = setInterval(() => {\n            void refreshPromotionLockHeartbeat(lockDir, heartbeatToken)\n              .then((ownsLock) => {\n                if (!ownsLock && heartbeat) {\n                  clearInterval(heartbeat);\n                  heartbeat = null;\n                }\n              })\n              .catch(() => undefined);\n          }, heartbeatMs);\n        }\n      } catch (err) {\n        lockToken = null;\n        if (heartbeat) {\n          clearInterval(heartbeat);\n          heartbeat = null;\n        }\n        await rm(lockDir, { recursive: true, force: true });\n        throw err;\n      }\n      break;\n    } catch (err) {\n      if (!isErrnoCode(err, \"EEXIST\")) {\n        throw err;\n      }\n      if (await reapStalePromotionLock(lockDir)) {\n        continue;\n      }\n      if (Date.now() >= deadline) {\n        throw new Error(\"Timed out acquiring semantic rule promotion lock\");\n      }\n      await sleep(promotionLockRetryMs());\n    }\n  }\n\n  const assertHeld = async () => {\n    if (!lockToken) {\n      throw new Error(\"Semantic rule promotion lock is no longer held\");\n    }\n    const ownsLock = await refreshPromotionLockHeartbeat(lockDir, lockToken);\n    if (!ownsLock) {\n      throw new Error(\"Semantic rule promotion lock is no longer held\");\n    }\n  };\n\n  let hasResult = false;\n  let result: T | undefined;\n  let callbackError: unknown;\n  let releaseError: unknown;\n  try {\n    await assertHeld();\n    result = await fn({\n      assertHeld,\n      beforePromotedRuleWrite: async () => {\n        if (!lockToken) {\n          throw new Error(\"Semantic rule promotion lock is no longer held\");\n        }\n        await testHooks?.beforePromotedRuleWrite?.(lockDir, lockToken);\n        await assertHeld();\n      },\n    });\n    hasResult = true;\n  } catch (err) {\n    callbackError = err;\n  } finally {\n    if (heartbeat) {\n      clearInterval(heartbeat);\n    }\n    if (lockToken) {\n      try {\n        await releasePromotionLock(lockDir, lockToken);\n      } catch (err) {\n        if (!hasResult && !callbackError) {\n          releaseError = err;\n        }\n      }\n    }\n  }\n  if (releaseError) {\n    throw releaseError;\n  }\n  if (callbackError) {\n    throw callbackError;\n  }\n  return result as T;\n}\n\nfunction normalizeRuleWhitespace(value: string): string {\n  return value.replace(/\\s+/g, \" \").trim();\n}\n\nfunction stripTrailingClausePunctuation(value: string): string {\n  // Linear trailing-punctuation strip (no `/[,:;]+$/` — CodeQL flags that as a\n  // polynomial-backtracking ReDoS on long runs of ',;:'). Walk back once, O(n).\n  let end = value.length;\n  while (end > 0) {\n    const ch = value[end - 1];\n    if (ch === \",\" || ch === \":\" || ch === \";\") end--;\n    else break;\n  }\n  return value.slice(0, end).trim();\n}\n\nfunction canonicalizeRuleContent(value: string): string {\n  return extractExplicitIfThenRule(value) ?? normalizeRuleWhitespace(value);\n}\n\nfunction canonicalizeRuleKey(value: string): string {\n  return canonicalizeRuleContent(value).toLowerCase();\n}\n\nfunction extractExplicitIfThenRule(content: string): string | null {\n  const match = content.match(/\\bif\\b([\\s\\S]+?)\\bthen\\b([\\s\\S]+?)(?:[.!?](?:\\s|$)|$)/i);\n  if (!match) return null;\n  const condition = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[1] ?? \"\"));\n  const outcome = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[2] ?? \"\"));\n  if (condition.length === 0 || outcome.length === 0) return null;\n  return `IF ${condition} THEN ${outcome}.`;\n}\n\nfunction promotionConfidence(memory: MemoryFile): number {\n  const base = Number.isFinite(memory.frontmatter.confidence) ? memory.frontmatter.confidence : 0.8;\n  return Math.max(0.6, Math.min(0.98, base));\n}\n\nfunction promotionTags(memory: MemoryFile): string[] {\n  return Array.from(new Set([...(memory.frontmatter.tags ?? []), \"semantic-rule\", \"promoted-rule\"]));\n}\n\nfunction buildSupportLinks(sourceMemoryId: string, confidence: number): MemoryLink[] {\n  return [\n    {\n      targetId: sourceMemoryId,\n      linkType: \"supports\",\n      strength: confidence,\n      reason: \"Promoted from verified episodic memory\",\n    },\n  ];\n}\n\nexport async function promoteSemanticRuleFromMemory(options: {\n  memoryDir: string;\n  enabled: boolean;\n  sourceMemoryId: string;\n  dryRun?: boolean;\n}): Promise<SemanticRulePromotionReport> {\n  const report: SemanticRulePromotionReport = {\n    enabled: options.enabled,\n    dryRun: options.dryRun === true,\n    promoted: [],\n    skipped: [],\n  };\n  if (!options.enabled) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"disabled\",\n    });\n    return report;\n  }\n\n  const storage = new StorageManager(options.memoryDir);\n  const sourceMemory = await storage.getMemoryById(options.sourceMemoryId);\n  if (!sourceMemory) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-missing\",\n    });\n    return report;\n  }\n  if (sourceMemory.frontmatter.status === \"forgotten\") {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-forgotten\",\n    });\n    return report;\n  }\n  if (sourceMemory.frontmatter.status === \"archived\" || sourceMemory.frontmatter.memoryKind !== \"episode\") {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-not-episode\",\n    });\n    return report;\n  }\n\n  const content = extractExplicitIfThenRule(sourceMemory.content);\n  if (!content) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"no-explicit-rule\",\n    });\n    return report;\n  }\n\n  const ruleKey = canonicalizeRuleKey(content);\n  const confidence = promotionConfidence(sourceMemory);\n  const candidateBase = {\n    sourceMemoryId: options.sourceMemoryId,\n    content,\n    confidence,\n    tags: promotionTags(sourceMemory),\n    memoryKind: \"note\" as const,\n    lineage: [options.sourceMemoryId],\n  };\n\n  return withPromotionLock(options.memoryDir, ruleKey, async (lock) => {\n    storage.invalidateAllMemoriesCacheForDir();\n    const existingRule = (await storage.readAllMemories()).find(\n      (memory) =>\n        memory.frontmatter.category === \"rule\" &&\n        memory.frontmatter.status !== \"archived\" &&\n        memory.frontmatter.status !== \"forgotten\" &&\n        canonicalizeRuleKey(memory.content) === ruleKey\n    );\n    if (existingRule) {\n      report.skipped.push({\n        sourceMemoryId: options.sourceMemoryId,\n        reason: \"duplicate-rule\",\n        existingRuleId: existingRule.frontmatter.id,\n      });\n      return report;\n    }\n\n    if (options.dryRun === true) {\n      await lock.assertHeld();\n      report.promoted.push({\n        id: `dry-run:${options.sourceMemoryId}`,\n        ...candidateBase,\n      });\n      return report;\n    }\n\n    await lock.beforePromotedRuleWrite();\n    const { id: id } = await storage.writeMemory(\"rule\", content, {\n      confidence,\n      tags: candidateBase.tags,\n      source: \"semantic-rule-promotion\",\n      lineage: candidateBase.lineage,\n      sourceMemoryId: options.sourceMemoryId,\n      memoryKind: \"note\",\n      links: buildSupportLinks(options.sourceMemoryId, confidence),\n    });\n    report.promoted.push({\n      id,\n      ...candidateBase,\n    });\n    return report;\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-AWJ2FHCF.js → chunk-X47LWMKA.js}

@@ -6,35 +6,46 @@ import {
 // src/memory-cache.ts
 var hotCacheByDir = /* @__PURE__ */ new Map();
 var archiveCacheByDir = /* @__PURE__ */ new Map();
-function getCachedMemories(baseDir, currentVersion) {
+function sweepExpiredHotEntries(now) {
+  for (const [dir, entry] of hotCacheByDir) {
+    if (entry.ttlMs > 0 && now - entry.loadedAt > entry.ttlMs) hotCacheByDir.delete(dir);
+  }
+}
+function getCachedMemories(baseDir, currentVersion, keyId = "", ttlMs = 0) {
   if (currentVersion === 0) return null;
   const entry = hotCacheByDir.get(baseDir);
-  if (!entry || entry.version !== currentVersion) return null;
+  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    hotCacheByDir.delete(baseDir);
+    return null;
+  }
   return [...entry.memories.values()];
 }
-function setCachedMemories(baseDir, memories, version) {
+function setCachedMemories(baseDir, memories, version, keyId = "", ttlMs = 0) {
   const map = /* @__PURE__ */ new Map();
   for (const m of memories) map.set(m.path, m);
-  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });
+  const now = Date.now();
+  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: now, keyId, ttlMs });
+  sweepExpiredHotEntries(now);
 }
-function updateCacheOnWrite(baseDir, memory) {
+function updateCacheOnWrite(baseDir, memory, keyId = "") {
   const entry = hotCacheByDir.get(baseDir);
-  if (entry) entry.memories.set(memory.path, memory);
+  if (entry && entry.keyId === keyId) entry.memories.set(memory.path, memory);
 }
-function updateCacheOnDelete(baseDir, filePath) {
+function updateCacheOnDelete(baseDir, filePath, keyId = "") {
   const entry = hotCacheByDir.get(baseDir);
-  if (entry) entry.memories.delete(filePath);
+  if (entry && entry.keyId === keyId) entry.memories.delete(filePath);
 }
-function getCachedArchivedMemories(baseDir, currentVersion) {
+function getCachedArchivedMemories(baseDir, currentVersion, keyId = "") {
   if (currentVersion === 0) return null;
   const entry = archiveCacheByDir.get(baseDir);
-  if (!entry || entry.version !== currentVersion) return null;
+  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;
   return [...entry.memories.values()];
 }
-function setCachedArchivedMemories(baseDir, memories, version) {
+function setCachedArchivedMemories(baseDir, memories, version, keyId = "") {
   const map = /* @__PURE__ */ new Map();
   for (const m of memories) map.set(m.path, m);
-  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });
+  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now(), keyId, ttlMs: 0 });
 }
 var entityCacheByDir = /* @__PURE__ */ new Map();
 function normalizeEntitySchemaKey(schemaKey) {
@@ -67,29 +78,37 @@ function invalidateCachedEntities(baseDir) {
 }
 var episodeMapByDir = /* @__PURE__ */ new Map();
 var ruleMemoriesByDir = /* @__PURE__ */ new Map();
-function getCachedEpisodeMap(baseDir, currentVersion) {
+function getCachedEpisodeMap(baseDir, currentVersion, keyId = "", ttlMs = 0) {
   if (currentVersion === 0) return null;
   const entry = episodeMapByDir.get(baseDir);
-  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    episodeMapByDir.delete(baseDir);
+    return null;
+  }
   return entry.data;
 }
-function setCachedEpisodeMap(baseDir, memories, version) {
+function setCachedEpisodeMap(baseDir, memories, version, cache = true, keyId = "") {
   const map = /* @__PURE__ */ new Map();
   for (const m of memories) {
     if (m.frontmatter.status === "archived" || m.frontmatter.status === "forgotten") continue;
     if (m.frontmatter.memoryKind !== "episode") continue;
     map.set(m.frontmatter.id, m);
   }
-  episodeMapByDir.set(baseDir, { data: map, sourceVersion: version });
+  if (cache) episodeMapByDir.set(baseDir, { data: map, sourceVersion: version, keyId, loadedAt: Date.now() });
   return map;
 }
-function getCachedRuleMemories(baseDir, currentVersion) {
+function getCachedRuleMemories(baseDir, currentVersion, keyId = "", ttlMs = 0) {
   if (currentVersion === 0) return null;
   const entry = ruleMemoriesByDir.get(baseDir);
-  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    ruleMemoriesByDir.delete(baseDir);
+    return null;
+  }
   return entry.data;
 }
-function setCachedRuleMemories(baseDir, memories, version) {
+function setCachedRuleMemories(baseDir, memories, version, cache = true, keyId = "") {
   const byId = /* @__PURE__ */ new Map();
   const all = [];
   for (const m of memories) {
@@ -99,7 +118,7 @@ function setCachedRuleMemories(baseDir, memories, version) {
     }
   }
   const result = { all, byId };
-  ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version });
+  if (cache) ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version, keyId, loadedAt: Date.now() });
   return result;
 }
 var QMD_CACHE_TTL_MS = 6e4;
@@ -184,6 +203,14 @@ function invalidateAllForDir(baseDir) {
     layer.invalidateForDir(baseDir);
   }
 }
+function invalidateDerivedAndGlobalForDir(baseDir) {
+  for (const layer of ALL_CACHE_LAYERS) {
+    if (layer.name === "hot-memories" || layer.name === "entities" || layer.name === "archive-memories") {
+      continue;
+    }
+    layer.invalidateForDir(baseDir);
+  }
+}
 function clearMemoryCache(baseDir) {
   if (baseDir) {
     invalidateAllForDir(baseDir);
@@ -222,7 +249,8 @@ export {
   setCachedQmdSearch,
   ALL_CACHE_LAYERS,
   invalidateAllForDir,
+  invalidateDerivedAndGlobalForDir,
   clearMemoryCache,
   getMemoryCacheStats
 };
-//# sourceMappingURL=chunk-AWJ2FHCF.js.map
+//# sourceMappingURL=chunk-X47LWMKA.js.map

package/dist/chunk-X47LWMKA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-cache.ts"],"sourcesContent":["import type { EntityFile, MemoryFile } from \"./types.js\";\nimport { clearQmdRecallCache, qmdRecallCacheSize } from \"./qmd-recall-cache.js\";\n\ninterface CacheEntry {\n  memories: Map<string, MemoryFile>; // keyed by file path\n  version: number;\n  loadedAt: number;\n  // Secure-store key identity that decrypted these memories (issue #1902, Codex\n  // P1). \"\" for plaintext/locked stores. A manager only reads an entry whose\n  // keyId matches its own, so a locked/unkeyed instance never sees content\n  // another instance decrypted under a key for the same baseDir.\n  keyId: string;\n  // Effective TTL (ms) this entry was stored under (issue #1902, Codex Medium),\n  // so the opportunistic sweep can evict abandoned corpora that are never\n  // revisited. 0 = no TTL (never swept by age).\n  ttlMs: number;\n}\n\n// Module-level singleton — shared across all StorageManager instances and sessions\nconst hotCacheByDir = new Map<string, CacheEntry>();\nconst archiveCacheByDir = new Map<string, CacheEntry>();\n\n/**\n * Evict every hot entry whose own TTL has elapsed (issue #1902, Codex Medium).\n * Called opportunistically on each set so a long-running process that reads many\n * namespace/temporary roots and never revisits some of them still releases their\n * (potentially hundreds-of-MB) corpora within the TTL, instead of holding them\n * resident until an explicit global clear. O(entries) over a small map.\n */\nfunction sweepExpiredHotEntries(now: number): void {\n  for (const [dir, entry] of hotCacheByDir) {\n    if (entry.ttlMs > 0 && now - entry.loadedAt > entry.ttlMs) hotCacheByDir.delete(dir);\n  }\n}\n\nexport function getCachedMemories(\n  baseDir: string,\n  currentVersion: number,\n  keyId = \"\",\n  ttlMs = 0,\n): MemoryFile[] | null {\n  // Don't serve from cache when version tracking is unavailable (version=0).\n  // This ensures tests and fresh installs without a version file always read disk.\n  if (currentVersion === 0) return null;\n  const entry = hotCacheByDir.get(baseDir);\n  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;\n  // TTL safety net (issue #1902): bound staleness from external filesystem edits\n  // that bypass the version sentinel. ttlMs <= 0 disables the check. On expiry\n  // evict the entry (not just return null) so a revisited-but-stale dir releases\n  // its resident corpus instead of lingering until an explicit clear.\n  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {\n    hotCacheByDir.delete(baseDir);\n    return null;\n  }\n  return [...entry.memories.values()];\n}\n\nexport function setCachedMemories(\n  baseDir: string,\n  memories: MemoryFile[],\n  version: number,\n  keyId = \"\",\n  ttlMs = 0,\n): void {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) map.set(m.path, m);\n  const now = Date.now();\n  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: now, keyId, ttlMs });\n  // Release abandoned corpora that expired but were never revisited (Codex Medium).\n  sweepExpiredHotEntries(now);\n}\n\nexport function updateCacheOnWrite(baseDir: string, memory: MemoryFile, keyId = \"\"): void {\n  const entry = hotCacheByDir.get(baseDir);\n  // Only mutate an entry that belongs to THIS key identity (issue #1902, Codex\n  // Medium). A concurrent differently-keyed manager may have replaced the\n  // single hotCacheByDir slot during an awaited parse; inserting our decrypted\n  // MemoryFile into its entry would leak plaintext across the key boundary.\n  if (entry && entry.keyId === keyId) entry.memories.set(memory.path, memory);\n}\n\nexport function updateCacheOnDelete(baseDir: string, filePath: string, keyId = \"\"): void {\n  const entry = hotCacheByDir.get(baseDir);\n  if (entry && entry.keyId === keyId) entry.memories.delete(filePath);\n}\n// Archive cache — same pattern, separate store\nexport function getCachedArchivedMemories(\n  baseDir: string,\n  currentVersion: number,\n  keyId = \"\",\n): MemoryFile[] | null {\n  if (currentVersion === 0) return null;\n  const entry = archiveCacheByDir.get(baseDir);\n  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;\n  return [...entry.memories.values()];\n}\n\nexport function setCachedArchivedMemories(\n  baseDir: string,\n  memories: MemoryFile[],\n  version: number,\n  keyId = \"\",\n): void {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) map.set(m.path, m);\n  // ttlMs: 0 — the archive cache has no age TTL; it is version-keyed and cleared\n  // via invalidation. The field satisfies the shared CacheEntry shape (#1902).\n  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now(), keyId, ttlMs: 0 });\n}\n\n// Entity cache — same pattern as memory cache, but keyed by schema-aware parse inputs.\nconst entityCacheByDir = new Map<string, { entities: EntityFile[]; version: number; loadedAt: number }>();\n\n/**\n * Single normalization point for the entity-cache schema key (issue #1535).\n * BOTH the set/get key builder and the prefix invalidation derive from here so\n * `undefined` vs `\"\"` (or any future normalization rule) can never diverge\n * between the write path and the invalidate path (rule 38 cousin).\n */\nfunction normalizeEntitySchemaKey(schemaKey: string | undefined): string {\n  return schemaKey ?? \"\";\n}\n\n/** Prefix shared by every entity-cache key for a dir, regardless of schemaKey. */\nfunction entityCacheKeyPrefix(baseDir: string): string {\n  return `${baseDir}\\u0000`;\n}\n\nfunction buildEntityCacheKey(baseDir: string, schemaKey?: string): string {\n  return `${entityCacheKeyPrefix(baseDir)}${normalizeEntitySchemaKey(schemaKey)}`;\n}\n\nexport function getCachedEntities(\n  baseDir: string,\n  currentVersion: number,\n  schemaKey: string = \"\",\n): EntityFile[] | null {\n  if (currentVersion === 0) return null;\n  const entry = entityCacheByDir.get(buildEntityCacheKey(baseDir, schemaKey));\n  if (!entry || entry.version !== currentVersion) return null;\n  return entry.entities;\n}\n\nexport function setCachedEntities(\n  baseDir: string,\n  entities: EntityFile[],\n  version: number,\n  schemaKey: string = \"\",\n): void {\n  entityCacheByDir.set(buildEntityCacheKey(baseDir, schemaKey), {\n    entities,\n    version,\n    loadedAt: Date.now(),\n  });\n}\n\nexport function invalidateCachedEntities(baseDir: string): void {\n  const prefix = entityCacheKeyPrefix(baseDir);\n  for (const key of entityCacheByDir.keys()) {\n    if (key.startsWith(prefix)) entityCacheByDir.delete(key);\n  }\n}\n\n// Derived caches — pre-filtered views invalidated alongside the main cache.\n// These avoid O(146K) filter+map on every verified recall/rules call.\ninterface DerivedCacheEntry<T> {\n  data: T;\n  sourceVersion: number; // matches the hot cache version it was derived from\n  keyId: string; // secure-store key identity of the corpus it was derived from (#1902)\n  loadedAt: number; // build time — bounds staleness from external edits via ttlMs (#1902)\n}\n\nconst episodeMapByDir = new Map<string, DerivedCacheEntry<Map<string, MemoryFile>>>();\nconst ruleMemoriesByDir = new Map<string, DerivedCacheEntry<{ all: MemoryFile[]; byId: Map<string, MemoryFile> }>>();\n\nexport function getCachedEpisodeMap(\n  baseDir: string,\n  currentVersion: number,\n  keyId = \"\",\n  ttlMs = 0,\n): Map<string, MemoryFile> | null {\n  if (currentVersion === 0) return null;\n  const entry = episodeMapByDir.get(baseDir);\n  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;\n  // TTL safety net (issue #1902): the version sentinel doesn't move on a direct\n  // external edit, so bound how long a derived view is served before a rebuild\n  // (which re-reads via readAllMemories, itself TTL-bounded). ttlMs <= 0 disables.\n  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {\n    episodeMapByDir.delete(baseDir);\n    return null;\n  }\n  return entry.data;\n}\n\n/** Build and cache the episode memory map from the full memory list. */\nexport function setCachedEpisodeMap(\n  baseDir: string,\n  memories: MemoryFile[],\n  version: number,\n  cache = true,\n  keyId = \"\",\n): Map<string, MemoryFile> {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) {\n    if (m.frontmatter.status === \"archived\" || m.frontmatter.status === \"forgotten\") continue;\n    if (m.frontmatter.memoryKind !== \"episode\") continue;\n    map.set(m.frontmatter.id, m);\n  }\n  if (cache) episodeMapByDir.set(baseDir, { data: map, sourceVersion: version, keyId, loadedAt: Date.now() });\n  return map;\n}\n\n/** Get pre-filtered rule memories. Derived from hot cache. */\nexport function getCachedRuleMemories(\n  baseDir: string,\n  currentVersion: number,\n  keyId = \"\",\n  ttlMs = 0,\n): { all: MemoryFile[]; byId: Map<string, MemoryFile> } | null {\n  if (currentVersion === 0) return null;\n  const entry = ruleMemoriesByDir.get(baseDir);\n  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;\n  // TTL safety net (issue #1902): bound staleness from direct external edits\n  // that don't move the version sentinel. ttlMs <= 0 disables.\n  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {\n    ruleMemoriesByDir.delete(baseDir);\n    return null;\n  }\n  return entry.data;\n}\n\n/** Build and cache the rule memories from the full memory list. */\nexport function setCachedRuleMemories(\n  baseDir: string,\n  memories: MemoryFile[],\n  version: number,\n  cache = true,\n  keyId = \"\",\n): { all: MemoryFile[]; byId: Map<string, MemoryFile> } {\n  const byId = new Map<string, MemoryFile>();\n  const all: MemoryFile[] = [];\n  for (const m of memories) {\n    byId.set(m.frontmatter.id, m);\n    if (\n      m.frontmatter.category === \"rule\" &&\n      m.frontmatter.status !== \"archived\" &&\n      m.frontmatter.status !== \"forgotten\"\n    ) {\n      all.push(m);\n    }\n  }\n  const result = { all, byId };\n  if (cache) ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version, keyId, loadedAt: Date.now() });\n  return result;\n}\n\n// QMD search result cache — short-lived (60s TTL) to avoid stale results\n// while reducing redundant daemon calls for repeated/similar queries.\ninterface QmdCacheEntry {\n  results: unknown[];\n  cachedAt: number;\n}\nconst QMD_CACHE_TTL_MS = 60_000;\nconst qmdSearchCache = new Map<string, QmdCacheEntry>();\n\nexport function getCachedQmdSearch(cacheKey: string): unknown[] | null {\n  const entry = qmdSearchCache.get(cacheKey);\n  if (!entry) return null;\n  if (Date.now() - entry.cachedAt > QMD_CACHE_TTL_MS) {\n    qmdSearchCache.delete(cacheKey);\n    return null;\n  }\n  return entry.results;\n}\n\nexport function setCachedQmdSearch(cacheKey: string, results: unknown[]): void {\n  qmdSearchCache.set(cacheKey, { results, cachedAt: Date.now() });\n  // Evict old entries to prevent unbounded growth\n  if (qmdSearchCache.size > 200) {\n    const now = Date.now();\n    for (const [key, entry] of qmdSearchCache) {\n      if (now - entry.cachedAt > QMD_CACHE_TTL_MS) qmdSearchCache.delete(key);\n    }\n  }\n}\n\n/**\n * Cache-layer registry (issue #1535).\n *\n * EVERY process-level cache that can serve memory-derived content is\n * enumerated here, and the single invalidation chokepoint\n * (`invalidateAllForDir`) iterates this list. Adding a new cache layer to\n * this module (or qmd-recall-cache.ts) REQUIRES registering it here —\n * otherwise mutations will never invalidate it (the exact bug this registry\n * exists to prevent) and the enumerate-all-layers fitness test in\n * tests/cache-invalidation-coherence.test.ts fails.\n */\nexport interface MemoryCacheLayer {\n  /** Stable identifier used by tests and diagnostics. */\n  readonly name: string;\n  /** \"dir\" layers evict only entries for the given baseDir. \"global\" layers\n   *  are fully cleared on any mutation: their keys embed queries, namespaces,\n   *  and strategies rather than a storage dir, so a per-dir selective clear\n   *  is not possible without recording the dir in each entry. Full clear is\n   *  the simple-and-correct choice — these caches are re-warmable\n   *  (issue #1535, implementation guide option (b)). */\n  readonly scope: \"dir\" | \"global\";\n  /** Evict entries for baseDir (\"dir\" scope) or everything (\"global\" scope). */\n  readonly invalidateForDir: (baseDir: string) => void;\n  /** Evict every entry across all dirs. */\n  readonly clearAll: () => void;\n  /** True when the layer still holds entries for baseDir (\"dir\" scope) or\n   *  any entries at all (\"global\" scope). */\n  readonly hasEntriesFor: (baseDir: string) => boolean;\n}\n\nexport const ALL_CACHE_LAYERS: readonly MemoryCacheLayer[] = [\n  {\n    name: \"hot-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void hotCacheByDir.delete(baseDir),\n    clearAll: () => hotCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => hotCacheByDir.has(baseDir),\n  },\n  {\n    name: \"archive-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void archiveCacheByDir.delete(baseDir),\n    clearAll: () => archiveCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => archiveCacheByDir.has(baseDir),\n  },\n  {\n    name: \"entities\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => invalidateCachedEntities(baseDir),\n    clearAll: () => entityCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => {\n      const prefix = entityCacheKeyPrefix(baseDir);\n      for (const key of entityCacheByDir.keys()) {\n        if (key.startsWith(prefix)) return true;\n      }\n      return false;\n    },\n  },\n  {\n    name: \"derived-episode-map\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void episodeMapByDir.delete(baseDir),\n    clearAll: () => episodeMapByDir.clear(),\n    hasEntriesFor: (baseDir) => episodeMapByDir.has(baseDir),\n  },\n  {\n    name: \"derived-rule-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void ruleMemoriesByDir.delete(baseDir),\n    clearAll: () => ruleMemoriesByDir.clear(),\n    hasEntriesFor: (baseDir) => ruleMemoriesByDir.has(baseDir),\n  },\n  {\n    name: \"qmd-search\",\n    scope: \"global\",\n    invalidateForDir: () => qmdSearchCache.clear(),\n    clearAll: () => qmdSearchCache.clear(),\n    hasEntriesFor: () => qmdSearchCache.size > 0,\n  },\n  {\n    name: \"qmd-recall\",\n    scope: \"global\",\n    invalidateForDir: () => clearQmdRecallCache(),\n    clearAll: () => clearQmdRecallCache(),\n    hasEntriesFor: () => qmdRecallCacheSize() > 0,\n  },\n];\n\n/**\n * The single invalidation chokepoint (issue #1535, rule 37).\n *\n * Every memory/entity mutation path must route through this function —\n * storage.ts calls it from its internal invalidation funnels\n * (invalidateAllMemoriesCache / invalidateColdMemoriesCache /\n * bumpMemoryStatusVersion / setSecureStoreKey). Nothing may clear an\n * individual layer ad hoc: partial clears are how the stale-recall bug\n * happened (qmdRecallCache was never invalidated on mutations, so recall\n * served pre-edit bundles for the remainder of its fresh/stale TTL window).\n */\nexport function invalidateAllForDir(baseDir: string): void {\n  for (const layer of ALL_CACHE_LAYERS) {\n    layer.invalidateForDir(baseDir);\n  }\n}\n\n/**\n * Invalidate every cache layer for `baseDir` EXCEPT the hot-memories layer\n * (issue #1902). Single-file write paths use this instead of\n * `invalidateAllForDir` because they patch the hot-memories entry in place\n * (via `updateCacheOnWrite`/`updateCacheOnDelete`) and re-key it to the bumped\n * version — so dropping it here would defeat the whole warm-cache fast path.\n * The derived episode/rule views and the global QMD caches are cheap to\n * rebuild and are not patched, so they are still evicted here. Every other\n * layer remains reachable for the wholesale `invalidateAllForDir` /\n * `clearMemoryCache` chokepoint used by bulk/ambiguous mutations.\n */\nexport function invalidateDerivedAndGlobalForDir(baseDir: string): void {\n  // Preserve the layers a single-file write intentionally keeps warm (issue\n  // #1902, Codex Medium): hot-memories is patched + re-keyed in place; the\n  // entities layer is keyed on memory-status, which plain create/content writes\n  // deliberately do NOT bump (so entity retrieval stays warm); and the\n  // archive-memories layer is version-keyed on the archive tier, untouched by a\n  // hot-tier write. Evict ONLY the derived (episode/rule) and global (QMD) views.\n  for (const layer of ALL_CACHE_LAYERS) {\n    if (\n      layer.name === \"hot-memories\" ||\n      layer.name === \"entities\" ||\n      layer.name === \"archive-memories\"\n    ) {\n      continue;\n    }\n    layer.invalidateForDir(baseDir);\n  }\n}\n\nexport function clearMemoryCache(baseDir?: string): void {\n  if (baseDir) {\n    invalidateAllForDir(baseDir);\n    return;\n  }\n  for (const layer of ALL_CACHE_LAYERS) {\n    layer.clearAll();\n  }\n}\n\nexport function getMemoryCacheStats(baseDir: string): {\n  hotSize: number;\n  archiveSize: number;\n  hotVersion: number | null;\n  archiveVersion: number | null;\n} {\n  const hot = hotCacheByDir.get(baseDir);\n  const archive = archiveCacheByDir.get(baseDir);\n  return {\n    hotSize: hot?.memories.size ?? 0,\n    archiveSize: archive?.memories.size ?? 0,\n    hotVersion: hot?.version ?? null,\n    archiveVersion: archive?.version ?? null,\n  };\n}\n"],"mappings":";;;;;;AAmBA,IAAM,gBAAgB,oBAAI,IAAwB;AAClD,IAAM,oBAAoB,oBAAI,IAAwB;AAStD,SAAS,uBAAuB,KAAmB;AACjD,aAAW,CAAC,KAAK,KAAK,KAAK,eAAe;AACxC,QAAI,MAAM,QAAQ,KAAK,MAAM,MAAM,WAAW,MAAM,MAAO,eAAc,OAAO,GAAG;AAAA,EACrF;AACF;AAEO,SAAS,kBACd,SACA,gBACA,QAAQ,IACR,QAAQ,GACa;AAGrB,MAAI,mBAAmB,EAAG,QAAO;AACjC,QAAM,QAAQ,cAAc,IAAI,OAAO;AACvC,MAAI,CAAC,SAAS,MAAM,YAAY,kBAAkB,MAAM,UAAU,MAAO,QAAO;AAKhF,MAAI,QAAQ,KAAK,KAAK,IAAI,IAAI,MAAM,WAAW,OAAO;AACpD,kBAAc,OAAO,OAAO;AAC5B,WAAO;AAAA,EACT;AACA,SAAO,CAAC,GAAG,MAAM,SAAS,OAAO,CAAC;AACpC;AAEO,SAAS,kBACd,SACA,UACA,SACA,QAAQ,IACR,QAAQ,GACF;AACN,QAAM,MAAM,oBAAI,IAAwB;AACxC,aAAW,KAAK,SAAU,KAAI,IAAI,EAAE,MAAM,CAAC;AAC3C,QAAM,MAAM,KAAK,IAAI;AACrB,gBAAc,IAAI,SAAS,EAAE,UAAU,KAAK,SAAS,UAAU,KAAK,OAAO,MAAM,CAAC;AAElF,yBAAuB,GAAG;AAC5B;AAEO,SAAS,mBAAmB,SAAiB,QAAoB,QAAQ,IAAU;AACxF,QAAM,QAAQ,cAAc,IAAI,OAAO;AAKvC,MAAI,SAAS,MAAM,UAAU,MAAO,OAAM,SAAS,IAAI,OAAO,MAAM,MAAM;AAC5E;AAEO,SAAS,oBAAoB,SAAiB,UAAkB,QAAQ,IAAU;AACvF,QAAM,QAAQ,cAAc,IAAI,OAAO;AACvC,MAAI,SAAS,MAAM,UAAU,MAAO,OAAM,SAAS,OAAO,QAAQ;AACpE;AAEO,SAAS,0BACd,SACA,gBACA,QAAQ,IACa;AACrB,MAAI,mBAAmB,EAAG,QAAO;AACjC,QAAM,QAAQ,kBAAkB,IAAI,OAAO;AAC3C,MAAI,CAAC,SAAS,MAAM,YAAY,kBAAkB,MAAM,UAAU,MAAO,QAAO;AAChF,SAAO,CAAC,GAAG,MAAM,SAAS,OAAO,CAAC;AACpC;AAEO,SAAS,0BACd,SACA,UACA,SACA,QAAQ,IACF;AACN,QAAM,MAAM,oBAAI,IAAwB;AACxC,aAAW,KAAK,SAAU,KAAI,IAAI,EAAE,MAAM,CAAC;AAG3C,oBAAkB,IAAI,SAAS,EAAE,UAAU,KAAK,SAAS,UAAU,KAAK,IAAI,GAAG,OAAO,OAAO,EAAE,CAAC;AAClG;AAGA,IAAM,mBAAmB,oBAAI,IAA2E;AAQxG,SAAS,yBAAyB,WAAuC;AACvE,SAAO,aAAa;AACtB;AAGA,SAAS,qBAAqB,SAAyB;AACrD,SAAO,GAAG,OAAO;AACnB;AAEA,SAAS,oBAAoB,SAAiB,WAA4B;AACxE,SAAO,GAAG,qBAAqB,OAAO,CAAC,GAAG,yBAAyB,SAAS,CAAC;AAC/E;AAEO,SAAS,kBACd,SACA,gBACA,YAAoB,IACC;AACrB,MAAI,mBAAmB,EAAG,QAAO;AACjC,QAAM,QAAQ,iBAAiB,IAAI,oBAAoB,SAAS,SAAS,CAAC;AAC1E,MAAI,CAAC,SAAS,MAAM,YAAY,eAAgB,QAAO;AACvD,SAAO,MAAM;AACf;AAEO,SAAS,kBACd,SACA,UACA,SACA,YAAoB,IACd;AACN,mBAAiB,IAAI,oBAAoB,SAAS,SAAS,GAAG;AAAA,IAC5D;AAAA,IACA;AAAA,IACA,UAAU,KAAK,IAAI;AAAA,EACrB,CAAC;AACH;AAEO,SAAS,yBAAyB,SAAuB;AAC9D,QAAM,SAAS,qBAAqB,OAAO;AAC3C,aAAW,OAAO,iBAAiB,KAAK,GAAG;AACzC,QAAI,IAAI,WAAW,MAAM,EAAG,kBAAiB,OAAO,GAAG;AAAA,EACzD;AACF;AAWA,IAAM,kBAAkB,oBAAI,IAAwD;AACpF,IAAM,oBAAoB,oBAAI,IAAqF;AAE5G,SAAS,oBACd,SACA,gBACA,QAAQ,IACR,QAAQ,GACwB;AAChC,MAAI,mBAAmB,EAAG,QAAO;AACjC,QAAM,QAAQ,gBAAgB,IAAI,OAAO;AACzC,MAAI,CAAC,SAAS,MAAM,kBAAkB,kBAAkB,MAAM,UAAU,MAAO,QAAO;AAItF,MAAI,QAAQ,KAAK,KAAK,IAAI,IAAI,MAAM,WAAW,OAAO;AACpD,oBAAgB,OAAO,OAAO;AAC9B,WAAO;AAAA,EACT;AACA,SAAO,MAAM;AACf;AAGO,SAAS,oBACd,SACA,UACA,SACA,QAAQ,MACR,QAAQ,IACiB;AACzB,QAAM,MAAM,oBAAI,IAAwB;AACxC,aAAW,KAAK,UAAU;AACxB,QAAI,EAAE,YAAY,WAAW,cAAc,EAAE,YAAY,WAAW,YAAa;AACjF,QAAI,EAAE,YAAY,eAAe,UAAW;AAC5C,QAAI,IAAI,EAAE,YAAY,IAAI,CAAC;AAAA,EAC7B;AACA,MAAI,MAAO,iBAAgB,IAAI,SAAS,EAAE,MAAM,KAAK,eAAe,SAAS,OAAO,UAAU,KAAK,IAAI,EAAE,CAAC;AAC1G,SAAO;AACT;AAGO,SAAS,sBACd,SACA,gBACA,QAAQ,IACR,QAAQ,GACqD;AAC7D,MAAI,mBAAmB,EAAG,QAAO;AACjC,QAAM,QAAQ,kBAAkB,IAAI,OAAO;AAC3C,MAAI,CAAC,SAAS,MAAM,kBAAkB,kBAAkB,MAAM,UAAU,MAAO,QAAO;AAGtF,MAAI,QAAQ,KAAK,KAAK,IAAI,IAAI,MAAM,WAAW,OAAO;AACpD,sBAAkB,OAAO,OAAO;AAChC,WAAO;AAAA,EACT;AACA,SAAO,MAAM;AACf;AAGO,SAAS,sBACd,SACA,UACA,SACA,QAAQ,MACR,QAAQ,IAC8C;AACtD,QAAM,OAAO,oBAAI,IAAwB;AACzC,QAAM,MAAoB,CAAC;AAC3B,aAAW,KAAK,UAAU;AACxB,SAAK,IAAI,EAAE,YAAY,IAAI,CAAC;AAC5B,QACE,EAAE,YAAY,aAAa,UAC3B,EAAE,YAAY,WAAW,cACzB,EAAE,YAAY,WAAW,aACzB;AACA,UAAI,KAAK,CAAC;AAAA,IACZ;AAAA,EACF;AACA,QAAM,SAAS,EAAE,KAAK,KAAK;AAC3B,MAAI,MAAO,mBAAkB,IAAI,SAAS,EAAE,MAAM,QAAQ,eAAe,SAAS,OAAO,UAAU,KAAK,IAAI,EAAE,CAAC;AAC/G,SAAO;AACT;AAQA,IAAM,mBAAmB;AACzB,IAAM,iBAAiB,oBAAI,IAA2B;AAE/C,SAAS,mBAAmB,UAAoC;AACrE,QAAM,QAAQ,eAAe,IAAI,QAAQ;AACzC,MAAI,CAAC,MAAO,QAAO;AACnB,MAAI,KAAK,IAAI,IAAI,MAAM,WAAW,kBAAkB;AAClD,mBAAe,OAAO,QAAQ;AAC9B,WAAO;AAAA,EACT;AACA,SAAO,MAAM;AACf;AAEO,SAAS,mBAAmB,UAAkB,SAA0B;AAC7E,iBAAe,IAAI,UAAU,EAAE,SAAS,UAAU,KAAK,IAAI,EAAE,CAAC;AAE9D,MAAI,eAAe,OAAO,KAAK;AAC7B,UAAM,MAAM,KAAK,IAAI;AACrB,eAAW,CAAC,KAAK,KAAK,KAAK,gBAAgB;AACzC,UAAI,MAAM,MAAM,WAAW,iBAAkB,gBAAe,OAAO,GAAG;AAAA,IACxE;AAAA,EACF;AACF;AAgCO,IAAM,mBAAgD;AAAA,EAC3D;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,CAAC,YAAY,KAAK,cAAc,OAAO,OAAO;AAAA,IAChE,UAAU,MAAM,cAAc,MAAM;AAAA,IACpC,eAAe,CAAC,YAAY,cAAc,IAAI,OAAO;AAAA,EACvD;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,CAAC,YAAY,KAAK,kBAAkB,OAAO,OAAO;AAAA,IACpE,UAAU,MAAM,kBAAkB,MAAM;AAAA,IACxC,eAAe,CAAC,YAAY,kBAAkB,IAAI,OAAO;AAAA,EAC3D;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,CAAC,YAAY,yBAAyB,OAAO;AAAA,IAC/D,UAAU,MAAM,iBAAiB,MAAM;AAAA,IACvC,eAAe,CAAC,YAAY;AAC1B,YAAM,SAAS,qBAAqB,OAAO;AAC3C,iBAAW,OAAO,iBAAiB,KAAK,GAAG;AACzC,YAAI,IAAI,WAAW,MAAM,EAAG,QAAO;AAAA,MACrC;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,CAAC,YAAY,KAAK,gBAAgB,OAAO,OAAO;AAAA,IAClE,UAAU,MAAM,gBAAgB,MAAM;AAAA,IACtC,eAAe,CAAC,YAAY,gBAAgB,IAAI,OAAO;AAAA,EACzD;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,CAAC,YAAY,KAAK,kBAAkB,OAAO,OAAO;AAAA,IACpE,UAAU,MAAM,kBAAkB,MAAM;AAAA,IACxC,eAAe,CAAC,YAAY,kBAAkB,IAAI,OAAO;AAAA,EAC3D;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,MAAM,eAAe,MAAM;AAAA,IAC7C,UAAU,MAAM,eAAe,MAAM;AAAA,IACrC,eAAe,MAAM,eAAe,OAAO;AAAA,EAC7C;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,OAAO;AAAA,IACP,kBAAkB,MAAM,oBAAoB;AAAA,IAC5C,UAAU,MAAM,oBAAoB;AAAA,IACpC,eAAe,MAAM,mBAAmB,IAAI;AAAA,EAC9C;AACF;AAaO,SAAS,oBAAoB,SAAuB;AACzD,aAAW,SAAS,kBAAkB;AACpC,UAAM,iBAAiB,OAAO;AAAA,EAChC;AACF;AAaO,SAAS,iCAAiC,SAAuB;AAOtE,aAAW,SAAS,kBAAkB;AACpC,QACE,MAAM,SAAS,kBACf,MAAM,SAAS,cACf,MAAM,SAAS,oBACf;AACA;AAAA,IACF;AACA,UAAM,iBAAiB,OAAO;AAAA,EAChC;AACF;AAEO,SAAS,iBAAiB,SAAwB;AACvD,MAAI,SAAS;AACX,wBAAoB,OAAO;AAC3B;AAAA,EACF;AACA,aAAW,SAAS,kBAAkB;AACpC,UAAM,SAAS;AAAA,EACjB;AACF;AAEO,SAAS,oBAAoB,SAKlC;AACA,QAAM,MAAM,cAAc,IAAI,OAAO;AACrC,QAAM,UAAU,kBAAkB,IAAI,OAAO;AAC7C,SAAO;AAAA,IACL,SAAS,KAAK,SAAS,QAAQ;AAAA,IAC/B,aAAa,SAAS,SAAS,QAAQ;AAAA,IACvC,YAAY,KAAK,WAAW;AAAA,IAC5B,gBAAgB,SAAS,WAAW;AAAA,EACtC;AACF;","names":[]}

package/dist/{chunk-VMGMY2AI.js → chunk-XF4KOVDK.js}

@@ -3,10 +3,10 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-O3BZ6PFY.js";
+} from "./chunk-JZM5QUTE.js";
 import {
   listNamespaces
-} from "./chunk-ZHKD4EZM.js";
+} from "./chunk-VCEH5UYS.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -32,23 +32,23 @@ import {
 } from "./chunk-MRHFJV44.js";
 import {
   runConsolidationProvenanceCheck
-} from "./chunk-7XH7VJN4.js";
+} from "./chunk-5S7Z5SHA.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-EJCVMPIM.js";
+} from "./chunk-7LMEY5KZ.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-ZUFJ7ZTR.js";
+} from "./chunk-L4H6MQ7I.js";
 import {
   analyzeGraphHealth
 } from "./chunk-OBMR4VIX.js";
 import {
   StorageManager
-} from "./chunk-KTOH7EJE.js";
+} from "./chunk-KXLRMM35.js";
 import {
   probeProjectionHealth
 } from "./chunk-RHOZ5LLO.js";
@@ -1464,7 +1464,7 @@ async function runOperatorInventory(options) {
   let quarantined = 0;
   let rejected = 0;
   for (const entry of uniqueRootEntries.values()) {
-    const storage = new StorageManager(entry.rootDir);
+    const storage = new StorageManager(entry.rootDir, void 0, false);
     const memories = await storage.readAllMemories();
     const entities = await storage.readAllEntityFiles();
     namespaces.push({
@@ -1671,4 +1671,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-VMGMY2AI.js.map
+//# sourceMappingURL=chunk-XF4KOVDK.js.map