@remnic/core 9.3.663 → 9.3.665

package/src/training-export/converter.test.ts

@@ -502,4 +502,23 @@ describe("convertMemoriesToRecords", () => {
       ["a", "b", "c"],
     );
   });
+
+  it("exports memories under category dirs beyond facts/ (issue #1546)", async () => {
+    const dir = await makeTmpDir();
+    // A decision routed into decisions/<date>/ must appear in the export, not
+    // just facts/ + corrections/.
+    await writeSyntheticMemory(dir, "decisions/2026-02-22", "decision-1.md", {
+      id: "decision-1",
+      category: "decision",
+      content: "We chose blue-green deploys.",
+    });
+    await writeSyntheticMemory(dir, "facts/2026-02-22", "fact-1.md", {
+      id: "fact-1",
+      content: "The worker retries three times.",
+    });
+
+    const records = await convertMemoriesToRecords({ memoryDir: dir });
+    const ids = records.map((r) => r.sourceIds?.[0]).sort();
+    assert.deepEqual(ids, ["decision-1", "fact-1"]);
+  });
 });

package/src/training-export/converter.ts

@@ -15,6 +15,7 @@ import path from "node:path";
 
 import { parseStrictCliDate } from "./date-parse.js";
 import type { TrainingExportOptions, TrainingExportRecord } from "./types.js";
+import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 
 // ---------------------------------------------------------------------------
 // Frontmatter parsing (mirrors storage.ts but kept standalone)
@@ -266,12 +267,14 @@ export async function convertMemoriesToRecords(
   const containmentRoot = await safeRealpath(memoryDir);
   if (!containmentRoot) return [];
 
-  // Collect from facts/ and corrections/ subdirectories (mirrors storage.ts)
-  const factsDir = path.join(memoryDir, "facts");
-  const correctionsDir = path.join(memoryDir, "corrections");
-
-  const dirs = [factsDir, correctionsDir];
+  // Collect from every recall category directory (RECALL_FALLBACK_DIRS — the
+  // single source of truth), so newly-routed categories (decisions/,
+  // preferences/, ...) are exported, not just facts/ + corrections/ (#1546).
+  // collectMarkdownFiles recurses, so flat (corrections/) vs dated
+  // (decisions/<date>/) layouts are both handled.
+  const dirs = RECALL_FALLBACK_DIRS.map((dir) => path.join(memoryDir, dir));
   if (options.includeEntities) {
+    // entities/ is NOT a recall category — it stays a separate opt-in include.
     dirs.push(path.join(memoryDir, "entities"));
   }
 

package/src/utils/category-dir.ts

@@ -60,13 +60,19 @@ export const ALL_CATEGORY_KEYS: string[] = [
   ...Object.keys(CATEGORY_DIR_MAP),
 ];
 
+/**
+ * Relative directory NAME for a category (e.g. "decisions"); "facts" for
+ * unknown / `fact` / `entity`. Single source of truth shared by every write,
+ * path-derivation, and tier-move site — never inline a category→dir ternary.
+ */
+export function categoryDirName(category: string): string {
+  return Object.hasOwn(CATEGORY_DIR_MAP, category) ? CATEGORY_DIR_MAP[category] : "facts";
+}
+
 /**
  * Resolve a category name to its directory path under memoryDir.
  * Falls back to `facts/` for unknown categories.
  */
 export function getCategoryDir(memoryDir: string, category: string): string {
-  const dir = Object.hasOwn(CATEGORY_DIR_MAP, category)
-    ? CATEGORY_DIR_MAP[category]
-    : undefined;
-  return dir ? path.join(memoryDir, dir) : path.join(memoryDir, "facts");
+  return path.join(memoryDir, categoryDirName(category));
 }

package/src/utils/path-containment.ts

@@ -0,0 +1,40 @@
+/**
+ * @remnic/core — Path Containment Guards
+ *
+ * Shared symlink/traversal containment helpers for filesystem walkers that
+ * scan the memory store. Extracted from search/document-scanner.ts so every
+ * walker (the search index scanner, the CLI dedupe walker, ...) enforces the
+ * SAME containment semantics instead of forking the check (CLAUDE.md rule 22).
+ *
+ * Both helpers operate on realpath()-resolved absolute paths: callers resolve
+ * symlinks first, then assert the resolved target is still inside the (also
+ * realpath-resolved) memory root. This blocks a symlinked category directory
+ * (e.g. decisions/ → /etc) from redirecting a scan — or a destructive dedupe
+ * unlink — outside the memory store.
+ */
+
+import path from "node:path";
+
+/**
+ * True when `child` is `parent` itself or nested underneath it. Both arguments
+ * must already be resolved (realpath) absolute paths.
+ */
+export function pathIsInside(parent: string, child: string): boolean {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+/**
+ * Throw if the realpath-resolved `candidateReal` escapes `rootReal`. The
+ * message references the original (pre-realpath) path so operators can locate
+ * the offending symlink/entry.
+ */
+export function assertPathInsideRoot(
+  rootReal: string,
+  candidateReal: string,
+  originalPath: string,
+): void {
+  if (!pathIsInside(rootReal, candidateReal)) {
+    throw new Error(`Refusing to scan memory path outside memoryDir: ${originalPath}`);
+  }
+}

package/dist/chunk-A7EF2XRO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/maintenance/memory-governance.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, readFile, readdir, rm, writeFile } from \"node:fs/promises\";\nimport { StorageManager } from \"../storage.js\";\nimport { decideLifecycleTransition } from \"../lifecycle.js\";\nimport type { MemoryFile, MemoryStatus } from \"../types.js\";\n\nexport type MemoryGovernanceMode = \"shadow\" | \"apply\";\nexport type MemoryGovernanceReasonCode =\n  | \"exact_duplicate\"\n  | \"semantic_duplicate_candidate\"\n  | \"disputed_memory\"\n  | \"speculative_low_confidence\"\n  | \"archive_candidate\"\n  | \"explicit_capture_review\"\n  | \"malformed_import\";\n\nexport interface MemoryGovernanceReviewQueueEntry {\n  entryId: string;\n  memoryId: string;\n  path: string;\n  reasonCode: MemoryGovernanceReasonCode;\n  severity: \"low\" | \"medium\" | \"high\";\n  suggestedAction: \"set_status\" | \"archive\";\n  suggestedStatus?: Extract<MemoryStatus, \"pending_review\" | \"quarantined\" | \"rejected\">;\n  relatedMemoryIds: string[];\n}\n\nexport interface MemoryGovernanceAppliedAction {\n  action: \"set_status\" | \"archive\";\n  memoryId: string;\n  reasonCode: MemoryGovernanceReviewQueueEntry[\"reasonCode\"];\n  beforeStatus: MemoryStatus;\n  afterStatus?: MemoryStatus;\n  originalPath: string;\n  currentPath: string;\n}\n\ninterface MemoryGovernanceRestoreEntry {\n  action: MemoryGovernanceAppliedAction[\"action\"];\n  memoryId: string;\n  reasonCode: MemoryGovernanceReviewQueueEntry[\"reasonCode\"];\n  originalPath: string;\n  currentPath: string;\n  beforeRaw: string;\n  expectedCurrentRaw?: string;\n  applied: boolean;\n}\n\nexport interface MemoryGovernanceRestoreManifest {\n  runId: string;\n  createdAt: string;\n  entries: MemoryGovernanceRestoreEntry[];\n}\n\nexport interface MemoryGovernanceSummary {\n  schemaVersion: 1;\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  createdAt: string;\n  scannedMemories: number;\n  reviewQueueCount: number;\n  proposedActionCount: number;\n  appliedActionCount: number;\n  ruleVersion: string;\n}\n\nexport interface MemoryGovernanceMetrics {\n  reviewReasons: Record<MemoryGovernanceReasonCode, number>;\n  proposedStatuses: Record<string, number>;\n  keptMemoryCount: number;\n  qualityScore: MemoryGovernanceQualityScore;\n}\n\nexport interface MemoryGovernanceQualityScore {\n  score: number;\n  maxScore: 100;\n  grade: \"excellent\" | \"good\" | \"fair\" | \"poor\";\n  deductions: Array<{\n    reasonCode: MemoryGovernanceReasonCode;\n    count: number;\n    pointsLost: number;\n  }>;\n}\n\nexport interface MemoryGovernanceTransitionReport {\n  proposed: Record<string, MemoryGovernanceAppliedAction[]>;\n  applied: Record<string, MemoryGovernanceAppliedAction[]>;\n}\n\nexport interface MemoryGovernanceManifest {\n  schemaVersion: 1;\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  createdAt: string;\n  ruleVersion: string;\n  artifacts: Record<string, string>;\n}\n\nexport interface MemoryGovernanceRunResult {\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  summary: MemoryGovernanceSummary;\n  summaryPath: string;\n  reviewQueuePath: string;\n  qualityScorePath: string;\n  transitionReportPath: string;\n  reportPath: string;\n  keptMemoriesPath: string;\n  appliedActionsPath: string;\n  metricsPath: string;\n  manifestPath: string;\n  restorePath?: string;\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  proposedActions: MemoryGovernanceAppliedAction[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n}\n\nexport interface RestoreMemoryGovernanceRunResult {\n  runId: string;\n  restoredActions: number;\n  restorePath: string;\n}\n\nexport interface RunMemoryGovernanceOptions {\n  memoryDir: string;\n  mode: MemoryGovernanceMode;\n  now?: Date;\n  maxMemories?: number;\n  batchSize?: number;\n  recentDays?: number;\n}\n\nexport interface RestoreMemoryGovernanceRunOptions {\n  memoryDir: string;\n  runId: string;\n  now?: Date;\n}\n\nexport const RULE_VERSION = \"memory-governance.v2\";\nconst SEMANTIC_DUPLICATE_MIN_TOKENS = 6;\nconst SEMANTIC_DUPLICATE_MIN_JACCARD = 0.66;\nconst QUALITY_SCORE_WEIGHTS: Record<MemoryGovernanceReasonCode, number> = {\n  exact_duplicate: 6,\n  semantic_duplicate_candidate: 4,\n  disputed_memory: 15,\n  speculative_low_confidence: 8,\n  archive_candidate: 2,\n  explicit_capture_review: 5,\n  malformed_import: 12,\n};\n\nfunction governanceRunsDir(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"memory-governance\", \"runs\");\n}\n\nfunction governanceRunDir(memoryDir: string, runId: string): string {\n  return path.join(governanceRunsDir(memoryDir), runId);\n}\n\nfunction governanceRestorePath(memoryDir: string, runId: string): string {\n  return path.join(governanceRunDir(memoryDir, runId), \"restore.json\");\n}\n\nfunction buildRunId(now: Date): string {\n  return `gov-${now.toISOString().replace(/[:.]/g, \"-\")}`;\n}\n\nfunction plannedArchivePath(memoryDir: string, originalPath: string, now: Date): string {\n  return path.join(\n    memoryDir,\n    \"archive\",\n    now.toISOString().slice(0, 10),\n    path.basename(originalPath),\n  );\n}\n\nfunction normalizeContent(content: string): string {\n  return content.trim().replace(/\\s+/g, \" \").toLowerCase();\n}\n\nfunction statusOf(memory: MemoryFile): MemoryStatus {\n  return memory.frontmatter.status ?? \"active\";\n}\n\nfunction parseIsoMs(value?: string): number | null {\n  if (!value) return null;\n  const ms = Date.parse(value);\n  return Number.isFinite(ms) ? ms : null;\n}\n\nfunction daysSince(value: string | undefined, now: Date): number {\n  const ts = parseIsoMs(value);\n  if (ts === null) return 365;\n  return Math.max(0, (now.getTime() - ts) / 86_400_000);\n}\n\nfunction compareCanonicalPreference(left: MemoryFile, right: MemoryFile): number {\n  if (left.frontmatter.confidence !== right.frontmatter.confidence) {\n    return (right.frontmatter.confidence ?? 0) - (left.frontmatter.confidence ?? 0);\n  }\n  return left.frontmatter.created.localeCompare(right.frontmatter.created);\n}\n\nfunction proposedStatusPriority(status: MemoryStatus): number {\n  switch (status) {\n    case \"quarantined\":\n      return 4;\n    case \"rejected\":\n      return 3;\n    case \"archived\":\n      return 2;\n    case \"pending_review\":\n      return 1;\n    default:\n      return 0;\n  }\n}\n\nfunction proposedActionPriority(action: MemoryGovernanceAppliedAction): number {\n  if (action.action === \"archive\") {\n    return proposedStatusPriority(\"archived\");\n  }\n  return proposedStatusPriority(action.afterStatus ?? \"active\");\n}\n\nfunction tokenizeSemanticContent(content: string): string[] {\n  return Array.from(\n    new Set(\n      normalizeContent(content)\n        .replaceAll(/[^\\p{L}\\p{N}]+/gu, \" \")\n        .split(\" \")\n        .filter((token) => token.length >= 4),\n    ),\n  );\n}\n\nfunction jaccardSimilarity(left: string[], right: string[]): number {\n  if (left.length === 0 || right.length === 0) return 0;\n  const leftSet = new Set(left);\n  const rightSet = new Set(right);\n  let intersection = 0;\n  for (const token of leftSet) {\n    if (rightSet.has(token)) intersection += 1;\n  }\n  const union = new Set([...leftSet, ...rightSet]).size;\n  return union > 0 ? intersection / union : 0;\n}\n\nfunction sameSemanticDuplicateScope(left: MemoryFile, right: MemoryFile): boolean {\n  if (left.frontmatter.category !== right.frontmatter.category) return false;\n  const leftEntityRef = left.frontmatter.entityRef?.trim();\n  const rightEntityRef = right.frontmatter.entityRef?.trim();\n  if (leftEntityRef && rightEntityRef && leftEntityRef !== rightEntityRef) return false;\n  return true;\n}\n\nfunction buildSemanticDuplicateEntries(activeMemories: MemoryFile[]): MemoryGovernanceReviewQueueEntry[] {\n  const reviewQueue: MemoryGovernanceReviewQueueEntry[] = [];\n  const ordered = [...activeMemories].sort(compareCanonicalPreference);\n  const tokensByMemoryId = new Map(\n    ordered.map((memory) => [memory.frontmatter.id, tokenizeSemanticContent(memory.content)] as const),\n  );\n  const claimed = new Set<string>();\n\n  for (let candidateIndex = 1; candidateIndex < ordered.length; candidateIndex += 1) {\n    const candidate = ordered[candidateIndex];\n    if (claimed.has(candidate.frontmatter.id)) continue;\n    const candidateTokens = tokensByMemoryId.get(candidate.frontmatter.id) ?? [];\n    if (candidateTokens.length < SEMANTIC_DUPLICATE_MIN_TOKENS) continue;\n    const candidateNormalized = normalizeContent(candidate.content);\n\n    for (let canonicalIndex = 0; canonicalIndex < candidateIndex; canonicalIndex += 1) {\n      const canonical = ordered[canonicalIndex];\n      if (!sameSemanticDuplicateScope(canonical, candidate)) continue;\n      const canonicalNormalized = normalizeContent(canonical.content);\n      if (canonicalNormalized === candidateNormalized) continue;\n      const canonicalTokens = tokensByMemoryId.get(canonical.frontmatter.id) ?? [];\n      if (canonicalTokens.length < SEMANTIC_DUPLICATE_MIN_TOKENS) continue;\n\n      const shorter = Math.min(candidateTokens.length, canonicalTokens.length);\n      const longer = Math.max(candidateTokens.length, canonicalTokens.length);\n      if (shorter / longer < 0.6) continue;\n      if (jaccardSimilarity(candidateTokens, canonicalTokens) < SEMANTIC_DUPLICATE_MIN_JACCARD) continue;\n\n      reviewQueue.push({\n        entryId: `review:${candidate.frontmatter.id}:semantic_duplicate_candidate`,\n        memoryId: candidate.frontmatter.id,\n        path: candidate.path,\n        reasonCode: \"semantic_duplicate_candidate\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: [canonical.frontmatter.id],\n      });\n      claimed.add(candidate.frontmatter.id);\n      break;\n    }\n  }\n\n  return reviewQueue;\n}\n\nfunction buildExplicitCaptureReviewEntries(\n  memories: MemoryFile[],\n  lifecycleEvents: Array<{\n    memoryId: string;\n    eventType: string;\n    reasonCode?: string;\n  }>,\n): MemoryGovernanceReviewQueueEntry[] {\n  const explicitQueuedIds = new Set(\n    lifecycleEvents\n      .filter((event) => event.eventType === \"explicit_capture_queued\")\n      .map((event) => event.memoryId),\n  );\n\n  return memories\n    .filter((memory) => {\n      if (statusOf(memory) !== \"pending_review\") return false;\n      const tags = memory.frontmatter.tags ?? [];\n      if (tags.includes(\"queued-review\")) return true;\n      if (explicitQueuedIds.has(memory.frontmatter.id)) return true;\n      return memory.frontmatter.source === \"explicit-review\" || memory.frontmatter.source === \"explicit-inline-review\";\n    })\n    .map((memory) => ({\n      entryId: `review:${memory.frontmatter.id}:explicit_capture_review`,\n      memoryId: memory.frontmatter.id,\n      path: memory.path,\n      reasonCode: \"explicit_capture_review\" as const,\n      severity: \"medium\" as const,\n      suggestedAction: \"set_status\" as const,\n      suggestedStatus: \"pending_review\" as const,\n      relatedMemoryIds: [],\n    }));\n}\n\nasync function listMarkdownFiles(root: string): Promise<string[]> {\n  const files: string[] = [];\n  const walk = async (dir: string) => {\n    try {\n      const entries = await readdir(dir, { withFileTypes: true });\n      for (const entry of entries) {\n        const fullPath = path.join(dir, entry.name);\n        if (entry.isDirectory()) {\n          await walk(fullPath);\n          continue;\n        }\n        if (entry.isFile() && entry.name.endsWith(\".md\")) {\n          files.push(fullPath);\n        }\n      }\n    } catch {\n      // Directory may not exist yet.\n    }\n  };\n\n  await walk(root);\n  return files;\n}\n\nfunction malformedMemoryId(memoryDir: string, filePath: string): string {\n  return `malformed:${path.relative(memoryDir, filePath).replaceAll(path.sep, \"/\")}`;\n}\n\nasync function buildMalformedImportEntries(\n  memoryDir: string,\n  storage: StorageManager,\n  parsedMemories: MemoryFile[],\n  candidateFiles?: string[],\n): Promise<MemoryGovernanceReviewQueueEntry[]> {\n  const parsedPaths = new Set(parsedMemories.map((memory) => memory.path));\n  const filesToInspect = candidateFiles ?? [\n    ...await listMarkdownFiles(path.join(memoryDir, \"facts\")),\n    ...await listMarkdownFiles(path.join(memoryDir, \"corrections\")),\n  ];\n  const entries: MemoryGovernanceReviewQueueEntry[] = [];\n\n  for (const filePath of filesToInspect) {\n    if (parsedPaths.has(filePath)) continue;\n    const parsed = await storage.readMemoryByPath(filePath);\n    if (parsed) continue;\n    entries.push({\n      entryId: `review:${malformedMemoryId(memoryDir, filePath)}:malformed_import`,\n      memoryId: malformedMemoryId(memoryDir, filePath),\n      path: filePath,\n      reasonCode: \"malformed_import\",\n      severity: \"high\",\n      suggestedAction: \"set_status\",\n      suggestedStatus: \"quarantined\",\n      relatedMemoryIds: [],\n    });\n  }\n\n  return entries;\n}\n\nasync function buildReviewQueue(\n  memoryDir: string,\n  storage: StorageManager,\n  memories: MemoryFile[],\n  now: Date,\n  options: {\n    malformedCandidateFiles?: string[];\n  } = {},\n): Promise<MemoryGovernanceReviewQueueEntry[]> {\n  const reviewQueue: MemoryGovernanceReviewQueueEntry[] = [];\n  const activeMemories = memories.filter((memory) => statusOf(memory) === \"active\");\n  const duplicateBuckets = new Map<string, MemoryFile[]>();\n\n  for (const memory of activeMemories) {\n    const key = `${memory.frontmatter.category}:${normalizeContent(memory.content)}`;\n    const bucket = duplicateBuckets.get(key) ?? [];\n    bucket.push(memory);\n    duplicateBuckets.set(key, bucket);\n  }\n\n  for (const bucket of duplicateBuckets.values()) {\n    if (bucket.length < 2) continue;\n    const ordered = [...bucket].sort(compareCanonicalPreference);\n    const canonical = ordered[0];\n    for (const duplicate of ordered.slice(1)) {\n      reviewQueue.push({\n        entryId: `review:${duplicate.frontmatter.id}:exact_duplicate`,\n        memoryId: duplicate.frontmatter.id,\n        path: duplicate.path,\n        reasonCode: \"exact_duplicate\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: canonical ? [canonical.frontmatter.id] : [],\n      });\n    }\n  }\n\n  reviewQueue.push(...buildSemanticDuplicateEntries(activeMemories));\n\n  for (const memory of activeMemories) {\n    if (memory.frontmatter.verificationState === \"disputed\") {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:disputed_memory`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"disputed_memory\",\n        severity: \"high\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"quarantined\",\n        relatedMemoryIds: [],\n      });\n    }\n\n    if (\n      memory.frontmatter.confidenceTier === \"speculative\"\n      && (memory.frontmatter.confidence ?? 0) <= 0.25\n    ) {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:speculative_low_confidence`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"speculative_low_confidence\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: [],\n      });\n    }\n\n    const lifecycle = decideLifecycleTransition(memory, {}, now);\n    const staleForArchive = memory.frontmatter.lifecycleState === \"stale\"\n      && daysSince(memory.frontmatter.updated ?? memory.frontmatter.created, now) >= 180;\n    if ((lifecycle.nextState === \"archived\" && lifecycle.changed) || staleForArchive) {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:archive_candidate`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"archive_candidate\",\n        severity: \"low\",\n        suggestedAction: \"archive\",\n        relatedMemoryIds: [],\n      });\n    }\n  }\n\n  const lifecycleEvents = await storage.readMemoryLifecycleEvents(Number.MAX_SAFE_INTEGER);\n  reviewQueue.push(...buildExplicitCaptureReviewEntries(memories, lifecycleEvents));\n  reviewQueue.push(...await buildMalformedImportEntries(\n    memoryDir,\n    storage,\n    memories,\n    options.malformedCandidateFiles,\n  ));\n\n  return reviewQueue;\n}\n\nexport function buildProposedActions(\n  reviewQueue: MemoryGovernanceReviewQueueEntry[],\n  memories: MemoryFile[],\n): MemoryGovernanceAppliedAction[] {\n  const byMemory = new Map(memories.map((memory) => [memory.frontmatter.id, memory]));\n  const selected = new Map<string, MemoryGovernanceAppliedAction>();\n\n  for (const entry of reviewQueue) {\n    const memory = byMemory.get(entry.memoryId);\n    if (!memory) continue;\n    const currentStatus = statusOf(memory);\n    if (\n      entry.suggestedAction === \"set_status\"\n      && entry.suggestedStatus\n      && entry.suggestedStatus === currentStatus\n    ) {\n      continue;\n    }\n    const candidate: MemoryGovernanceAppliedAction = {\n      action: entry.suggestedAction,\n      memoryId: entry.memoryId,\n      reasonCode: entry.reasonCode,\n      beforeStatus: currentStatus,\n      afterStatus: entry.suggestedStatus,\n      originalPath: memory.path,\n      currentPath: memory.path,\n    };\n\n    const existing = selected.get(entry.memoryId);\n    if (!existing) {\n      selected.set(entry.memoryId, candidate);\n      continue;\n    }\n\n    const existingPriority = proposedActionPriority(existing);\n    const candidatePriority = proposedActionPriority(candidate);\n    if (candidatePriority > existingPriority) {\n      selected.set(entry.memoryId, candidate);\n    }\n  }\n\n  return [...selected.values()];\n}\n\nfunction buildMetrics(\n  reviewQueue: MemoryGovernanceReviewQueueEntry[],\n  proposedActions: MemoryGovernanceAppliedAction[],\n  scannedMemories: number,\n): MemoryGovernanceMetrics {\n  const reviewReasons: MemoryGovernanceMetrics[\"reviewReasons\"] = {\n    exact_duplicate: 0,\n    semantic_duplicate_candidate: 0,\n    disputed_memory: 0,\n    speculative_low_confidence: 0,\n    archive_candidate: 0,\n    explicit_capture_review: 0,\n    malformed_import: 0,\n  };\n  const proposedStatuses: Record<string, number> = {};\n\n  for (const entry of reviewQueue) {\n    reviewReasons[entry.reasonCode] += 1;\n  }\n\n  for (const action of proposedActions) {\n    const effectiveStatus = action.afterStatus ?? (action.action === \"archive\" ? \"archived\" : undefined);\n    if (!effectiveStatus) continue;\n    proposedStatuses[effectiveStatus] = (proposedStatuses[effectiveStatus] ?? 0) + 1;\n  }\n\n  return {\n    reviewReasons,\n    proposedStatuses,\n    keptMemoryCount: Math.max(0, scannedMemories - proposedActions.length),\n    qualityScore: buildQualityScore(reviewReasons),\n  };\n}\n\nexport function buildQualityScore(\n  reviewReasons: Record<MemoryGovernanceReasonCode, number>,\n): MemoryGovernanceQualityScore {\n  const deductions = Object.entries(reviewReasons)\n    .map(([reasonCode, count]) => ({\n      reasonCode: reasonCode as MemoryGovernanceReasonCode,\n      count,\n      pointsLost: count * QUALITY_SCORE_WEIGHTS[reasonCode as MemoryGovernanceReasonCode],\n    }))\n    .filter((entry) => entry.count > 0)\n    .sort((left, right) => right.pointsLost - left.pointsLost);\n  const totalPointsLost = deductions.reduce((sum, entry) => sum + entry.pointsLost, 0);\n  const score = Math.max(0, 100 - totalPointsLost);\n  const grade = score >= 90 ? \"excellent\"\n    : score >= 75 ? \"good\"\n      : score >= 50 ? \"fair\"\n        : \"poor\";\n  return {\n    score,\n    maxScore: 100,\n    grade,\n    deductions,\n  };\n}\n\nexport function groupActionsByStatus(\n  actions: MemoryGovernanceAppliedAction[],\n): Record<string, MemoryGovernanceAppliedAction[]> {\n  const grouped: Record<string, MemoryGovernanceAppliedAction[]> = {};\n  for (const action of actions) {\n    const status = action.afterStatus ?? (action.action === \"archive\" ? \"archived\" : \"unchanged\");\n    const bucket = grouped[status] ?? [];\n    bucket.push(action);\n    grouped[status] = bucket;\n  }\n  return grouped;\n}\n\nasync function safeRead(filePath: string): Promise<string | null> {\n  try {\n    return await readFile(filePath, \"utf-8\");\n  } catch {\n    return null;\n  }\n}\n\nasync function persistRestoreManifest(\n  memoryDir: string,\n  manifest: MemoryGovernanceRestoreManifest,\n): Promise<string> {\n  const restorePath = governanceRestorePath(memoryDir, manifest.runId);\n  await mkdir(path.dirname(restorePath), { recursive: true });\n  await writeFile(restorePath, JSON.stringify(manifest, null, 2), \"utf-8\");\n  return restorePath;\n}\n\nasync function writeGovernanceArtifacts(options: {\n  memoryDir: string;\n  runId: string;\n  traceId: string;\n  summary: MemoryGovernanceSummary;\n  metrics: MemoryGovernanceMetrics;\n  qualityScore: MemoryGovernanceQualityScore;\n  transitionReport: MemoryGovernanceTransitionReport;\n  keptMemoryIds: string[];\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  proposedActions: MemoryGovernanceAppliedAction[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n  restoreManifest?: MemoryGovernanceRestoreManifest;\n}): Promise<\n  Pick<\n    MemoryGovernanceRunResult,\n    | \"summaryPath\"\n    | \"reviewQueuePath\"\n    | \"qualityScorePath\"\n    | \"transitionReportPath\"\n    | \"reportPath\"\n    | \"keptMemoriesPath\"\n    | \"appliedActionsPath\"\n    | \"metricsPath\"\n    | \"manifestPath\"\n    | \"restorePath\"\n  >\n> {\n  const runDir = governanceRunDir(options.memoryDir, options.runId);\n  await mkdir(runDir, { recursive: true });\n\n  const summaryPath = path.join(runDir, \"summary.json\");\n  const reviewQueuePath = path.join(runDir, \"review-queue.json\");\n  const qualityScorePath = path.join(runDir, \"quality-score.json\");\n  const transitionReportPath = path.join(runDir, \"status-transitions.json\");\n  const reportPath = path.join(runDir, \"report.md\");\n  const keptMemoriesPath = path.join(runDir, \"kept-memories.json\");\n  const appliedActionsPath = path.join(runDir, \"applied-actions.json\");\n  const metricsPath = path.join(runDir, \"metrics.json\");\n  const manifestPath = path.join(runDir, \"manifest.json\");\n  const restorePath = options.restoreManifest ? governanceRestorePath(options.memoryDir, options.runId) : undefined;\n\n  await writeFile(summaryPath, JSON.stringify(options.summary, null, 2), \"utf-8\");\n  await writeFile(reviewQueuePath, JSON.stringify(options.reviewQueue, null, 2), \"utf-8\");\n  await writeFile(qualityScorePath, JSON.stringify(options.qualityScore, null, 2), \"utf-8\");\n  await writeFile(transitionReportPath, JSON.stringify(options.transitionReport, null, 2), \"utf-8\");\n  await writeFile(keptMemoriesPath, JSON.stringify(options.keptMemoryIds, null, 2), \"utf-8\");\n  await writeFile(appliedActionsPath, JSON.stringify(options.appliedActions, null, 2), \"utf-8\");\n  await writeFile(metricsPath, JSON.stringify(options.metrics, null, 2), \"utf-8\");\n  await writeFile(\n    reportPath,\n    [\n      `# Memory Governance Run ${options.runId}`,\n      \"\",\n      `- Trace ID: ${options.traceId}`,\n      `- Mode: ${options.summary.mode}`,\n      `- Scanned memories: ${options.summary.scannedMemories}`,\n      `- Kept memories: ${options.metrics.keptMemoryCount}`,\n      `- Review queue entries: ${options.summary.reviewQueueCount}`,\n      `- Proposed actions: ${options.summary.proposedActionCount}`,\n      `- Applied actions: ${options.summary.appliedActionCount}`,\n      `- Quality score: ${options.qualityScore.score}/${options.qualityScore.maxScore} (${options.qualityScore.grade})`,\n      \"\",\n      \"## Metrics\",\n      ...Object.entries(options.metrics.reviewReasons).map(([reason, count]) => `- ${reason}: ${count}`),\n      ...(Object.entries(options.metrics.proposedStatuses).length > 0\n        ? Object.entries(options.metrics.proposedStatuses).map(([status, count]) => `- proposed ${status}: ${count}`)\n        : [\"- proposed statuses: (none)\"]),\n      \"\",\n      \"## Quality Score\",\n      ...(options.qualityScore.deductions.length > 0\n        ? options.qualityScore.deductions.map((entry) => `- ${entry.reasonCode}: ${entry.count} -> -${entry.pointsLost}`)\n        : [\"- no deductions\"]),\n      \"\",\n      \"## Proposed Actions\",\n      ...(options.proposedActions.length > 0\n        ? options.proposedActions.map((action) =>\n            `- ${action.memoryId}: ${action.action}${action.afterStatus ? ` -> ${action.afterStatus}` : \"\"} [${action.reasonCode}]`,\n          )\n        : [\"- (empty)\"]),\n      \"\",\n      \"## Applied Actions\",\n      ...(options.appliedActions.length > 0\n        ? options.appliedActions.map((action) =>\n            `- ${action.memoryId}: ${action.action}${action.afterStatus ? ` -> ${action.afterStatus}` : \"\"} [${action.reasonCode}]`,\n          )\n        : [\"- (empty)\"]),\n      \"\",\n      \"## Review Queue\",\n      ...(options.reviewQueue.length > 0\n        ? options.reviewQueue.map((entry) =>\n            `- ${entry.memoryId}: ${entry.reasonCode} -> ${entry.suggestedAction}${entry.suggestedStatus ? ` (${entry.suggestedStatus})` : \"\"}`,\n          )\n        : [\"- (empty)\"]),\n    ].join(\"\\n\"),\n    \"utf-8\",\n  );\n  const manifest: MemoryGovernanceManifest = {\n    schemaVersion: 1,\n    runId: options.runId,\n    traceId: options.traceId,\n    mode: options.summary.mode,\n    createdAt: options.summary.createdAt,\n    ruleVersion: options.summary.ruleVersion,\n    artifacts: {\n      summary: summaryPath,\n      reviewQueue: reviewQueuePath,\n      qualityScore: qualityScorePath,\n      transitionReport: transitionReportPath,\n      report: reportPath,\n      keptMemories: keptMemoriesPath,\n      appliedActions: appliedActionsPath,\n      metrics: metricsPath,\n      ...(restorePath ? { restore: restorePath } : {}),\n    },\n  };\n  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), \"utf-8\");\n  if (restorePath && options.restoreManifest && await safeRead(restorePath) === null) {\n    await writeFile(restorePath, JSON.stringify(options.restoreManifest, null, 2), \"utf-8\");\n  }\n\n  return {\n    summaryPath,\n    reviewQueuePath,\n    qualityScorePath,\n    transitionReportPath,\n    reportPath,\n    keptMemoriesPath,\n    appliedActionsPath,\n    metricsPath,\n    manifestPath,\n    restorePath,\n  };\n}\n\nexport async function runMemoryGovernance(\n  options: RunMemoryGovernanceOptions,\n): Promise<MemoryGovernanceRunResult> {\n  const now = options.now ?? new Date();\n  const runId = buildRunId(now);\n  const traceId = runId;\n  const storage = new StorageManager(options.memoryDir);\n  const boundedScan =\n    options.maxMemories !== undefined ||\n    options.recentDays !== undefined ||\n    options.batchSize !== undefined;\n  const normalizedRecentDays = typeof options.recentDays === \"number\" && Number.isFinite(options.recentDays)\n    ? Math.max(1, Math.floor(options.recentDays))\n    : undefined;\n  const updatedAfter = normalizedRecentDays !== undefined\n    ? new Date(now.getTime() - normalizedRecentDays * 86_400_000)\n    : undefined;\n  const memoryWindow = boundedScan\n    ? await storage.readMemoriesWindow({\n        maxMemories: options.maxMemories,\n        batchSize: options.batchSize,\n        updatedAfter,\n      })\n    : undefined;\n  const memories = memoryWindow?.memories ?? await storage.readAllMemories();\n  const reviewQueue = await buildReviewQueue(options.memoryDir, storage, memories, now, {\n    malformedCandidateFiles: memoryWindow?.filePaths,\n  });\n  const proposedActions = buildProposedActions(reviewQueue, memories);\n  const reviewEntryByActionKey = new Map(\n    reviewQueue.map((entry) => [`${entry.memoryId}:${entry.reasonCode}`, entry] as const),\n  );\n  const metrics = buildMetrics(reviewQueue, proposedActions, memories.length);\n  const transitionReport: MemoryGovernanceTransitionReport = {\n    proposed: groupActionsByStatus(proposedActions),\n    applied: {},\n  };\n  const memoryPathById = new Map(memories.map((memory) => [memory.frontmatter.id, memory.path] as const));\n  const targetedMemoryIds = new Set(proposedActions.map((action) => action.memoryId));\n  const keptMemoryIds = memories\n    .map((memory) => memory.frontmatter.id)\n    .filter((memoryId) => !targetedMemoryIds.has(memoryId));\n  const appliedActions: MemoryGovernanceAppliedAction[] = [];\n  const restoreEntries: MemoryGovernanceRestoreEntry[] = [];\n  const restoreEntryByMemoryId = new Map<string, MemoryGovernanceRestoreEntry>();\n\n  if (options.mode === \"apply\") {\n    for (const action of proposedActions) {\n      const memoryPath = memoryPathById.get(action.memoryId) ?? null;\n      if (!memoryPath) continue;\n      const memory = await storage.readMemoryByPath(memoryPath);\n      if (!memory) continue;\n      if (memory.frontmatter.id !== action.memoryId) continue;\n      const beforeRaw = await safeRead(memory.path);\n      if (!beforeRaw) continue;\n      const entry: MemoryGovernanceRestoreEntry = {\n        action: action.action,\n        memoryId: action.memoryId,\n        reasonCode: action.reasonCode,\n        originalPath: memory.path,\n        currentPath: action.action === \"archive\"\n          ? plannedArchivePath(options.memoryDir, memory.path, now)\n          : memory.path,\n        beforeRaw,\n        applied: false,\n      };\n      restoreEntries.push(entry);\n      restoreEntryByMemoryId.set(action.memoryId, entry);\n    }\n\n    const restoreManifest: MemoryGovernanceRestoreManifest = {\n      runId,\n      createdAt: now.toISOString(),\n      entries: restoreEntries,\n    };\n    await persistRestoreManifest(options.memoryDir, restoreManifest);\n\n    for (const action of proposedActions) {\n      const memoryPath = memoryPathById.get(action.memoryId) ?? null;\n      if (!memoryPath) continue;\n      const memory = await storage.readMemoryByPath(memoryPath);\n      if (!memory) continue;\n      if (memory.frontmatter.id !== action.memoryId) continue;\n      const restoreEntry = restoreEntryByMemoryId.get(action.memoryId);\n      if (!restoreEntry) continue;\n\n      if (action.action === \"archive\") {\n        const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);\n        restoreEntry.applied = true;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        const archivedPath = await storage.archiveMemory(memory, {\n          at: now,\n          actor: \"memory-governance.apply\",\n          reasonCode: action.reasonCode,\n          ruleVersion: RULE_VERSION,\n          relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],\n          correlationId: traceId,\n        });\n        if (!archivedPath) {\n          restoreEntry.applied = false;\n          await persistRestoreManifest(options.memoryDir, restoreManifest);\n          continue;\n        }\n        restoreEntry.currentPath = archivedPath;\n        restoreEntry.expectedCurrentRaw = await safeRead(archivedPath) ?? undefined;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        appliedActions.push({\n          ...action,\n          currentPath: archivedPath,\n          afterStatus: \"archived\",\n        });\n        continue;\n      }\n\n      if (!action.afterStatus || action.beforeStatus === action.afterStatus) continue;\n      const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);\n      restoreEntry.applied = true;\n      await persistRestoreManifest(options.memoryDir, restoreManifest);\n      const updated = await storage.writeMemoryFrontmatter(memory, {\n        status: action.afterStatus,\n        updated: now.toISOString(),\n      }, {\n        actor: \"memory-governance.apply\",\n        reasonCode: action.reasonCode,\n        ruleVersion: RULE_VERSION,\n        relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],\n        correlationId: traceId,\n      });\n      if (!updated) {\n        restoreEntry.applied = false;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        continue;\n      }\n      restoreEntry.expectedCurrentRaw = await safeRead(memory.path) ?? undefined;\n      await persistRestoreManifest(options.memoryDir, restoreManifest);\n      appliedActions.push({\n        ...action,\n        currentPath: memory.path,\n      });\n    }\n  }\n\n  const summary: MemoryGovernanceSummary = {\n    schemaVersion: 1,\n    runId,\n    traceId,\n    mode: options.mode,\n    createdAt: now.toISOString(),\n    scannedMemories: memories.length,\n    reviewQueueCount: reviewQueue.length,\n    proposedActionCount: proposedActions.length,\n    appliedActionCount: appliedActions.length,\n    ruleVersion: RULE_VERSION,\n  };\n  const restoreManifest = options.mode === \"apply\"\n    ? {\n        runId,\n        createdAt: now.toISOString(),\n        entries: restoreEntries,\n      }\n    : undefined;\n  transitionReport.applied = groupActionsByStatus(appliedActions);\n  const paths = await writeGovernanceArtifacts({\n    memoryDir: options.memoryDir,\n    runId,\n    traceId,\n    summary,\n    metrics,\n    qualityScore: metrics.qualityScore,\n    transitionReport,\n    keptMemoryIds,\n    reviewQueue,\n    proposedActions,\n    appliedActions,\n    restoreManifest,\n  });\n\n  return {\n    runId,\n    traceId,\n    mode: options.mode,\n    summary,\n    ...paths,\n    reviewQueue,\n    proposedActions,\n    appliedActions,\n  };\n}\n\nexport async function restoreMemoryGovernanceRun(\n  options: RestoreMemoryGovernanceRunOptions,\n): Promise<RestoreMemoryGovernanceRunResult> {\n  void options.now;\n  const restorePath = governanceRestorePath(options.memoryDir, options.runId);\n  const raw = JSON.parse(await readFile(restorePath, \"utf-8\")) as MemoryGovernanceRestoreManifest;\n  let restoredActions = 0;\n\n  for (const entry of [...raw.entries].reverse()) {\n    if (!entry.applied) {\n      continue;\n    }\n    const currentRaw = await safeRead(entry.currentPath);\n    if (entry.expectedCurrentRaw && currentRaw !== entry.expectedCurrentRaw) {\n      throw new Error(`restore conflict for ${entry.memoryId}: current contents diverged from governance run`);\n    }\n    if (entry.action === \"archive\") {\n      await rm(entry.currentPath, { force: true });\n    }\n    await mkdir(path.dirname(entry.originalPath), { recursive: true });\n    await writeFile(entry.originalPath, entry.beforeRaw, \"utf-8\");\n    restoredActions += 1;\n  }\n\n  return {\n    runId: raw.runId,\n    restoredActions,\n    restorePath,\n  };\n}\n\nexport async function listMemoryGovernanceRuns(memoryDir: string): Promise<string[]> {\n  try {\n    return (await readdir(governanceRunsDir(memoryDir))).sort().reverse();\n  } catch {\n    return [];\n  }\n}\n\nexport async function readMemoryGovernanceRunArtifact(\n  memoryDir: string,\n  runId: string,\n): Promise<{\n  summary: MemoryGovernanceSummary;\n  metrics: MemoryGovernanceMetrics;\n  qualityScore: MemoryGovernanceQualityScore;\n  keptMemoryIds: string[];\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n  transitionReport: MemoryGovernanceTransitionReport;\n  report: string;\n  manifest: MemoryGovernanceManifest;\n  restore?: MemoryGovernanceRestoreManifest;\n}> {\n  const runDir = governanceRunDir(memoryDir, runId);\n  const summary = JSON.parse(await readFile(path.join(runDir, \"summary.json\"), \"utf-8\")) as MemoryGovernanceSummary;\n  const metrics = JSON.parse(await readFile(path.join(runDir, \"metrics.json\"), \"utf-8\")) as MemoryGovernanceMetrics;\n  metrics.qualityScore ??= buildQualityScore(metrics.reviewReasons);\n  const keptMemoryIds = JSON.parse(await readFile(path.join(runDir, \"kept-memories.json\"), \"utf-8\")) as string[];\n  const reviewQueue = JSON.parse(\n    await readFile(path.join(runDir, \"review-queue.json\"), \"utf-8\"),\n  ) as MemoryGovernanceReviewQueueEntry[];\n  const appliedActions = JSON.parse(\n    await readFile(path.join(runDir, \"applied-actions.json\"), \"utf-8\"),\n  ) as MemoryGovernanceAppliedAction[];\n  const qualityScoreRaw = await safeRead(path.join(runDir, \"quality-score.json\"));\n  const transitionReportRaw = await safeRead(path.join(runDir, \"status-transitions.json\"));\n  const manifest = JSON.parse(\n    await readFile(path.join(runDir, \"manifest.json\"), \"utf-8\"),\n  ) as MemoryGovernanceManifest;\n  const report = await readFile(path.join(runDir, \"report.md\"), \"utf-8\");\n  const restoreRaw = await safeRead(path.join(runDir, \"restore.json\"));\n  const qualityScore = qualityScoreRaw\n    ? JSON.parse(qualityScoreRaw) as MemoryGovernanceQualityScore\n    : metrics.qualityScore ?? buildQualityScore(metrics.reviewReasons);\n  const transitionReport = transitionReportRaw\n    ? JSON.parse(transitionReportRaw) as MemoryGovernanceTransitionReport\n    : {\n        proposed: {},\n        applied: groupActionsByStatus(appliedActions),\n      };\n  return {\n    summary,\n    metrics,\n    qualityScore,\n    keptMemoryIds,\n    reviewQueue,\n    appliedActions,\n    transitionReport,\n    report,\n    manifest,\n    restore: restoreRaw ? JSON.parse(restoreRaw) as MemoryGovernanceRestoreManifest : undefined,\n  };\n}\n"],"mappings":"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","names":["restoreManifest","reviewEntry"]}

package/dist/chunk-AL4RAJL5.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\";\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 the facts/ and corrections/ directories for\n  // `.md` files that DO reference provenance frontmatter but didn't\n  // come back from the reader — those are the corruption cases the\n  // doctor is meant to surface.\n  try {\n    const seenPaths = new Set(memories.map((m) => m.path));\n    const scanRoots = [\"facts\", \"corrections\", \"procedures\", \"reasoning-traces\"];\n    for (const rootName of scanRoots) {\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":[]}