@remnic/plugin-openclaw 1.0.11 → 1.0.12

package/dist/{chunk-TVKKIS53.js → chunk-CDAZGIGT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4G2XCSD2.js";
 import {
   StorageManager
-} from "./chunk-TNH24SF6.js";
+} from "./chunk-7UZNLMW5.js";
 
 // ../remnic-core/src/maintenance/memory-governance.ts
 import path from "path";

package/dist/{chunk-XMSDA5WA.js → chunk-EXDYWXMB.js}

@@ -4044,5 +4044,6 @@ var coerce = {
 var NEVER = INVALID;
 
 export {
+  ZodError,
   external_exports
 };

package/dist/{capsule-export-CVA3CKUQ.js → chunk-FGTYFLL5.js}

@@ -1,13 +1,9 @@
-import {
-  CAPSULE_SCHEMA_VERSION,
-  EXPORT_FORMAT
-} from "./chunk-YGXXBRV7.js";
 import {
   CAPSULE_ID_PATTERN,
   CapsuleBlockSchema,
   ExportBundleV2Schema,
   ExportManifestV2Schema
-} from "./chunk-K7EUBNDD.js";
+} from "./chunk-4LYQ4ONL.js";
 import {
   listFilesRecursive,
   sha256File,
@@ -17,17 +13,18 @@ import {
 import {
   encryptCapsuleFile
 } from "./chunk-SSFTU6LP.js";
-import "./chunk-XMSDA5WA.js";
-import "./chunk-CXM7EBAO.js";
-import "./chunk-JZBOXOUC.js";
-import "./chunk-6IWEAUN6.js";
-import "./chunk-YGGGUTG3.js";
-import "./chunk-MLKGABMK.js";
 
 // ../remnic-core/src/transfer/capsule-export.ts
 import { mkdir, readFile, stat, writeFile } from "fs/promises";
 import path from "path";
 import { gzipSync } from "zlib";
+
+// ../remnic-core/src/transfer/constants.ts
+var EXPORT_FORMAT = "openclaw-engram-export";
+var EXPORT_SCHEMA_VERSION = 1;
+var CAPSULE_SCHEMA_VERSION = 2;
+
+// ../remnic-core/src/transfer/capsule-export.ts
 var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -145,6 +142,14 @@ function parseSince(since) {
   assertCalendarRoundTrip(since, ms);
   return ms;
 }
+function isValidCapsuleSince(since) {
+  try {
+    parseSince(since);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function assertCalendarRoundTrip(since, ms) {
   const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(since);
   if (!m) return;
@@ -260,6 +265,10 @@ function buildCapsuleBlock(name, override) {
   };
   return CapsuleBlockSchema.parse(merged);
 }
+
 export {
-  exportCapsule
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION,
+  exportCapsule,
+  isValidCapsuleSince
 };

package/dist/{chunk-ETJZRIAM.js → chunk-L6I4MQKO.js}

@@ -1,6 +1,6 @@
 import {
   parseExportBundle
-} from "./chunk-K7EUBNDD.js";
+} from "./chunk-4LYQ4ONL.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,

package/dist/{capsule-cli-TFKLAG3S.js → chunk-LLUROTZJ.js}

@@ -1,5 +1,3 @@
-import "./chunk-MLKGABMK.js";
-
 // ../remnic-core/src/capsule-cli.ts
 import path from "path";
 function parseCapsuleOutputFormat(raw) {
@@ -311,19 +309,20 @@ function renderCapsuleInspect(manifest, format) {
   }
   return lines.join("\n") + "\n";
 }
+
 export {
-  defaultCapsulesDir,
+  parseCapsuleOutputFormat,
+  parseCapsuleImportMode,
   parseCapsuleConflictMode,
+  parseCapsuleSince,
+  parseCapsuleIncludeKinds,
+  parseCapsulePeers,
   parseCapsuleExportOptions,
-  parseCapsuleImportMode,
   parseCapsuleImportOptions,
-  parseCapsuleIncludeKinds,
-  parseCapsuleInspectOptions,
-  parseCapsuleListOptions,
   parseCapsuleMergeOptions,
-  parseCapsuleOutputFormat,
-  parseCapsulePeers,
-  parseCapsuleSince,
-  renderCapsuleInspect,
-  renderCapsuleList
+  parseCapsuleListOptions,
+  parseCapsuleInspectOptions,
+  defaultCapsulesDir,
+  renderCapsuleList,
+  renderCapsuleInspect
 };

package/dist/{chunk-L4PRBB2A.js → chunk-OAE7AQ6R.js}

@@ -1,26 +1,26 @@
 import {
   external_exports
-} from "./chunk-XMSDA5WA.js";
+} from "./chunk-EXDYWXMB.js";
 import {
   StorageManager,
   parseContinuityImprovementLoops,
-  parseContinuityIncident,
   sanitizeMemoryContent
-} from "./chunk-TNH24SF6.js";
+} from "./chunk-7UZNLMW5.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
+import {
+  expandTildePath
+} from "./chunk-OEI7GLV2.js";
 
 // ../remnic-core/src/compounding/engine.ts
 import { createHash } from "crypto";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, unlink, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
-import os2 from "os";
 
 // ../remnic-core/src/shared-context/manager.ts
 import { mkdir, readFile, readdir, appendFile, writeFile, stat } from "fs/promises";
 import path from "path";
-import os from "os";
 var SharedFeedbackEntrySchema = external_exports.object({
   agent: external_exports.string().min(1),
   decision: external_exports.enum(["approved", "approved_with_feedback", "rejected"]),
@@ -256,10 +256,13 @@ function formatFeedbackLine(entry) {
 function formatOverlapLine(entry) {
   return `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")}) [sources: ${entry.sourcePaths.join(", ")}]`;
 }
+function resolveSharedContextDir(config) {
+  return typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? expandTildePath(config.sharedContextDir) : path.join(expandTildePath(config.workspaceDir), "shared-context");
+}
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path.join(os.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = resolveSharedContextDir(config);
     this.dir = base;
     this.prioritiesPath = path.join(base, "priorities.md");
     this.prioritiesInboxPath = path.join(base, "priorities.inbox.md");
@@ -764,12 +767,6 @@ function monthIdFromIsoWeek(weekId) {
   monday.setUTCDate(isoWeekOneMonday.getUTCDate() + (week - 1) * 7);
   return isoMonthId(monday);
 }
-function sharedContextDir(config) {
-  if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
-    return config.sharedContextDir;
-  }
-  return path2.join(os2.homedir(), ".openclaw", "workspace", "shared-context");
-}
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
     case "daily":
@@ -785,8 +782,9 @@ function cadenceStaleWindowMs(cadence) {
   }
 }
 var CompoundingEngine = class {
-  constructor(config) {
+  constructor(config, storage = new StorageManager(config.memoryDir)) {
     this.config = config;
+    this.storage = storage;
     this.weeklyDir = path2.join(config.memoryDir, "compounding", "weekly");
     this.rubricsDir = path2.join(config.memoryDir, "compounding", "rubrics");
     this.rubricsIndexPath = path2.join(this.rubricsDir, "index.json");
@@ -794,15 +792,13 @@ var CompoundingEngine = class {
     this.rubricsWorkflowsDir = path2.join(this.rubricsDir, "workflows");
     this.rubricsPath = path2.join(config.memoryDir, "compounding", "rubrics.md");
     this.mistakesPath = path2.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path2.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path2.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path2.join(config.memoryDir, "identity", "incidents");
+    this.feedbackInboxPath = path2.join(resolveSharedContextDir(config), "feedback", "inbox.jsonl");
     this.identityAuditWeeklyDir = path2.join(config.memoryDir, "identity", "audits", "weekly");
     this.identityAuditMonthlyDir = path2.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path2.join(config.memoryDir, "identity", "improvement-loops.md");
     this.memoryActionEventsPath = path2.join(config.memoryDir, "state", "memory-actions.jsonl");
   }
   config;
+  storage;
   weeklyDir;
   rubricsDir;
   rubricsIndexPath;
@@ -811,11 +807,8 @@ var CompoundingEngine = class {
   rubricsPath;
   mistakesPath;
   feedbackInboxPath;
-  identityAnchorPath;
-  identityIncidentsDir;
   identityAuditWeeklyDir;
   identityAuditMonthlyDir;
-  identityImprovementLoopsPath;
   memoryActionEventsPath;
   async ensureDirs() {
     await mkdir2(this.weeklyDir, { recursive: true });
@@ -838,7 +831,7 @@ var CompoundingEngine = class {
     let promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
     if (this.config.cmcConsolidationEnabled) {
       try {
-        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-JD6KJJH6.js");
+        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-YI53C2AO.js");
         const causalCandidates = await deriveCausalPromotionCandidates({
           memoryDir: this.config.memoryDir,
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -1030,13 +1023,14 @@ var CompoundingEngine = class {
     const period = opts?.period === "monthly" ? "monthly" : "weekly";
     const key = opts?.key?.trim() || (period === "weekly" ? isoWeekId(/* @__PURE__ */ new Date()) : isoMonthId(/* @__PURE__ */ new Date()));
     const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-    const [anchorPresent, improvementLoopsRaw, openIncidents, closedIncidents, mistakes] = await Promise.all([
-      this.readNonEmptyFile(this.identityAnchorPath),
-      this.readOptionalFile(this.identityImprovementLoopsPath),
-      this.readContinuityIncidents(200, "open"),
-      this.readContinuityIncidents(200, "closed"),
+    const [identityAnchor, improvementLoopsRaw, openIncidents, closedIncidents, mistakes] = await Promise.all([
+      this.readOptionalIdentityAnchorForAudit(),
+      this.readOptionalImprovementLoopsForAudit(),
+      this.readContinuityIncidentsForAudit(200, "open"),
+      this.readContinuityIncidentsForAudit(200, "closed"),
       this.readMistakes()
     ]);
+    const anchorPresent = (identityAnchor ?? "").trim().length > 0;
     const improvementLoops = improvementLoopsRaw ? parseContinuityImprovementLoops(improvementLoopsRaw) : [];
     const activeLoops = improvementLoops.filter((loop) => loop.status === "active");
     const staleActiveLoops = activeLoops.filter((loop) => {
@@ -1097,10 +1091,7 @@ var CompoundingEngine = class {
       ...openIncidents.length > 0 ? openIncidents.slice(0, 20).map((i) => `- ${i.id}`) : ["- (none)"],
       ""
     ];
-    const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
-    await mkdir2(dir, { recursive: true });
-    const reportPath = path2.join(dir, `${key}.md`);
-    await writeFile2(reportPath, lines.join("\n"), "utf-8");
+    const reportPath = await this.storage.writeIdentityAudit(period, key, lines.join("\n"));
     return { period, key, reportPath };
   }
   async readMistakes() {
@@ -1254,29 +1245,19 @@ var CompoundingEngine = class {
   }
   async readActionEventsForWeek(weekId) {
     const out = [];
-    try {
-      const raw = await readFile2(this.memoryActionEventsPath, "utf-8");
-      const lines = raw.split("\n");
-      for (let idx = 0; idx < lines.length; idx += 1) {
-        const line = lines[idx];
-        if (!line.trim()) continue;
-        try {
-          const parsed = JSON.parse(line);
-          if (typeof parsed.timestamp !== "string" || typeof parsed.action !== "string") continue;
-          const ts = new Date(parsed.timestamp);
-          if (!Number.isFinite(ts.getTime()) || isoWeekId(ts) !== weekId) continue;
-          out.push({
-            line: idx + 1,
-            action: parsed.action,
-            outcome: parsed.outcome === "applied" || parsed.outcome === "skipped" || parsed.outcome === "failed" ? parsed.outcome : "unknown",
-            policyDecision: parsed.policyDecision === "deny" || parsed.policyDecision === "defer" ? parsed.policyDecision : null,
-            namespace: typeof parsed.namespace === "string" && parsed.namespace.length > 0 ? parsed.namespace : "default",
-            reason: typeof parsed.reason === "string" ? parsed.reason : null
-          });
-        } catch {
-        }
-      }
-    } catch {
+    const rows = await this.storage.readMemoryActionEventRows(Number.MAX_SAFE_INTEGER);
+    for (const row of rows) {
+      const event = row.event;
+      const ts = new Date(event.timestamp);
+      if (!Number.isFinite(ts.getTime()) || isoWeekId(ts) !== weekId) continue;
+      out.push({
+        line: row.line,
+        action: event.action,
+        outcome: event.outcome,
+        policyDecision: event.policyDecision === "deny" || event.policyDecision === "defer" ? event.policyDecision : null,
+        namespace: typeof event.namespace === "string" && event.namespace.length > 0 ? event.namespace : "default",
+        reason: typeof event.reason === "string" ? event.reason : null
+      });
     }
     return out;
   }
@@ -1285,19 +1266,18 @@ var CompoundingEngine = class {
     for (const event of events) {
       const key = event.action;
       const acc = byAction.get(key) ?? {
-        counts: { applied: 0, skipped: 0, failed: 0, unknown: 0 },
+        counts: { applied: 0, skipped: 0, failed: 0 },
         provenance: /* @__PURE__ */ new Set()
       };
       if (event.outcome === "applied") acc.counts.applied += 1;
       else if (event.outcome === "skipped") acc.counts.skipped += 1;
-      else if (event.outcome === "failed") acc.counts.failed += 1;
-      else acc.counts.unknown += 1;
+      else acc.counts.failed += 1;
       acc.provenance.add(`${path2.basename(this.memoryActionEventsPath)}:L${event.line}`);
       byAction.set(key, acc);
     }
     const out = [];
     for (const [action, data] of byAction.entries()) {
-      const total = data.counts.applied + data.counts.skipped + data.counts.failed + data.counts.unknown;
+      const total = data.counts.applied + data.counts.skipped + data.counts.failed;
       if (total <= 0) continue;
       const weightedScore = Number(((data.counts.applied * 1 - data.counts.skipped * 0.5 - data.counts.failed * 1.5) / total).toFixed(3));
       out.push({
@@ -1334,7 +1314,7 @@ var CompoundingEngine = class {
       if (item.total < 3) continue;
       if (item.weightedScore < 0.3) continue;
       const content = normalizePromotedGuidanceContent(
-        `Prefer ${item.action} when the same workflow recurs; this week's outcomes were applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}, unknown=${item.counts.unknown}.`
+        `Prefer ${item.action} when the same workflow recurs; this week's outcomes were applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}.`
       );
       upsert({
         id: stablePromotionCandidateId("action-outcome", item.action, content),
@@ -1561,7 +1541,7 @@ var CompoundingEngine = class {
     } else {
       for (const item of outcomeSummary.slice(0, 20)) {
         lines.push(
-          `- ${item.action}: applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}, unknown=${item.counts.unknown}, weight=${item.weightedScore} _(source: ${item.provenance.join(", ")})_`
+          `- ${item.action}: applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}, weight=${item.weightedScore} _(source: ${item.provenance.join(", ")})_`
         );
       }
     }
@@ -1572,7 +1552,7 @@ var CompoundingEngine = class {
         lines.push("- (no advisory promotion candidates this week)");
       } else {
         for (const candidate of promotionCandidates) {
-          const outcomeSummaryText = candidate.outcome ? ` outcomes[a=${candidate.outcome.applied}, s=${candidate.outcome.skipped}, f=${candidate.outcome.failed}, u=${candidate.outcome.unknown}]` : "";
+          const outcomeSummaryText = candidate.outcome ? ` outcomes[a=${candidate.outcome.applied}, s=${candidate.outcome.skipped}, f=${candidate.outcome.failed}]` : "";
           lines.push(
             `- [${candidate.sourceType}] ${candidate.subject} -> ${candidate.content} (category=${candidate.category}, score=${candidate.score}, id=${candidate.id}): ${candidate.rationale}${outcomeSummaryText} _(source: ${candidate.provenance.join(", ")})_`
           );
@@ -1648,7 +1628,7 @@ var CompoundingEngine = class {
       };
       this.addRubricObservation(
         workflowEntry,
-        `Outcome weight=${item.weightedScore} (applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}, unknown=${item.counts.unknown})`,
+        `Outcome weight=${item.weightedScore} (applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed})`,
         ...item.provenance
       );
       byWorkflow.set(item.action, workflowEntry);
@@ -1705,7 +1685,7 @@ var CompoundingEngine = class {
     } else {
       for (const item of outcomeSummary.slice(0, 20)) {
         lines.push(
-          `- ${item.action}: weight=${item.weightedScore} (applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed}, unknown=${item.counts.unknown})`
+          `- ${item.action}: weight=${item.weightedScore} (applied=${item.counts.applied}, skipped=${item.counts.skipped}, failed=${item.counts.failed})`
         );
       }
     }
@@ -1798,52 +1778,44 @@ var CompoundingEngine = class {
     entry.observations = normalized.observationEntries?.map((item) => item.note) ?? [];
     entry.provenance = [...new Set((normalized.observationEntries ?? []).flatMap((item) => item.provenance))];
   }
-  async readNonEmptyFile(filePath) {
+  async readOptionalIdentityAnchorForAudit() {
     try {
-      const raw = await readFile2(filePath, "utf-8");
-      return raw.trim().length > 0;
+      return await this.storage.readIdentityAnchor();
     } catch {
-      return false;
+      return null;
     }
   }
-  async readOptionalFile(filePath) {
+  async readOptionalImprovementLoopsForAudit() {
     try {
-      const raw = await readFile2(filePath, "utf-8");
-      return raw.trim().length > 0 ? raw : null;
+      return await this.storage.readIdentityImprovementLoops();
     } catch {
       return null;
     }
   }
-  async readContinuityIncidents(limit = 200, state) {
-    const normalizedLimit = Number.isFinite(limit) ? limit : 0;
-    const cappedLimit = Math.max(0, Math.floor(normalizedLimit));
-    if (cappedLimit === 0) return [];
-    const incidents = [];
+  async readContinuityIncidentsForAudit(limit, state) {
     try {
-      const names = await readdir2(this.identityIncidentsDir);
-      const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
-      for (const file of files) {
-        if (incidents.length >= cappedLimit) break;
-        const filePath = path2.join(this.identityIncidentsDir, file);
-        try {
-          const raw = await readFile2(filePath, "utf-8");
-          const parsed = parseContinuityIncident(raw);
-          if (!parsed) continue;
-          if (state && parsed.state !== state) continue;
-          incidents.push(parsed);
-        } catch {
-        }
-      }
+      return await this.storage.readContinuityIncidents(limit, state);
     } catch {
+      return [];
+    }
+  }
+  async readOptionalIdentityAuditForReference(period, key) {
+    try {
+      return await this.storage.readIdentityAudit(period, key);
+    } catch {
+      return null;
     }
-    return incidents;
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
     const weeklyPath = path2.join(this.identityAuditWeeklyDir, `${weekId}.md`);
     const monthlyPath = path2.join(this.identityAuditMonthlyDir, `${monthId}.md`);
-    const weeklyExists = await this.readNonEmptyFile(weeklyPath);
-    const monthlyExists = await this.readNonEmptyFile(monthlyPath);
+    const [weeklyAudit, monthlyAudit] = await Promise.all([
+      this.readOptionalIdentityAuditForReference("weekly", weekId),
+      this.readOptionalIdentityAuditForReference("monthly", monthId)
+    ]);
+    const weeklyExists = (weeklyAudit ?? "").trim().length > 0;
+    const monthlyExists = (monthlyAudit ?? "").trim().length > 0;
     return {
       weekId,
       monthId,

package/dist/{chunk-3I7RHWYT.js → chunk-RKR6PTPA.js}

@@ -111,8 +111,8 @@ async function writeMaybeEncryptedFile(filePath, content, key, options = {}, mem
 }
 async function migrateMemoryDirToEncrypted(dir, key, onBeforeEncrypt) {
   const result = { encrypted: 0, skipped: 0, errors: [] };
-  const mdFiles = await collectMdFiles(dir);
-  for (const filePath of mdFiles) {
+  const files = await collectEncryptableStorageFiles(dir);
+  for (const filePath of files) {
     try {
       const buf = await readFile(filePath);
       if (isEncryptedFile(buf)) {
@@ -126,7 +126,7 @@ async function migrateMemoryDirToEncrypted(dir, key, onBeforeEncrypt) {
         }
       }
       const content = buf.toString("utf8");
-      const aad = filePathAad(filePath, dir);
+      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
       const encrypted = encryptFileBody(content, key, aad);
       const tempPath = `${filePath}.enc-tmp-${process.pid}-${Date.now()}`;
       try {
@@ -150,7 +150,43 @@ async function migrateMemoryDirToEncrypted(dir, key, onBeforeEncrypt) {
   }
   return result;
 }
-async function collectMdFiles(dir, rootDir = dir) {
+async function decryptMemoryDirToPlaintext(dir, key) {
+  const result = { decrypted: 0, skipped: 0, errors: [] };
+  const files = await collectStorageManagedFiles(dir, isDecryptableStoragePath);
+  for (const filePath of files) {
+    try {
+      const buf = await readFile(filePath);
+      if (!isEncryptedFile(buf)) {
+        result.skipped++;
+        continue;
+      }
+      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
+      const plaintext = decryptFileBody(buf, key, aad);
+      const tempPath = `${filePath}.dec-tmp-${process.pid}-${Date.now()}`;
+      try {
+        await writeFile(tempPath, plaintext, { mode: 384 });
+        await rename(tempPath, filePath);
+        result.decrypted++;
+      } catch (writeErr) {
+        try {
+          await unlink(tempPath);
+        } catch {
+        }
+        throw writeErr;
+      }
+    } catch (err) {
+      result.errors.push({
+        filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+async function collectEncryptableStorageFiles(dir, rootDir = dir) {
+  return collectStorageManagedFiles(dir, isEncryptableStoragePath, rootDir);
+}
+async function collectStorageManagedFiles(dir, includeFile, rootDir = dir) {
   const results = [];
   let names;
   try {
@@ -172,9 +208,9 @@ async function collectMdFiles(dir, rootDir = dir) {
       continue;
     }
     if (isDir) {
-      const sub = await collectMdFiles(full, rootDir);
+      const sub = await collectStorageManagedFiles(full, includeFile, rootDir);
       results.push(...sub);
-    } else if (isFile && name.endsWith(".md") && isEncryptableStoragePath(full, rootDir)) {
+    } else if (isFile && includeFile(full, rootDir)) {
       results.push(full);
     }
   }
@@ -183,18 +219,75 @@ async function collectMdFiles(dir, rootDir = dir) {
 function isEncryptableStoragePath(filePath, rootDir) {
   const rel = path.relative(rootDir, filePath);
   if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
-  const normalized = rel.split(path.sep).join("/");
+  const normalized = normalizeStorageRelativePath(rel);
   if (normalized === "profile.md") return true;
+  if (isEncryptableStateSidecar(normalized)) return true;
+  if (isEncryptableSummarySidecar(normalized)) return true;
   const firstSegment = normalized.split("/", 1)[0];
-  return ENCRYPTABLE_STORAGE_ROOTS.has(firstSegment);
+  return ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS.has(firstSegment) && normalized.endsWith(".md");
 }
-var ENCRYPTABLE_STORAGE_ROOTS = /* @__PURE__ */ new Set([
+function isDecryptableStoragePath(filePath, rootDir) {
+  if (isEncryptableStoragePath(filePath, rootDir)) return true;
+  const rel = path.relative(rootDir, filePath);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
+  const normalized = normalizeStorageRelativePath(rel);
+  const firstSegment = normalized.split("/", 1)[0];
+  return DECRYPTABLE_SIDECAR_ROOTS.has(firstSegment);
+}
+function normalizeStorageRelativePath(rel) {
+  const normalized = rel.split(path.sep).join("/");
+  const parts = normalized.split("/");
+  if (parts[0] === "namespaces" && parts.length >= 3) {
+    return parts.slice(2).join("/");
+  }
+  return normalized;
+}
+function storageAadRootForFile(filePath, rootDir) {
+  const rel = path.relative(rootDir, filePath);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return rootDir;
+  const parts = rel.split(path.sep);
+  if (parts[0] === "namespaces" && parts.length >= 3 && parts[1]) {
+    return path.join(rootDir, "namespaces", parts[1]);
+  }
+  return rootDir;
+}
+var ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = /* @__PURE__ */ new Set([
   "facts",
   "corrections",
   "procedures",
   "reasoning-traces",
   "artifacts",
-  "archive"
+  "archive",
+  "entities",
+  "identity"
+]);
+var ENCRYPTABLE_STATE_SIDECARS = /* @__PURE__ */ new Set([
+  "state/behavior-signals.jsonl",
+  "state/buffer-surprise-ledger.jsonl",
+  "state/buffer.json",
+  "state/compression-guideline-draft-state.json",
+  "state/compression-guideline-state.json",
+  "state/compression-guidelines.draft.md",
+  "state/compression-guidelines.md",
+  "state/entity-synthesis-queue.json",
+  "state/fact-hashes.txt",
+  "state/memory-actions.jsonl",
+  "state/memory-lifecycle-ledger.jsonl",
+  "state/meta.json",
+  "state/reextract-jobs.jsonl",
+  "state/topics.json"
+]);
+function isEncryptableStateSidecar(normalized) {
+  return ENCRYPTABLE_STATE_SIDECARS.has(normalized);
+}
+function isEncryptableSummarySidecar(normalized) {
+  return normalized.startsWith("summaries/") && normalized.endsWith(".json");
+}
+var DECRYPTABLE_SIDECAR_ROOTS = /* @__PURE__ */ new Set([
+  "state",
+  "indexes",
+  "index",
+  "provenance"
 ]);
 
 export {
@@ -210,5 +303,6 @@ export {
   filePathAad,
   readMaybeEncryptedFile,
   writeMaybeEncryptedFile,
-  migrateMemoryDirToEncrypted
+  migrateMemoryDirToEncrypted,
+  decryptMemoryDirToPlaintext
 };

package/dist/{chunk-P3DIW2SD.js → chunk-TILAJIJR.js}

@@ -5,7 +5,7 @@ import {
 import {
   StorageManager,
   isSemanticConsolidationLlmOperator
-} from "./chunk-TNH24SF6.js";
+} from "./chunk-7UZNLMW5.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";

package/dist/{engine-VMTFKFGO.js → engine-BIYI3P4J.js}

@@ -1,13 +1,15 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-L4PRBB2A.js";
-import "./chunk-XMSDA5WA.js";
-import "./chunk-TNH24SF6.js";
+} from "./chunk-OAE7AQ6R.js";
+import "./chunk-EXDYWXMB.js";
+import "./chunk-7UZNLMW5.js";
 import "./chunk-6OJAU466.js";
-import "./chunk-3I7RHWYT.js";
+import "./chunk-RKR6PTPA.js";
 import "./chunk-UFU5GGGA.js";
 import "./chunk-YGGGUTG3.js";
+import "./chunk-OEI7GLV2.js";
+import "./chunk-I6B2W2IY.js";
 import "./chunk-MLKGABMK.js";
 export {
   CompoundingEngine,