@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-RDESQOEE.js

@@ -0,0 +1,1008 @@
+import {
+  toBackupStamp
+} from "./chunk-KJTKLXTH.js";
+import {
+  loadPersistedNativeKnowledgeChunks
+} from "./chunk-2DQ2XREU.js";
+import {
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact
+} from "./chunk-ZIEZJMFW.js";
+import {
+  StorageManager
+} from "./chunk-S2OBXHMN.js";
+import {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+} from "./chunk-SCU65EZI.js";
+import {
+  assertInjectedStorageRooted,
+  readProjectedEntityMentionRows,
+  readProjectedGovernanceRows,
+  readProjectedNativeKnowledgeRows,
+  writeProjectionMetaHighWater
+} from "./chunk-JE334SIA.js";
+import {
+  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  buildLifecycleEventsForMemory,
+  inferMemoryStatus,
+  memoryLifecycleEventProjectionIdentity,
+  sortMemoryLifecycleEvents,
+  toMemoryPathRel
+} from "./chunk-7RJUVTVF.js";
+import {
+  MEMORY_PROJECTION_SCHEMA_VERSION,
+  getMemoryProjectionPath,
+  initializeMemoryProjectionDb,
+  isProjectedMemoryPathValid,
+  memoryCurrentSelectExpressions,
+  parseCurrentRow,
+  parseTimelineRows
+} from "./chunk-AL3UYZ5N.js";
+import {
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
+import {
+  commitPreparedFileAtomically
+} from "./chunk-AW4QUFQF.js";
+import {
+  isSupportPassportPrivateMemory
+} from "./chunk-PWPIERBM.js";
+import {
+  isErrnoCode
+} from "./chunk-KNA3BXXL.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/maintenance/rebuild-memory-projection.ts
+import path from "path";
+import { mkdir, rm, stat } from "fs/promises";
+async function backupExistingProjection(memoryDir, outputPath, now) {
+  try {
+    await stat(outputPath);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) {
+      return void 0;
+    }
+    throw err;
+  }
+  const backupPath = path.join(
+    memoryDir,
+    "archive",
+    "memory-projection",
+    toBackupStamp(now),
+    "state",
+    "memory-projection.sqlite"
+  );
+  return backupPath;
+}
+function inferProjectedStatus(pathRel, memory) {
+  return inferMemoryStatus(memory.frontmatter, pathRel);
+}
+function toCurrentStateRow(memoryDir, memory) {
+  const pathRel = toMemoryPathRel(memoryDir, memory.path);
+  return {
+    memoryId: memory.frontmatter.id,
+    category: memory.frontmatter.category,
+    status: inferProjectedStatus(pathRel, memory),
+    lifecycleState: memory.frontmatter.lifecycleState,
+    path: memory.path,
+    pathRel,
+    created: memory.frontmatter.created,
+    updated: memory.frontmatter.updated,
+    archivedAt: memory.frontmatter.archivedAt,
+    supersededAt: memory.frontmatter.supersededAt,
+    entityRef: memory.frontmatter.entityRef,
+    source: memory.frontmatter.source,
+    confidence: memory.frontmatter.confidence,
+    confidenceTier: memory.frontmatter.confidenceTier,
+    memoryKind: memory.frontmatter.memoryKind,
+    accessCount: memory.frontmatter.accessCount,
+    lastAccessed: memory.frontmatter.lastAccessed,
+    tags: normalizeProjectionTags(memory.frontmatter.tags),
+    preview: normalizeProjectionPreview(memory.content),
+    privateRecord: isSupportPassportPrivateMemory(memory)
+  };
+}
+function buildEntityMentionRows(currentRows) {
+  return currentRows.flatMap((row) => {
+    const mentions = [];
+    if (row.entityRef) {
+      mentions.push({
+        memoryId: row.memoryId,
+        entityRef: row.entityRef,
+        mentionSource: "frontmatter.entityRef",
+        created: row.created,
+        updated: row.updated
+      });
+    }
+    for (const tag of row.tags ?? []) {
+      if (!tag.includes(":")) continue;
+      mentions.push({
+        memoryId: row.memoryId,
+        entityRef: tag,
+        mentionSource: "tag",
+        created: row.created,
+        updated: row.updated
+      });
+    }
+    return mentions;
+  });
+}
+function buildGovernanceActionRowKey(action) {
+  return [
+    action.action,
+    action.memoryId,
+    action.reasonCode,
+    action.originalPath,
+    action.currentPath
+  ].join("::");
+}
+async function loadLatestGovernanceProjection(memoryDir) {
+  const runId = (await listMemoryGovernanceRuns(memoryDir))[0];
+  if (!runId) return null;
+  try {
+    const artifact = await readMemoryGovernanceRunArtifact(memoryDir, runId);
+    return {
+      runId,
+      summary: artifact.summary,
+      metrics: artifact.metrics,
+      reviewQueueRows: artifact.reviewQueue.map((entry) => ({
+        runId,
+        entryId: entry.entryId,
+        memoryId: entry.memoryId,
+        path: entry.path,
+        reasonCode: entry.reasonCode,
+        severity: entry.severity,
+        suggestedAction: entry.suggestedAction,
+        suggestedStatus: entry.suggestedStatus,
+        relatedMemoryIds: [...entry.relatedMemoryIds]
+      })),
+      appliedActionRows: artifact.appliedActions.map((action) => ({
+        runId,
+        rowKey: buildGovernanceActionRowKey(action),
+        action: action.action,
+        memoryId: action.memoryId,
+        reasonCode: action.reasonCode,
+        beforeStatus: action.beforeStatus,
+        afterStatus: action.afterStatus,
+        originalPath: action.originalPath,
+        currentPath: action.currentPath
+      })),
+      report: artifact.report
+    };
+  } catch {
+    return null;
+  }
+}
+function loadTimelineEvents(memories, lifecycleEvents) {
+  if (lifecycleEvents.length > 0) {
+    return {
+      events: sortMemoryLifecycleEvents(lifecycleEvents),
+      usedLifecycleLedger: true
+    };
+  }
+  return {
+    events: sortMemoryLifecycleEvents(memories.flatMap((memory) => buildLifecycleEventsForMemory(memory))),
+    usedLifecycleLedger: false
+  };
+}
+function normalizeScopedIso(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`invalid projection scope timestamp: ${value}`);
+  }
+  return parsed.toISOString();
+}
+function normalizeProjectionScope(options) {
+  const updatedAfter = normalizeScopedIso(options.updatedAfter);
+  const updatedBefore = normalizeScopedIso(options.updatedBefore);
+  if (updatedAfter && updatedBefore && new Date(updatedAfter).getTime() > new Date(updatedBefore).getTime()) {
+    throw new Error("updatedAfter must be less than or equal to updatedBefore");
+  }
+  return {
+    updatedAfter,
+    updatedBefore
+  };
+}
+function hasScopedProjectionFilter(scope) {
+  return scope.updatedAfter !== null || scope.updatedBefore !== null;
+}
+function memoryScopeTimestamp(memory) {
+  const candidate = memory.frontmatter.updated || memory.frontmatter.created;
+  return candidate;
+}
+function isTimestampInProjectionScope(timestamp, scope) {
+  if (!scope.updatedAfter && !scope.updatedBefore) return true;
+  const parsed = new Date(timestamp);
+  if (Number.isNaN(parsed.getTime())) return false;
+  if (scope.updatedAfter && parsed.getTime() < new Date(scope.updatedAfter).getTime()) return false;
+  if (scope.updatedBefore && parsed.getTime() >= new Date(scope.updatedBefore).getTime()) return false;
+  return true;
+}
+function filterMemoriesForProjectionScope(memories, scope) {
+  if (!scope.updatedAfter && !scope.updatedBefore) return memories;
+  return memories.filter((memory) => isTimestampInProjectionScope(memoryScopeTimestamp(memory), scope));
+}
+function filterCurrentStateRowsForProjectionScope(rows, scope) {
+  if (!scope.updatedAfter && !scope.updatedBefore) return rows;
+  return rows.filter((row) => isTimestampInProjectionScope(row.updated || row.created, scope));
+}
+function serializeCurrentStateRow(row) {
+  return JSON.stringify({
+    memoryId: row.memoryId,
+    category: row.category,
+    status: row.status,
+    lifecycleState: row.lifecycleState ?? null,
+    pathRel: row.pathRel,
+    created: row.created,
+    updated: row.updated,
+    archivedAt: row.archivedAt ?? null,
+    supersededAt: row.supersededAt ?? null,
+    entityRef: row.entityRef ?? null,
+    source: row.source,
+    confidence: row.confidence,
+    confidenceTier: row.confidenceTier,
+    memoryKind: row.memoryKind ?? null,
+    accessCount: row.accessCount ?? null,
+    lastAccessed: row.lastAccessed ?? null,
+    tags: row.tags ?? [],
+    preview: row.preview ?? "",
+    privateRecord: row.privateRecord === true
+  });
+}
+function serializeTimelineEvent(event) {
+  return JSON.stringify({
+    eventId: event.eventId,
+    memoryId: event.memoryId,
+    eventType: event.eventType,
+    timestamp: event.timestamp,
+    actor: event.actor,
+    reasonCode: event.reasonCode ?? null,
+    ruleVersion: event.ruleVersion,
+    relatedMemoryIds: event.relatedMemoryIds ?? [],
+    before: event.before ?? null,
+    after: event.after ?? null,
+    correlationId: event.correlationId ?? null
+  });
+}
+function serializeEntityMentionRow(row) {
+  return JSON.stringify(row);
+}
+function serializeNativeKnowledgeRow(row) {
+  return JSON.stringify({
+    chunkId: row.chunkId,
+    sourceKind: row.sourceKind,
+    sourcePath: row.sourcePath,
+    title: row.title,
+    startLine: row.startLine,
+    endLine: row.endLine,
+    namespace: row.namespace ?? null,
+    privacyClass: row.privacyClass ?? null,
+    derivedDate: row.derivedDate ?? null,
+    sessionKey: row.sessionKey ?? null,
+    workflowKey: row.workflowKey ?? null,
+    author: row.author ?? null,
+    agent: row.agent ?? null,
+    sourceHash: row.sourceHash ?? null,
+    preview: row.preview
+  });
+}
+function serializeGovernanceReviewQueueRow(row) {
+  return JSON.stringify({
+    runId: row.runId,
+    entryId: row.entryId,
+    memoryId: row.memoryId,
+    path: row.path,
+    reasonCode: row.reasonCode,
+    severity: row.severity,
+    suggestedAction: row.suggestedAction,
+    suggestedStatus: row.suggestedStatus ?? null,
+    relatedMemoryIds: row.relatedMemoryIds
+  });
+}
+function selectProjectionMemories(tiers) {
+  const allMemories = tiers.flat();
+  const memories = [];
+  const keptById = /* @__PURE__ */ new Map();
+  const skippedDuplicateMemories = [];
+  const skippedBlankIdMemories = [];
+  for (const tier of tiers) {
+    for (const memory of [...tier].sort((left, right) => left.path.localeCompare(right.path))) {
+      const memoryId = memory.frontmatter.id.trim();
+      if (!memoryId) {
+        skippedBlankIdMemories.push({ path: memory.path });
+        log.warn(`projection rebuild skipped blank memory id: path=${memory.path}`);
+        continue;
+      }
+      const kept = keptById.get(memoryId);
+      if (kept) {
+        skippedDuplicateMemories.push({
+          memoryId,
+          keptPath: kept.path,
+          skippedPath: memory.path
+        });
+        log.warn(
+          `projection rebuild skipped duplicate memory id=${memoryId}: kept=${kept.path} skipped=${memory.path}`
+        );
+        continue;
+      }
+      keptById.set(memoryId, memory);
+      memories.push(memory);
+    }
+  }
+  return { allMemories, memories, skippedDuplicateMemories, skippedBlankIdMemories };
+}
+function deduplicateTimelineEvents(events, sourcePathFor) {
+  const keptById = /* @__PURE__ */ new Map();
+  const unique = [];
+  const skipped = [];
+  const skippedBlankIds = [];
+  for (const event of sortMemoryLifecycleEvents(events)) {
+    const sourcePath = sourcePathFor(event);
+    if (!event.memoryId.trim()) {
+      skippedBlankIds.push({ eventId: event.eventId, path: sourcePath });
+      log.warn(
+        `projection rebuild skipped timeline event with blank memory id: event_id=${event.eventId} path=${sourcePath}`
+      );
+      continue;
+    }
+    const kept = keptById.get(event.eventId);
+    if (kept) {
+      skipped.push({
+        eventId: event.eventId,
+        keptPath: kept.path,
+        skippedPath: sourcePath
+      });
+      log.warn(
+        `projection rebuild skipped duplicate timeline event_id=${event.eventId}: kept=${kept.path} skipped=${sourcePath}`
+      );
+      continue;
+    }
+    keptById.set(event.eventId, { event, path: sourcePath });
+    unique.push(event);
+  }
+  return { events: unique, skipped, skippedBlankIds };
+}
+async function loadAuthoritativeProjectionSnapshot(options) {
+  const storage = assertInjectedStorageRooted("rebuildMemoryProjection", options.memoryDir, options.storage) ?? new StorageManager(options.memoryDir);
+  storage.invalidateAllMemoriesCacheForDir();
+  const selected = selectProjectionMemories([
+    await storage.readAllMemories(),
+    await storage.readAllColdMemories(),
+    await storage.readArchivedMemories()
+  ]);
+  const allMemories = selected.allMemories;
+  const projectionMemories = selected.memories;
+  const lifecycleEvents = await storage.readAllMemoryLifecycleEvents();
+  const timeline = loadTimelineEvents(projectionMemories, lifecycleEvents);
+  const lifecycleLedgerPath = path.join(
+    options.memoryDir,
+    "state",
+    "memory-lifecycle-ledger.jsonl"
+  );
+  const memoryPathById = new Map(
+    projectionMemories.map((memory) => [memory.frontmatter.id, memory.path])
+  );
+  const deduplicatedTimeline = deduplicateTimelineEvents(
+    timeline.events,
+    (event) => timeline.usedLifecycleLedger ? lifecycleLedgerPath : memoryPathById.get(event.memoryId) ?? lifecycleLedgerPath
+  );
+  const events = deduplicatedTimeline.events;
+  const usedLifecycleLedger = timeline.usedLifecycleLedger;
+  const sourceLifecycleLedgerEventCount = new Set(
+    lifecycleEvents.map(memoryLifecycleEventProjectionIdentity)
+  ).size;
+  const currentRows = projectionMemories.map((memory) => toCurrentStateRow(options.memoryDir, memory));
+  const scope = normalizeProjectionScope(options);
+  const scopedMemories = filterMemoriesForProjectionScope(projectionMemories, scope);
+  const scopedMemoryIds = new Set(scopedMemories.map((memory) => memory.frontmatter.id));
+  const nativeKnowledgeRows = await loadPersistedNativeKnowledgeChunks({
+    memoryDir: options.memoryDir,
+    defaultNamespace: options.defaultNamespace ?? "default"
+  }).then((rows) => rows.map((row) => ({
+    chunkId: row.chunkId,
+    sourceKind: row.sourceKind,
+    sourcePath: row.sourcePath,
+    title: row.title,
+    startLine: row.startLine,
+    endLine: row.endLine,
+    namespace: row.namespace ?? options.defaultNamespace ?? "default",
+    privacyClass: row.privacyClass,
+    derivedDate: row.derivedDate,
+    sessionKey: row.sessionKey,
+    workflowKey: row.workflowKey,
+    author: row.author,
+    agent: row.agent,
+    sourceHash: row.sourceHash,
+    preview: normalizeProjectionPreview(row.content)
+  })));
+  const governance = await loadLatestGovernanceProjection(options.memoryDir);
+  const entityMentionRows = buildEntityMentionRows(currentRows);
+  return {
+    allMemories,
+    currentRows,
+    timelineRows: events,
+    scopedCurrentRows: currentRows.filter((row) => scopedMemoryIds.has(row.memoryId)),
+    scopedTimelineRows: events.filter((event) => scopedMemoryIds.has(event.memoryId)),
+    entityMentionRows,
+    scopedEntityMentionRows: entityMentionRows.filter((row) => scopedMemoryIds.has(row.memoryId)),
+    nativeKnowledgeRows,
+    governance,
+    usedLifecycleLedger,
+    sourceLifecycleLedgerEventCount,
+    scope,
+    skippedDuplicateMemories: selected.skippedDuplicateMemories,
+    skippedBlankIdMemories: selected.skippedBlankIdMemories,
+    skippedDuplicateTimelineEvents: deduplicatedTimeline.skipped,
+    skippedBlankIdTimelineEvents: deduplicatedTimeline.skippedBlankIds
+  };
+}
+function readProjectedCurrentRows(memoryDir) {
+  const dbPath = getMemoryProjectionPath(memoryDir);
+  try {
+    const db = openBetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const selectExpressions = memoryCurrentSelectExpressions(db);
+      const rows = db.prepare(`
+        SELECT
+          memory_id,
+          category,
+          status,
+          lifecycle_state,
+          path_rel,
+          created_at,
+          updated_at,
+          archived_at,
+          superseded_at,
+          entity_ref,
+          source,
+          confidence,
+          confidence_tier,
+          memory_kind,
+          access_count,
+          last_accessed,
+          ${selectExpressions.tagsJson}, ${selectExpressions.previewText}, ${selectExpressions.privateRecord}
+        FROM memory_current
+      `).all();
+      return {
+        projectionExists: true,
+        rows: rows.map((row) => parseCurrentRow(memoryDir, row)).filter((row) => row !== null)
+      };
+    } finally {
+      db.close();
+    }
+  } catch {
+    return { projectionExists: false, rows: [] };
+  }
+}
+function readProjectedTimelineRows(memoryDir) {
+  const dbPath = getMemoryProjectionPath(memoryDir);
+  try {
+    const db = openBetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const rows = db.prepare(`
+        SELECT
+          event_id,
+          memory_id,
+          event_type,
+          timestamp,
+          actor,
+          reason_code,
+          rule_version,
+          related_memory_ids_json,
+          before_json,
+          after_json,
+          correlation_id
+        FROM memory_timeline
+      `).all();
+      return {
+        projectionExists: true,
+        rows: parseTimelineRows(rows)
+      };
+    } finally {
+      db.close();
+    }
+  } catch {
+    return { projectionExists: false, rows: [] };
+  }
+}
+function writeProjectionDb(dbPath, nowIso, currentRows, timelineRows, entityMentionRows, nativeKnowledgeRows, governance, usedLifecycleLedger, sourceLifecycleLedgerEventCount) {
+  const db = openBetterSqlite3(dbPath);
+  const memoryDir = path.dirname(path.dirname(dbPath));
+  try {
+    initializeMemoryProjectionDb(db);
+    const insertMeta = db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES (?, ?)");
+    insertMeta.run("schemaVersion", String(MEMORY_PROJECTION_SCHEMA_VERSION));
+    insertMeta.run("rebuiltAt", nowIso);
+    insertMeta.run("usedLifecycleLedger", usedLifecycleLedger ? "true" : "false");
+    writeProjectionMetaHighWater(insertMeta, sourceLifecycleLedgerEventCount, timelineRows);
+    insertMeta.run("latestGovernanceRunId", governance?.runId ?? "");
+    const insertCurrent = db.prepare(`
+      INSERT INTO memory_current (
+        memory_id,
+        category,
+        status,
+        lifecycle_state,
+        path_rel,
+        path_valid,
+        created_at,
+        updated_at,
+        archived_at,
+        superseded_at,
+        entity_ref,
+        source,
+        confidence,
+        confidence_tier,
+        memory_kind,
+        access_count,
+        last_accessed,
+        tags_json, preview_text, private_record
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertTimeline = db.prepare(`
+      INSERT INTO memory_timeline (
+        event_id,
+        memory_id,
+        event_type,
+        timestamp,
+        event_order,
+        actor,
+        reason_code,
+        rule_version,
+        related_memory_ids_json,
+        before_json,
+        after_json,
+        correlation_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertEntityMention = db.prepare(`
+      INSERT INTO memory_entity_mentions (
+        memory_id,
+        entity_ref,
+        mention_source,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `);
+    const insertNativeKnowledge = db.prepare(`
+      INSERT INTO native_knowledge_chunks (
+        chunk_id,
+        source_kind,
+        source_path,
+        title,
+        start_line,
+        end_line,
+        namespace,
+        privacy_class,
+        derived_date,
+        session_key,
+        workflow_key,
+        author,
+        agent,
+        source_hash,
+        preview_text
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertGovernanceReviewQueue = db.prepare(`
+      INSERT INTO memory_review_queue (
+        entry_id,
+        run_id,
+        memory_id,
+        path,
+        reason_code,
+        severity,
+        suggested_action,
+        suggested_status,
+        related_memory_ids_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertGovernanceAppliedAction = db.prepare(`
+      INSERT INTO memory_review_actions (
+        row_key,
+        run_id,
+        action,
+        memory_id,
+        reason_code,
+        before_status,
+        after_status,
+        original_path,
+        current_path
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertGovernanceRun = db.prepare(`
+      INSERT INTO memory_review_runs (
+        run_id,
+        created_at,
+        mode,
+        summary_json,
+        metrics_json,
+        applied_actions_json,
+        report_markdown
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const writeTx = db.transaction(() => {
+      for (const row of currentRows) {
+        insertCurrent.run(
+          row.memoryId,
+          row.category,
+          row.status,
+          row.lifecycleState ?? null,
+          row.pathRel,
+          isProjectedMemoryPathValid(memoryDir, row.pathRel) ? 1 : 0,
+          row.created,
+          row.updated,
+          row.archivedAt ?? null,
+          row.supersededAt ?? null,
+          row.entityRef ?? null,
+          row.source,
+          row.confidence,
+          row.confidenceTier,
+          row.memoryKind ?? null,
+          row.accessCount ?? null,
+          row.lastAccessed ?? null,
+          JSON.stringify(row.tags ?? []),
+          row.preview ?? "",
+          row.privateRecord === true ? 1 : 0
+        );
+      }
+      for (const event of timelineRows) {
+        insertTimeline.run(
+          event.eventId,
+          event.memoryId,
+          event.eventType,
+          event.timestamp,
+          MEMORY_LIFECYCLE_EVENT_SORT_ORDER[event.eventType],
+          event.actor,
+          event.reasonCode ?? null,
+          event.ruleVersion,
+          JSON.stringify(event.relatedMemoryIds ?? []),
+          event.before ? JSON.stringify(event.before) : null,
+          event.after ? JSON.stringify(event.after) : null,
+          event.correlationId ?? null
+        );
+      }
+      for (const row of entityMentionRows) {
+        insertEntityMention.run(
+          row.memoryId,
+          row.entityRef,
+          row.mentionSource,
+          row.created,
+          row.updated
+        );
+      }
+      for (const row of nativeKnowledgeRows) {
+        insertNativeKnowledge.run(
+          row.chunkId,
+          row.sourceKind,
+          row.sourcePath,
+          row.title,
+          row.startLine,
+          row.endLine,
+          row.namespace ?? null,
+          row.privacyClass ?? null,
+          row.derivedDate ?? null,
+          row.sessionKey ?? null,
+          row.workflowKey ?? null,
+          row.author ?? null,
+          row.agent ?? null,
+          row.sourceHash ?? null,
+          row.preview
+        );
+      }
+      for (const row of governance?.reviewQueueRows ?? []) {
+        insertGovernanceReviewQueue.run(
+          row.entryId,
+          row.runId,
+          row.memoryId,
+          row.path,
+          row.reasonCode,
+          row.severity,
+          row.suggestedAction,
+          row.suggestedStatus ?? null,
+          JSON.stringify(row.relatedMemoryIds)
+        );
+      }
+      for (const row of governance?.appliedActionRows ?? []) {
+        insertGovernanceAppliedAction.run(
+          row.rowKey,
+          row.runId,
+          row.action,
+          row.memoryId,
+          row.reasonCode,
+          row.beforeStatus,
+          row.afterStatus ?? null,
+          row.originalPath,
+          row.currentPath
+        );
+      }
+      if (governance) {
+        const createdAt = typeof governance.summary?.createdAt === "string" ? governance.summary.createdAt : nowIso;
+        const mode = typeof governance.summary?.mode === "string" ? governance.summary.mode : "shadow";
+        insertGovernanceRun.run(
+          governance.runId,
+          createdAt,
+          mode,
+          JSON.stringify(governance.summary ?? null),
+          JSON.stringify(governance.metrics ?? null),
+          JSON.stringify(
+            (governance.appliedActionRows ?? []).map((row) => ({
+              action: row.action,
+              memoryId: row.memoryId,
+              reasonCode: row.reasonCode,
+              beforeStatus: row.beforeStatus,
+              afterStatus: row.afterStatus,
+              originalPath: row.originalPath,
+              currentPath: row.currentPath
+            }))
+          ),
+          governance.report
+        );
+      }
+    });
+    writeTx();
+  } finally {
+    db.close();
+  }
+}
+function mergeScopedCurrentRows(existingRows, replacementRows, scopedMemoryIds) {
+  return [...existingRows.filter((row) => !scopedMemoryIds.has(row.memoryId)), ...replacementRows].sort((a, b) => a.memoryId.localeCompare(b.memoryId));
+}
+function mergeScopedTimelineRows(existingRows, replacementRows, scopedMemoryIds) {
+  return sortMemoryLifecycleEvents([
+    ...existingRows.filter((event) => !scopedMemoryIds.has(event.memoryId)),
+    ...replacementRows
+  ]);
+}
+function mergeScopedEntityMentionRows(existingRows, replacementRows, scopedMemoryIds) {
+  return [
+    ...existingRows.filter((row) => !scopedMemoryIds.has(row.memoryId)),
+    ...replacementRows
+  ].sort(
+    (left, right) => [left.entityRef, left.memoryId, left.mentionSource].join("::").localeCompare(
+      [right.entityRef, right.memoryId, right.mentionSource].join("::")
+    )
+  );
+}
+async function rebuildMemoryProjection(options) {
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const outputPath = getMemoryProjectionPath(options.memoryDir);
+  const snapshot = await loadAuthoritativeProjectionSnapshot(options);
+  let backupPath;
+  if (!dryRun) {
+    let nextCurrentRows = snapshot.currentRows;
+    let nextTimelineRows = snapshot.timelineRows;
+    let nextEntityMentionRows = snapshot.entityMentionRows;
+    let nextNativeKnowledgeRows = snapshot.nativeKnowledgeRows;
+    let nextGovernance = snapshot.governance;
+    if (hasScopedProjectionFilter(snapshot.scope)) {
+      nextCurrentRows = snapshot.scopedCurrentRows;
+      nextTimelineRows = snapshot.scopedTimelineRows;
+      nextEntityMentionRows = snapshot.scopedEntityMentionRows;
+      const projectedCurrent = readProjectedCurrentRows(options.memoryDir);
+      const projectedTimeline = readProjectedTimelineRows(options.memoryDir);
+      const projectedEntityMentions = readProjectedEntityMentionRows(options.memoryDir);
+      const projectedNativeKnowledge = readProjectedNativeKnowledgeRows(options.memoryDir);
+      const projectedGovernance = readProjectedGovernanceRows(options.memoryDir);
+      if (projectedCurrent.projectionExists && projectedTimeline.projectionExists) {
+        const actualScopedCurrentRows = filterCurrentStateRowsForProjectionScope(
+          projectedCurrent.rows,
+          snapshot.scope
+        );
+        const scopedMemoryIds = /* @__PURE__ */ new Set([
+          ...snapshot.scopedCurrentRows.map((row) => row.memoryId),
+          ...snapshot.scopedTimelineRows.map((event) => event.memoryId),
+          ...actualScopedCurrentRows.map((row) => row.memoryId)
+        ]);
+        nextCurrentRows = mergeScopedCurrentRows(
+          projectedCurrent.rows,
+          snapshot.scopedCurrentRows,
+          scopedMemoryIds
+        );
+        nextTimelineRows = mergeScopedTimelineRows(
+          projectedTimeline.rows,
+          snapshot.scopedTimelineRows,
+          scopedMemoryIds
+        );
+        nextEntityMentionRows = mergeScopedEntityMentionRows(
+          projectedEntityMentions.rows,
+          snapshot.scopedEntityMentionRows,
+          scopedMemoryIds
+        );
+      }
+      if (projectedNativeKnowledge.projectionExists) {
+        nextNativeKnowledgeRows = snapshot.nativeKnowledgeRows;
+      }
+      if (projectedGovernance.projectionExists && projectedGovernance.runId) {
+        nextGovernance = snapshot.governance;
+      }
+    }
+    const tempPath = `${outputPath}.tmp`;
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    await rm(tempPath, { force: true });
+    writeProjectionDb(
+      tempPath,
+      now.toISOString(),
+      nextCurrentRows,
+      nextTimelineRows,
+      nextEntityMentionRows,
+      nextNativeKnowledgeRows,
+      nextGovernance,
+      snapshot.usedLifecycleLedger,
+      snapshot.sourceLifecycleLedgerEventCount
+    );
+    backupPath = await backupExistingProjection(options.memoryDir, outputPath, now);
+    backupPath = await commitPreparedFileAtomically(tempPath, outputPath, backupPath);
+  }
+  return {
+    dryRun,
+    scannedMemories: snapshot.allMemories.length,
+    currentRows: snapshot.scopedCurrentRows.length,
+    timelineRows: snapshot.scopedTimelineRows.length,
+    entityMentionRows: snapshot.scopedEntityMentionRows.length,
+    nativeKnowledgeRows: snapshot.nativeKnowledgeRows.length,
+    reviewQueueRows: snapshot.governance?.reviewQueueRows.length ?? 0,
+    outputPath,
+    backupPath,
+    usedLifecycleLedger: snapshot.usedLifecycleLedger,
+    skippedDuplicateMemories: snapshot.skippedDuplicateMemories,
+    skippedBlankIdMemories: snapshot.skippedBlankIdMemories,
+    skippedDuplicateTimelineEvents: snapshot.skippedDuplicateTimelineEvents,
+    skippedBlankIdTimelineEvents: snapshot.skippedBlankIdTimelineEvents,
+    scope: snapshot.scope
+  };
+}
+async function verifyMemoryProjection(options) {
+  const outputPath = getMemoryProjectionPath(options.memoryDir);
+  const snapshot = await loadAuthoritativeProjectionSnapshot(options);
+  const projectedCurrent = readProjectedCurrentRows(options.memoryDir);
+  const projectedTimeline = readProjectedTimelineRows(options.memoryDir);
+  const projectedEntityMentions = readProjectedEntityMentionRows(options.memoryDir);
+  const projectedNativeKnowledge = readProjectedNativeKnowledgeRows(options.memoryDir);
+  const projectedGovernance = readProjectedGovernanceRows(options.memoryDir);
+  const projectionExists = projectedCurrent.projectionExists || projectedTimeline.projectionExists || projectedEntityMentions.projectionExists || projectedNativeKnowledge.projectionExists || projectedGovernance.projectionExists;
+  const actualScopedCurrentRows = filterCurrentStateRowsForProjectionScope(projectedCurrent.rows, snapshot.scope);
+  const expectedCurrentById = new Map(
+    snapshot.scopedCurrentRows.map((row) => [row.memoryId, serializeCurrentStateRow(row)])
+  );
+  const actualCurrentById = new Map(
+    actualScopedCurrentRows.map((row) => [row.memoryId, serializeCurrentStateRow(row)])
+  );
+  const missingCurrentMemoryIds = [...expectedCurrentById.keys()].filter((memoryId) => !actualCurrentById.has(memoryId)).sort();
+  const extraCurrentMemoryIds = [...actualCurrentById.keys()].filter((memoryId) => !expectedCurrentById.has(memoryId)).sort();
+  const mismatchedCurrentMemoryIds = [...expectedCurrentById.keys()].filter(
+    (memoryId) => actualCurrentById.has(memoryId) && actualCurrentById.get(memoryId) !== expectedCurrentById.get(memoryId)
+  ).sort();
+  const selectedMemoryIds = /* @__PURE__ */ new Set([
+    ...snapshot.scopedCurrentRows.map((row) => row.memoryId),
+    ...actualScopedCurrentRows.map((row) => row.memoryId)
+  ]);
+  const expectedTimelineById = new Map(
+    snapshot.scopedTimelineRows.map((event) => [event.eventId, serializeTimelineEvent(event)])
+  );
+  const actualTimelineRows = projectedTimeline.rows.filter((event) => selectedMemoryIds.has(event.memoryId));
+  const actualTimelineById = new Map(
+    actualTimelineRows.map((event) => [event.eventId, serializeTimelineEvent(event)])
+  );
+  const missingTimelineEventIds = [...expectedTimelineById.keys()].filter((eventId) => !actualTimelineById.has(eventId)).sort();
+  const extraTimelineEventIds = [...actualTimelineById.keys()].filter((eventId) => !expectedTimelineById.has(eventId)).sort();
+  const expectedEntityMentionsByKey = new Map(
+    snapshot.scopedEntityMentionRows.map((row) => [
+      `${row.memoryId}::${row.entityRef}::${row.mentionSource}`,
+      serializeEntityMentionRow(row)
+    ])
+  );
+  const actualScopedEntityMentionRows = projectedEntityMentions.rows.filter((row) => selectedMemoryIds.has(row.memoryId));
+  const actualEntityMentionsByKey = new Map(
+    actualScopedEntityMentionRows.map((row) => [
+      `${row.memoryId}::${row.entityRef}::${row.mentionSource}`,
+      serializeEntityMentionRow(row)
+    ])
+  );
+  const missingEntityMentionKeys = [...expectedEntityMentionsByKey.keys()].filter((key) => !actualEntityMentionsByKey.has(key)).sort();
+  const extraEntityMentionKeys = [...actualEntityMentionsByKey.keys()].filter((key) => !expectedEntityMentionsByKey.has(key)).sort();
+  const mismatchedEntityMentionKeys = [...expectedEntityMentionsByKey.keys()].filter(
+    (key) => actualEntityMentionsByKey.has(key) && actualEntityMentionsByKey.get(key) !== expectedEntityMentionsByKey.get(key)
+  ).sort();
+  const expectedNativeKnowledgeById = new Map(
+    snapshot.nativeKnowledgeRows.map((row) => [row.chunkId, serializeNativeKnowledgeRow(row)])
+  );
+  const actualNativeKnowledgeById = new Map(
+    projectedNativeKnowledge.rows.map((row) => [row.chunkId, serializeNativeKnowledgeRow(row)])
+  );
+  const missingNativeKnowledgeChunkIds = [...expectedNativeKnowledgeById.keys()].filter((chunkId) => !actualNativeKnowledgeById.has(chunkId)).sort();
+  const extraNativeKnowledgeChunkIds = [...actualNativeKnowledgeById.keys()].filter((chunkId) => !expectedNativeKnowledgeById.has(chunkId)).sort();
+  const mismatchedNativeKnowledgeChunkIds = [...expectedNativeKnowledgeById.keys()].filter(
+    (chunkId) => actualNativeKnowledgeById.has(chunkId) && actualNativeKnowledgeById.get(chunkId) !== expectedNativeKnowledgeById.get(chunkId)
+  ).sort();
+  const expectedReviewQueueById = new Map(
+    (snapshot.governance?.reviewQueueRows ?? []).map((row) => [
+      `${row.runId}::${row.entryId}`,
+      serializeGovernanceReviewQueueRow(row)
+    ])
+  );
+  const actualReviewQueueById = new Map(
+    projectedGovernance.reviewQueueRows.map((row) => [
+      `${row.runId}::${row.entryId}`,
+      serializeGovernanceReviewQueueRow(row)
+    ])
+  );
+  const missingReviewQueueEntryIds = [...expectedReviewQueueById.keys()].filter((entryId) => !actualReviewQueueById.has(entryId)).sort();
+  const extraReviewQueueEntryIds = [...actualReviewQueueById.keys()].filter((entryId) => !expectedReviewQueueById.has(entryId)).sort();
+  const mismatchedReviewQueueEntryIds = [...expectedReviewQueueById.keys()].filter(
+    (entryId) => actualReviewQueueById.has(entryId) && actualReviewQueueById.get(entryId) !== expectedReviewQueueById.get(entryId)
+  ).sort();
+  return {
+    outputPath,
+    projectionExists,
+    ok: projectionExists && missingCurrentMemoryIds.length === 0 && extraCurrentMemoryIds.length === 0 && mismatchedCurrentMemoryIds.length === 0 && missingTimelineEventIds.length === 0 && extraTimelineEventIds.length === 0 && missingEntityMentionKeys.length === 0 && extraEntityMentionKeys.length === 0 && mismatchedEntityMentionKeys.length === 0 && missingNativeKnowledgeChunkIds.length === 0 && extraNativeKnowledgeChunkIds.length === 0 && mismatchedNativeKnowledgeChunkIds.length === 0 && missingReviewQueueEntryIds.length === 0 && extraReviewQueueEntryIds.length === 0 && mismatchedReviewQueueEntryIds.length === 0,
+    expectedCurrentRows: snapshot.scopedCurrentRows.length,
+    actualCurrentRows: actualScopedCurrentRows.length,
+    expectedTimelineRows: snapshot.scopedTimelineRows.length,
+    actualTimelineRows: actualTimelineRows.length,
+    expectedEntityMentionRows: snapshot.scopedEntityMentionRows.length,
+    actualEntityMentionRows: actualScopedEntityMentionRows.length,
+    expectedNativeKnowledgeRows: snapshot.nativeKnowledgeRows.length,
+    actualNativeKnowledgeRows: projectedNativeKnowledge.rows.length,
+    expectedReviewQueueRows: snapshot.governance?.reviewQueueRows.length ?? 0,
+    actualReviewQueueRows: projectedGovernance.reviewQueueRows.length,
+    missingCurrentMemoryIds,
+    extraCurrentMemoryIds,
+    mismatchedCurrentMemoryIds,
+    missingTimelineEventIds,
+    extraTimelineEventIds,
+    missingEntityMentionKeys,
+    extraEntityMentionKeys,
+    mismatchedEntityMentionKeys,
+    missingNativeKnowledgeChunkIds,
+    extraNativeKnowledgeChunkIds,
+    mismatchedNativeKnowledgeChunkIds,
+    missingReviewQueueEntryIds,
+    extraReviewQueueEntryIds,
+    mismatchedReviewQueueEntryIds,
+    usedLifecycleLedger: snapshot.usedLifecycleLedger,
+    scope: snapshot.scope
+  };
+}
+async function repairMemoryProjection(options) {
+  const dryRun = options.dryRun !== false;
+  const verify = await verifyMemoryProjection(options);
+  if (verify.ok) {
+    return {
+      dryRun,
+      repaired: false,
+      verify
+    };
+  }
+  if (dryRun) {
+    return {
+      dryRun: true,
+      repaired: false,
+      verify
+    };
+  }
+  const rebuild = await rebuildMemoryProjection({
+    ...options,
+    dryRun: false
+  });
+  const verified = await verifyMemoryProjection(options);
+  return {
+    dryRun: false,
+    repaired: verified.ok,
+    verify: verified,
+    rebuild
+  };
+}
+
+export {
+  backupExistingProjection,
+  rebuildMemoryProjection,
+  verifyMemoryProjection,
+  repairMemoryProjection
+};
+//# sourceMappingURL=chunk-RDESQOEE.js.map