@remnic/core 9.54.8 → 9.55.0

package/dist/{chunk-OS5DYALF.js → chunk-4THNU7OF.js}

@@ -7,6 +7,9 @@ import {
 import {
   openclawReplayNormalizer
 } from "./chunk-H4CKS5B2.js";
+import {
+  importMarkdownBundle
+} from "./chunk-HDDRVXX4.js";
 import {
   importSqlite
 } from "./chunk-PYHOAXTI.js";
@@ -16,9 +19,6 @@ import {
 import {
   exportSqlite
 } from "./chunk-BV2TIZ4F.js";
-import {
-  importMarkdownBundle
-} from "./chunk-HDDRVXX4.js";
 import {
   detectImportFormat
 } from "./chunk-OZKVVUJB.js";
@@ -27,13 +27,16 @@ import {
 } from "./chunk-2DL3OFLD.js";
 import {
   backupMemoryDir
-} from "./chunk-2NLLXCJG.js";
+} from "./chunk-BXLOS5AJ.js";
 import {
   exportMarkdownBundle
 } from "./chunk-765K3SAT.js";
 import {
   RoutingRulesStore
 } from "./chunk-XL24QQ63.js";
+import {
+  WebDavServer
+} from "./chunk-PYIFUBRK.js";
 import {
   buildReplayNormalizerRegistry,
   clampBatchSize,
@@ -43,36 +46,33 @@ import {
   isReplaySource,
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  rebuildObservations
+} from "./chunk-DQTCGVFK.js";
 import {
   TailscaleHelper
 } from "./chunk-EEC4PCG5.js";
-import {
-  WebDavServer
-} from "./chunk-PYIFUBRK.js";
 import {
   migrateObservations
 } from "./chunk-IIFFC3RL.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-4GE3NA5I.js";
-import {
-  rebuildObservations
-} from "./chunk-DQTCGVFK.js";
+} from "./chunk-CME347TM.js";
 import {
   archiveObservations
 } from "./chunk-YLBE6PLR.js";
-import {
-  runCompatChecks
-} from "./chunk-CDKHKZL5.js";
 import {
   getBulkImportSource,
   listBulkImportSources,
   registerBulkImportSource,
   runBulkImportPipeline
 } from "./chunk-HSSERO3E.js";
+import {
+  runCompatChecks
+} from "./chunk-CDKHKZL5.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-ZUJW327U.js";
+} from "./chunk-FONW766A.js";
 import {
   getUtilityLearningStatus,
   learnUtilityPromotionWeights
@@ -86,15 +86,15 @@ import {
 } from "./chunk-OJP3N7UK.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-OTUFRUV3.js";
+} from "./chunk-LYPG7GOO.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-G7YUH4WT.js";
+} from "./chunk-TAMY4NKO.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-HGJ6NJ4E.js";
+} from "./chunk-D4LVHPOA.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -105,7 +105,7 @@ import {
 } from "./chunk-HYQJQGD3.js";
 import {
   parseXrayCliOptions
-} from "./chunk-FONWBCVY.js";
+} from "./chunk-IKT6ZVO7.js";
 import {
   readRuntimePolicySnapshot,
   sanitizeRuntimePolicyValues
@@ -118,7 +118,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-2GD6MLXD.js";
+} from "./chunk-TFXYQNBH.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -152,7 +152,7 @@ import {
 } from "./chunk-6GUG4YNM.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-PCRHFB75.js";
+} from "./chunk-4QFCAKNM.js";
 import {
   rescoreMemoryImportance
 } from "./chunk-JXS5PDQ7.js";
@@ -165,17 +165,17 @@ import {
   runEvalStoredBaselineCiGate,
   validateEvalBenchmarkPack
 } from "./chunk-MCA2X4WH.js";
+import {
+  GraphDashboardServer
+} from "./chunk-YNDLCWXS.js";
 import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-FEBHRT2I.js";
+} from "./chunk-FR3FNPCJ.js";
 import {
   getCueAnchorStoreStatus
 } from "./chunk-ACPCA4NO.js";
-import {
-  GraphDashboardServer
-} from "./chunk-YNDLCWXS.js";
 import {
   buildConnectorRowsFromDefinitions,
   parseConnectorsListOptions,
@@ -196,11 +196,11 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   parseConfig
-} from "./chunk-PG4QBPVG.js";
+} from "./chunk-3VFVQDZO.js";
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-IEQCHXUS.js";
+} from "./chunk-HQ2VGCGP.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -213,13 +213,13 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-XCO2NXPZ.js";
+} from "./chunk-O54B5YNM.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-DJUKBGAD.js";
 import {
   EngramAccessService
-} from "./chunk-MTF5EFFF.js";
+} from "./chunk-FK7T55BA.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -236,10 +236,10 @@ import {
   parseRecallExplainFormat,
   renderRecallExplain,
   renderXray
-} from "./chunk-H7NAZ3UB.js";
+} from "./chunk-U7BMN33M.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-7SF5BAWF.js";
+} from "./chunk-S6AH7WSF.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-HTP6XRUI.js";
@@ -248,31 +248,31 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-P2FA65P2.js";
+} from "./chunk-7NSC4IVA.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-TPWBUKS3.js";
+} from "./chunk-PSH3VFZ7.js";
 import {
   analyzeGraphHealth
-} from "./chunk-OLT3YTDH.js";
+} from "./chunk-YMOPYG3K.js";
 import {
   resolveNamespaceChildRoot
-} from "./chunk-Z463UYI6.js";
+} from "./chunk-HC55YCNK.js";
 import {
   getCausalTrajectoryStoreStatus
-} from "./chunk-ZXGKQQ3L.js";
+} from "./chunk-HXXGZ4KV.js";
 import {
   meetingIdDate
-} from "./chunk-XXRRHING.js";
+} from "./chunk-BWJMBJCY.js";
 import {
   isValidTranscriptDate
 } from "./chunk-UHVXE24Y.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-76JJSXK7.js";
+} from "./chunk-5QHDXMXP.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-KMAP7SNQ.js";
@@ -298,6 +298,11 @@ import {
 import {
   assertPathInsideRoot
 } from "./chunk-GCASGYIO.js";
+import {
+  inferMemoryStatus,
+  isArchivedMemoryPath,
+  toMemoryPathRel
+} from "./chunk-7RJUVTVF.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-XX4HPFFM.js";
@@ -321,7 +326,7 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -1527,6 +1532,367 @@ async function runRebuildMemoryLifecycleLedgerCliCommand(options) {
   });
 }
 
+// src/security/injection-screen.ts
+var RULE_WEIGHTS = {
+  // Direct commands to an agent are high-confidence instructions.
+  "imperative-to-agent": 4,
+  // Tool syntax names an executable operation and its arguments.
+  "tool-invocation-syntax": 4,
+  // Encoded blobs are opaque and cannot receive normal factual review.
+  "encoded-blob": 5,
+  // Instruction resets directly try to replace the active authority.
+  "ignore-previous-family": 4,
+  // Conditional triggers encode a hidden action for a future turn.
+  "conditional-trigger": 3,
+  // Remnic command references can redirect the memory system itself.
+  "authority-escalation": 4
+};
+var INJECTION_SCREEN_THRESHOLD = 4;
+var MAX_EXCERPT_LENGTH = 180;
+var AUTHORITY_EXECUTABLE_TOOL_REFERENCE = String.raw`(?:remnic|engram)(?:\s+security\s+audit-memory\b|\s+(?:memory_store|suggestion_submit|observe|recall|delete_memory|memory_correct_apply|memory_search)(?:\s+(?:tool|command))?\b|\s+(?:tool|command)\b|[_:-](?:memory_store|suggestion_submit|observe|recall|delete_memory|memory_correct_apply|memory_search)\b)`;
+var AUTHORITY_OPTIONAL_QUOTE = String.raw`[\`"']?`;
+var AUTHORITY_DIRECTIVE_PATTERN = new RegExp(
+  String.raw`\b(?:call|invoke|execute|run|use)\s+(?:the\s+)?${AUTHORITY_OPTIONAL_QUOTE}${AUTHORITY_EXECUTABLE_TOOL_REFERENCE}`,
+  "i"
+);
+var AUTHORITY_MANDATORY_DIRECTIVE_PATTERN = new RegExp(
+  String.raw`\byou\s+(?:must|should)\s+(?:call|invoke|execute|run|use)\s+(?:the\s+)?${AUTHORITY_OPTIONAL_QUOTE}${AUTHORITY_EXECUTABLE_TOOL_REFERENCE}`,
+  "i"
+);
+function excerptFor(content, match) {
+  const start = match?.index ?? 0;
+  const excerpt2 = content.slice(Math.max(0, start - 32), start + MAX_EXCERPT_LENGTH);
+  return excerpt2.length < content.length ? `${excerpt2}\u2026` : excerpt2;
+}
+function findingFor(rule, content, pattern) {
+  const match = content.match(pattern);
+  if (!match) return void 0;
+  return { rule, excerpt: excerptFor(content, match) };
+}
+function findImperativeToAgent(content) {
+  return findingFor(
+    "imperative-to-agent",
+    content,
+    /\b(?:agent|assistant|ai|model)\s*[,!:.-]\s*(?:please\s+)?(?:ignore|disregard|call|run|execute|send|delete|reveal|email|store|remember|follow|use|do)\b/i
+  ) ?? findingFor(
+    "imperative-to-agent",
+    content,
+    /\b(?:agent|assistant|ai|model)\s+(?:must|should|need to|please)\s+(?:ignore|disregard|call|run|execute|send|delete|reveal|email|store|remember|follow|use|do)\b/i
+  );
+}
+function findToolInvocationSyntax(content) {
+  return findingFor(
+    "tool-invocation-syntax",
+    content,
+    /\{\s*["']?(?:tool|function|name)["']?\s*:\s*["'][^"']+["'][\s\S]*["']?(?:args|arguments|parameters)["']?\s*:/i
+  ) ?? findingFor(
+    "tool-invocation-syntax",
+    content,
+    // Bare verbs only count when the target looks like a tool identifier
+    // (namespaced / snake_case / dotted) or is explicitly called a tool —
+    // plain English like "on-call SRE" or "call Sam" must not trip the
+    // screen (#1955 false-positive criterion).
+    /<(?:tool(?:_call)?|function(?:_call)?|invoke)\b[^>]*>|\b(?:call|invoke|execute|run)\s+(?:the\s+)?[a-z][a-z0-9-]*(?:[_:.][a-z0-9-]+)+\b|\b(?:call|invoke|execute|run)\s+the\s+[a-z0-9-]+\s+tool\b/i
+  ) ?? findingFor(
+    "tool-invocation-syntax",
+    content,
+    /\b(?:call|invoke|execute)\s*\(\s*["'][\w:-]+["']/i
+  );
+}
+function findEncodedBlob(content) {
+  return findingFor("encoded-blob", content, /\b[0-9a-f]{121,}\b/i) ?? findingFor(
+    "encoded-blob",
+    content,
+    /\b[A-Za-z0-9+/]{121,}={0,2}\b/
+  );
+}
+function findIgnorePreviousFamily(content) {
+  return findingFor(
+    "ignore-previous-family",
+    content,
+    /\b(?:ignore|disregard|skip|forget|dismiss)\s+(?:all\s+)?(?:the\s+)?(?:previous|prior|above|earlier|preceding)\s+(?:instructions?|directions?|rules?|messages?|context)\b/i
+  ) ?? findingFor(
+    "ignore-previous-family",
+    content,
+    /\b(?:do\s+not|don't)\s+(?:follow|obey)\s+(?:the\s+)?(?:previous|prior|above|earlier)\s+(?:instructions?|rules?|directions?)\b/i
+  );
+}
+function findConditionalTrigger(content) {
+  return findingFor(
+    "conditional-trigger",
+    content,
+    /\b(?:when|if)\b[\s\S]{1,120}\b(?:say|says|see|sees|hear|hears|receive|receives|mention|mentions|contain|contains|encounter|encounters)\b[\s\S]{1,120}\b(?:then\s+)?(?:call|invoke|run|execute|send|delete|reveal|store|use|follow|do|respond)\b/i
+  ) ?? findingFor(
+    "conditional-trigger",
+    content,
+    /\b(?:when|if)\b[\s\S]{1,100},\s*(?:then\s+)?(?:call|invoke|run|execute|send|delete|reveal|store|use|follow|do|respond)\b/i
+  );
+}
+function findAuthorityEscalation(content) {
+  return findingFor(
+    "authority-escalation",
+    content,
+    AUTHORITY_DIRECTIVE_PATTERN
+  ) ?? findingFor(
+    "authority-escalation",
+    content,
+    AUTHORITY_MANDATORY_DIRECTIVE_PATTERN
+  );
+}
+function screenCandidateFact(content) {
+  const findings = [];
+  const rules = [
+    ["imperative-to-agent", findImperativeToAgent],
+    ["tool-invocation-syntax", findToolInvocationSyntax],
+    ["encoded-blob", findEncodedBlob],
+    ["ignore-previous-family", findIgnorePreviousFamily],
+    ["conditional-trigger", findConditionalTrigger],
+    ["authority-escalation", findAuthorityEscalation]
+  ];
+  for (const [rule, find] of rules) {
+    const finding = find(content);
+    if (finding) findings.push({ rule, excerpt: finding.excerpt });
+  }
+  const score = findings.reduce((sum, finding) => sum + RULE_WEIGHTS[finding.rule], 0);
+  return { score, findings, quarantine: score >= INJECTION_SCREEN_THRESHOLD };
+}
+
+// src/security/audit-memory.ts
+function isActive(memory, memoryDir) {
+  const status = memory.frontmatter.status;
+  if (status !== void 0 && status !== "active") return false;
+  if (memory.frontmatter.archivedAt !== void 0) return false;
+  const pathRel = toMemoryPathRel(memoryDir, memory.path);
+  if (isArchivedMemoryPath(memory.path) || isArchivedMemoryPath(pathRel)) return false;
+  return inferMemoryStatus(memory.frontmatter, pathRel) === "active";
+}
+function parseSince(value) {
+  if (value === void 0) return void 0;
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new Error("invalid --since date");
+    return new Date(value.getTime());
+  }
+  return parseStrictCliDate(value, "--since");
+}
+function isInWindow(memory, since) {
+  if (since === void 0) return true;
+  const created = Date.parse(memory.frontmatter.created);
+  const updated = Date.parse(memory.frontmatter.updated);
+  return Number.isFinite(created) && created >= since.getTime() || Number.isFinite(updated) && updated >= since.getTime();
+}
+function excerpt(value) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  return compact.length > 180 ? `${compact.slice(0, 177)}...` : compact;
+}
+function lineageHint(memory) {
+  const frontmatter = memory.frontmatter;
+  const source = frontmatter.sources?.[0];
+  if (typeof source?.sessionKey === "string" && source.sessionKey.trim().length > 0) {
+    return source.sessionKey.trim();
+  }
+  for (const value of [
+    frontmatter.sourceSessionKey,
+    frontmatter.sessionKey,
+    frontmatter.conversationId,
+    frontmatter.sourceTurnId,
+    frontmatter.sourceConnector,
+    frontmatter.source
+  ]) {
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return "unknown";
+}
+var GENERIC_LINEAGE_VALUES = {
+  unknown: true,
+  none: true,
+  null: true,
+  "n/a": true,
+  na: true,
+  extraction: true,
+  connector: true
+};
+function lineageKey(memory) {
+  const frontmatter = memory.frontmatter;
+  const source = frontmatter.sources?.[0];
+  for (const value of [
+    source?.sessionKey,
+    frontmatter.sourceSessionKey,
+    frontmatter.sessionKey,
+    frontmatter.conversationId
+  ]) {
+    if (typeof value !== "string") continue;
+    const key = value.trim();
+    if (key.length > 0 && GENERIC_LINEAGE_VALUES[key.toLowerCase()] !== true) return key;
+  }
+  return void 0;
+}
+function sourceGroups(memories) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const memory of memories) {
+    const lineage = lineageKey(memory);
+    if (lineage === void 0) continue;
+    const day = typeof memory.frontmatter.created === "string" ? memory.frontmatter.created.slice(0, 10) : "";
+    if (!day) continue;
+    const key = `${lineage}@${day}`;
+    const group = groups.get(key) ?? [];
+    group.push(memory);
+    groups.set(key, group);
+  }
+  return groups;
+}
+function burstBaseline(counts) {
+  if (counts.length === 0) return { mean: 0, standardDeviation: 0, threshold: 10 };
+  const mean = counts.reduce((sum, count) => sum + count, 0) / counts.length;
+  const variance = counts.reduce((sum, count) => sum + (count - mean) ** 2, 0) / counts.length;
+  const standardDeviation = Math.sqrt(variance);
+  return {
+    mean,
+    standardDeviation,
+    threshold: Math.max(10, mean + 3 * standardDeviation)
+  };
+}
+function writeBurstStats(groups) {
+  const entries = [...groups.entries()];
+  const counts = entries.map(([, group]) => group.length);
+  const summary = burstBaseline(counts);
+  const anomalousGroups = entries.filter(([, group], candidateIndex) => {
+    const baselineCounts = counts.filter((_, index) => index !== candidateIndex);
+    const baseline = burstBaseline(baselineCounts);
+    return group.length > baseline.threshold;
+  }).map(([lineage, group]) => ({ lineageHint: lineage, count: group.length }));
+  return {
+    groupCount: counts.length,
+    mean: summary.mean,
+    standardDeviation: summary.standardDeviation,
+    threshold: summary.threshold,
+    anomalousGroups
+  };
+}
+async function auditMemoryStore(options) {
+  const since = parseSince(options.since);
+  const storage = options.storage;
+  const hotMemories = await storage.readAllMemories();
+  const coldMemories = storage.readAllColdMemories ? await storage.readAllColdMemories() : [];
+  const allMemories = [...hotMemories, ...coldMemories];
+  const activeMemories = allMemories.filter(
+    (memory) => isActive(memory, options.memoryDir) && isInWindow(memory, since)
+  );
+  const findings = [];
+  const quarantinePaths = /* @__PURE__ */ new Map();
+  for (const memory of activeMemories) {
+    const screened = screenCandidateFact(memory.content);
+    if (screened.quarantine === true) quarantinePaths.set(memory.path, { injection: true, burst: false });
+    for (const screenFinding of screened.findings) {
+      findings.push({
+        memoryId: memory.frontmatter.id,
+        category: "injection-signature",
+        rule: screenFinding.rule,
+        excerpt: excerpt(screenFinding.excerpt || memory.content),
+        lineageHint: lineageHint(memory)
+      });
+      if (screenFinding.rule === "authority-escalation") {
+        findings.push({
+          memoryId: memory.frontmatter.id,
+          category: "authority-escalation",
+          rule: screenFinding.rule,
+          excerpt: excerpt(screenFinding.excerpt || memory.content),
+          lineageHint: lineageHint(memory)
+        });
+      }
+    }
+  }
+  const groups = sourceGroups(activeMemories);
+  const burstStats = writeBurstStats(groups);
+  const anomalousLineages = new Set(burstStats.anomalousGroups.map((group) => group.lineageHint));
+  for (const [lineage, group] of groups) {
+    if (!anomalousLineages.has(lineage)) continue;
+    for (const memory of group) {
+      const q = quarantinePaths.get(memory.path) ?? { injection: false, burst: false };
+      q.burst = true;
+      quarantinePaths.set(memory.path, q);
+      findings.push({
+        memoryId: memory.frontmatter.id,
+        category: "write-burst",
+        rule: "write-burst",
+        excerpt: excerpt(memory.content),
+        lineageHint: lineage
+      });
+    }
+  }
+  const quarantinedMemoryIds = [];
+  if (options.quarantine) {
+    const now = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+    for (const staleMemory of activeMemories) {
+      const qInfo = quarantinePaths.get(staleMemory.path);
+      if (!qInfo) continue;
+      const memory = await storage.readMemoryByPath(staleMemory.path);
+      if (!memory || !isActive(memory, options.memoryDir)) continue;
+      if (qInfo.injection && !qInfo.burst && !screenCandidateFact(memory.content).quarantine) continue;
+      const changed = await storage.writeMemoryFrontmatterIfUnchanged(memory, {
+        status: "pending_review",
+        updated: now
+      }, {
+        actor: "cli.security.audit-memory",
+        reasonCode: "memory-poisoning-hardening",
+        ruleVersion: "memory-poisoning.v1"
+      });
+      if (changed) quarantinedMemoryIds.push(memory.frontmatter.id);
+    }
+  }
+  return {
+    ...since ? { since: since.toISOString() } : {},
+    scannedMemories: allMemories.length,
+    activeMemories: activeMemories.length,
+    findings,
+    quarantinedMemoryIds,
+    transitions: quarantinedMemoryIds.length,
+    writeBurstStats: burstStats
+  };
+}
+function formatAuditMemoryReport(report) {
+  const lines = [
+    "Memory security audit",
+    `Scanned: ${report.scannedMemories} total, ${report.activeMemories} active`,
+    `Findings: ${report.findings.length}`,
+    `Quarantined: ${report.transitions}`,
+    "",
+    "CATEGORY               MEMORY ID                 RULE                    LINEAGE              EXCERPT"
+  ];
+  if (report.findings.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const finding of report.findings) {
+      lines.push([
+        finding.category.padEnd(22),
+        finding.memoryId.padEnd(25),
+        finding.rule.padEnd(23),
+        finding.lineageHint.slice(0, 19).padEnd(20),
+        finding.excerpt
+      ].join(" "));
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/security/audit-memory-cli.ts
+function registerSecurityCommands(cmd, orchestrator) {
+  const securityCmd = cmd.command("security").description("Memory security audit and hardening workflows");
+  securityCmd.command("audit-memory").description("Audit the memory store for injection signatures, write bursts, and authority escalation").option("--since <date>", "Only scan memories created or updated on or after this ISO date").option("--quarantine", "Move flagged active memories to pending_review").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
+    const options = args[0] ?? {};
+    const report = await runAuditMemoryCliCommand({
+      memoryDir: orchestrator.config.memoryDir,
+      storage: orchestrator.storage,
+      since: typeof options.since === "string" && options.since.trim().length > 0 ? options.since.trim() : void 0,
+      quarantine: options.quarantine === true
+    });
+    if (options.json === true) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    console.log(formatAuditMemoryReport(report));
+  });
+}
+
 // src/chat/chat-cli.ts
 import { createInterface } from "readline";
 async function readAllStdin() {
@@ -2235,6 +2601,9 @@ async function runMemoryReviewDispositionCliCommand(options) {
     reasonCode: options.reasonCode
   };
 }
+async function runAuditMemoryCliCommand(options) {
+  return auditMemoryStore(options);
+}
 async function runMigrateObservationsCliCommand(options) {
   return migrateObservations({
     memoryDir: options.memoryDir,
@@ -3987,7 +4356,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
       );
       tierCmd.command("list").description("Summarize tier distribution across all memories").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const options = args[0] ?? {};
-        const { summarizeTiers, formatTierSummaryText } = await import("./tier-stats-EXYSKSVN.js");
+        const { summarizeTiers, formatTierSummaryText } = await import("./tier-stats-7E6OBUSD.js");
         const summary = await summarizeTiers(orchestrator.storage);
         if (reportHasMachineReadableOutput(options)) {
           console.log(JSON.stringify(summary, null, 2));
@@ -3998,7 +4367,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
       tierCmd.command("explain").description("Explain the tier-transition decision for a single memory").argument("<id>", "Memory id to explain").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const idArg = typeof args[0] === "string" ? args[0] : "";
         const options = args[1] ?? {};
-        const { explainTierForMemory, formatTierExplainText } = await import("./tier-stats-EXYSKSVN.js");
+        const { explainTierForMemory, formatTierExplainText } = await import("./tier-stats-7E6OBUSD.js");
         try {
           const explain = await explainTierForMemory(
             orchestrator.storage,
@@ -4031,7 +4400,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const idArg = typeof args[0] === "string" ? args[0] : "";
         const options = args[1] ?? {};
         const reason = typeof options.reason === "string" && options.reason.trim().length > 0 ? options.reason.trim() : void 0;
-        const { forgetMemory } = await import("./forget-EHGGJZLX.js");
+        const { forgetMemory } = await import("./forget-5TWK7CZT.js");
         try {
           const result = await forgetMemory(orchestrator.storage, {
             id: idArg,
@@ -4589,7 +4958,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
         }
         if (sourceArchive.endsWith(".enc")) {
-          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-7FJQINUR.js");
+          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-YO5QJ6L3.js");
           const encDetected = await isEncryptedCapsuleFile(sourceArchive).catch(() => true);
           if (encDetected) {
             throw new Error(
@@ -4752,7 +5121,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           const { parseExportBundle } = await import("./transfer/types.js");
           let decryptedBuf;
           try {
-            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-7FJQINUR.js");
+            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-YO5QJ6L3.js");
             decryptedBuf = await decryptCapsuleFileInMemory(archivePath, memoryDir);
           } catch (decErr) {
             const msg = decErr instanceof Error ? decErr.message : String(decErr);
@@ -6270,6 +6639,7 @@ ${doc.content}` : doc.content,
         }
         console.log("OK");
       });
+      registerSecurityCommands(cmd, orchestrator);
       cmd.command("governance-run").description("Run memory governance in shadow/apply mode and write audit artifacts").option("--mode <mode>", "Governance mode (shadow|apply)", "shadow").option("--max-memories <n>", "Maximum memories to scan in this run").option("--batch-size <n>", "File-read batch size for bounded governance runs").option("--recent-days <n>", "Only govern memories updated within the last N days").option("--namespace <ns>", "Namespace to govern (default: current default namespace)").action(async (...args) => {
         const options = args[0] ?? {};
         const mode = options.mode === "apply" ? "apply" : "shadow";
@@ -7236,7 +7606,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           console.error("--verb is required. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context");
           process.exit(1);
         }
-        const { isValidResolutionVerb, executeResolution } = await import("./resolution-MMOD5WC4.js");
+        const { isValidResolutionVerb, executeResolution } = await import("./resolution-DKMBPXHI.js");
         if (!isValidResolutionVerb(verb)) {
           console.error(`Invalid verb: ${verb}. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context`);
           process.exit(1);
@@ -7268,7 +7638,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
       });
       reviewCmd.command("scan").description("Run an on-demand contradiction scan").option("--namespace <ns>", "Namespace to scan").action(async (...args) => {
         const options = args[0] ?? {};
-        const { runContradictionScan } = await import("./contradiction-scan-JDTBXRGW.js");
+        const { runContradictionScan } = await import("./contradiction-scan-522AYLQC.js");
         console.log("Running contradiction scan...");
         const result = await runContradictionScan({
           storage: orchestrator.storage,
@@ -7890,6 +8260,10 @@ function parseDuration(duration) {
 }
 
 export {
+  INJECTION_SCREEN_THRESHOLD,
+  screenCandidateFact,
+  auditMemoryStore,
+  formatAuditMemoryReport,
   registerWearableConnector,
   getWearableConnector,
   listWearableConnectors,
@@ -7920,6 +8294,7 @@ export {
   runMemoryGovernanceReportCliCommand,
   runMemoryGovernanceRestoreCliCommand,
   runMemoryReviewDispositionCliCommand,
+  runAuditMemoryCliCommand,
   runMigrateObservationsCliCommand,
   runConversationIndexHealthCliCommand,
   runConversationIndexInspectCliCommand,
@@ -7995,4 +8370,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-OS5DYALF.js.map
+//# sourceMappingURL=chunk-4THNU7OF.js.map