@remnic/plugin-openclaw 1.0.11 → 1.0.12

package/dist/index.js

@@ -1,10 +1,6 @@
 import {
   compareVersions
 } from "./chunk-GUSMRW4H.js";
-import {
-  EXPORT_FORMAT,
-  EXPORT_SCHEMA_VERSION
-} from "./chunk-YGXXBRV7.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule,
@@ -12,10 +8,20 @@ import {
 } from "./chunk-FQRSVYY4.js";
 import {
   importCapsule
-} from "./chunk-ETJZRIAM.js";
+} from "./chunk-L6I4MQKO.js";
+import {
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION,
+  exportCapsule,
+  isValidCapsuleSince
+} from "./chunk-FGTYFLL5.js";
 import {
+  CAPSULE_ID_PATTERN,
   ExportBundleV1Schema
-} from "./chunk-K7EUBNDD.js";
+} from "./chunk-4LYQ4ONL.js";
+import {
+  defaultCapsulesDir
+} from "./chunk-LLUROTZJ.js";
 import {
   TierMigrationExecutor
 } from "./chunk-BU5KJVWF.js";
@@ -37,7 +43,7 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-TVKKIS53.js";
+} from "./chunk-CDAZGIGT.js";
 import {
   clamp01,
   clampLifecycleThreshold,
@@ -84,7 +90,7 @@ import {
   parseOperatorAwareConsolidationResponse,
   renderExtensionsFooter,
   resolveExtensionsRoot
-} from "./chunk-P3DIW2SD.js";
+} from "./chunk-TILAJIJR.js";
 import {
   BoxBuilder,
   countRecallTokenOverlap,
@@ -109,11 +115,12 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-L4PRBB2A.js";
+} from "./chunk-OAE7AQ6R.js";
 import {
+  ZodError,
   external_exports
-} from "./chunk-XMSDA5WA.js";
-import "./chunk-N7EOZY6F.js";
+} from "./chunk-EXDYWXMB.js";
+import "./chunk-6F6EKSVP.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -181,11 +188,11 @@ import {
   sortMemoryLifecycleEvents,
   stripCitationForTemplate,
   toMemoryPathRel
-} from "./chunk-TNH24SF6.js";
+} from "./chunk-7UZNLMW5.js";
 import {
   sidecarKey
 } from "./chunk-6OJAU466.js";
-import "./chunk-3I7RHWYT.js";
+import "./chunk-RKR6PTPA.js";
 import {
   initLogger,
   log
@@ -32443,7 +32450,7 @@ var Orchestrator = class _Orchestrator {
     this.conversationFaiss = conversationIndexRuntime.faiss;
     this.conversationIndexBackend = conversationIndexRuntime.backend;
     this.sharedContext = config.sharedContextEnabled ? new SharedContextManager(config) : void 0;
-    this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
+    this.compounding = config.compoundingEnabled ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
     this.conversationIndexDir = path43.join(
@@ -32745,8 +32752,7 @@ var Orchestrator = class _Orchestrator {
         promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
       });
       if (this.config.factDeduplicationEnabled) {
-        const stateDir2 = path43.join(this.config.memoryDir, "state");
-        this.contentHashIndex = new ContentHashIndex(stateDir2);
+        this.contentHashIndex = this.storage.createContentHashIndex();
         await this.contentHashIndex.load();
         log.info(
           `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
@@ -33404,7 +33410,7 @@ ${doc.content}` : doc.content,
   }
   async runDeepSleepGovernanceNow(options) {
     const targetStorage = options?.storage ?? this.storage;
-    const { runMemoryGovernance: runMemoryGovernance2 } = await import("./memory-governance-DWGFV4FX.js");
+    const { runMemoryGovernance: runMemoryGovernance2 } = await import("./memory-governance-SJ5DGRB3.js");
     const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-3I52ISYR.js");
     const govResult = await runMemoryGovernance2({
       memoryDir: targetStorage.dir,
@@ -45905,8 +45911,8 @@ Returns: Performance trace data with timing breakdown`,
 
 // ../remnic-core/src/cli.ts
 import path74 from "path";
-import { access as access6, readFile as readFile46, readdir as readdir27, unlink as unlink12 } from "fs/promises";
-import { createHash as createHash13 } from "crypto";
+import { access as access7, readFile as readFile47, readdir as readdir28, unlink as unlink12 } from "fs/promises";
+import { createHash as createHash14 } from "crypto";
 
 // ../remnic-core/src/transfer/export-json.ts
 import path45 from "path";
@@ -46020,7 +46026,7 @@ async function backupMemoryDir(opts) {
   const ts = timestampDirName(/* @__PURE__ */ new Date());
   if (opts.encrypt === true) {
     const { listFilesRecursive: listFilesRecursive3, toPosixRelPath: toPosixRelPath2 } = await import("./fs-utils-PZRI2HDZ.js");
-    const { readFile: readFile53 } = await import("fs/promises");
+    const { readFile: readFile54 } = await import("fs/promises");
     const memoryDirAbs = path47.resolve(opts.memoryDir);
     const filesAbs = await listFilesRecursive3(memoryDirAbs);
     const includeTranscripts = opts.includeTranscripts === true;
@@ -46030,7 +46036,7 @@ async function backupMemoryDir(opts) {
       const parts = relPosix.split("/");
       if (parts.some((p) => p === "node_modules" || p === ".git" || p === ".secure-store" || p === ".capsules")) continue;
       if (!includeTranscripts && parts[0] === "transcripts") continue;
-      const content = await readFile53(abs, "utf-8");
+      const content = await readFile54(abs, "utf-8");
       records.push({ path: relPosix, content });
     }
     records.sort((a, b) => a.path.localeCompare(b.path));
@@ -49052,7 +49058,7 @@ function removeManagedCaptureInstructions(existing) {
 async function runOperatorSetup(options) {
   const now = options.now ?? /* @__PURE__ */ new Date();
   const configStatus = await loadCliPluginConfig(options.configPath);
-  const storage = new StorageManager(options.orchestrator.config.memoryDir);
+  const storage = options.orchestrator.storage;
   await storage.ensureDirectories();
   await mkdir42(options.orchestrator.config.workspaceDir, { recursive: true });
   const qmdAvailable = await options.orchestrator.qmd.probe();
@@ -49329,6 +49335,7 @@ async function runOperatorDoctor(options) {
   const configStatus = await loadCliPluginConfig(options.configPath);
   const checks = [];
   const config = options.orchestrator.config;
+  const storage = options.orchestrator.storage;
   const configReview = await buildOperatorConfigReviewReport({
     now,
     configStatus,
@@ -49379,7 +49386,7 @@ async function runOperatorDoctor(options) {
     remediation: conversationIndex.enabled && conversationIndex.status !== "ok" ? "Run `openclaw engram rebuild-index` to refresh the conversation index artifacts." : void 0,
     details: conversationIndex
   });
-  const meta = await new StorageManager(config.memoryDir).loadMeta();
+  const meta = await storage.loadMeta();
   checks.push({
     key: "maintenance",
     status: meta.lastExtractionAt || meta.lastConsolidationAt ? "ok" : "warn",
@@ -49412,14 +49419,14 @@ async function runOperatorDoctor(options) {
     warnRatio: config.fileHygiene.lintWarnRatio
   }) : [];
   checks.push(summarizeHygieneWarnings(warnings, config.fileHygiene));
-  checks.push(await summarizeMemoryWorthLegacyCounters(new StorageManager(config.memoryDir)));
+  checks.push(await summarizeMemoryWorthLegacyCounters(storage));
   checks.push(
-    await summarizeBufferSurpriseDistribution(new StorageManager(config.memoryDir), config)
+    await summarizeBufferSurpriseDistribution(storage, config)
   );
-  checks.push(await summarizeConsolidationProvenance(new StorageManager(config.memoryDir), config));
+  checks.push(await summarizeConsolidationProvenance(storage, config));
   checks.push(await summarizeGraphEdgeDecayStatus(config));
   checks.push(await summarizeTierDistribution(options.orchestrator.storage));
-  checks.push(await summarizeDreamsPhases(config));
+  checks.push(await summarizeDreamsPhases(config, storage));
   checks.push(summarizeSecurityMitigations(config));
   checks.push(await summarizeObservationThroughput(config.memoryDir));
   const summary = checks.reduce(
@@ -49569,8 +49576,8 @@ async function summarizeTierDistribution(storage) {
     const sevenDaysAgoMs = Date.now() - 7 * 864e5;
     if (journalPath) {
       try {
-        const { readFile: readFile53 } = await import("fs/promises");
-        const raw = await readFile53(journalPath, "utf-8");
+        const { readFile: readFile54 } = await import("fs/promises");
+        const raw = await readFile54(journalPath, "utf-8");
         for (const line of raw.split("\n")) {
           const trimmed = line.trim();
           if (trimmed.length === 0) continue;
@@ -49615,9 +49622,8 @@ async function summarizeTierDistribution(storage) {
     };
   }
 }
-async function summarizeDreamsPhases(config) {
+async function summarizeDreamsPhases(config, storage = new StorageManager(config.memoryDir)) {
   const phases = config.dreamsPhases;
-  const storage = new StorageManager(config.memoryDir);
   const meta = await storage.loadMeta();
   let deepSleepLastRun = null;
   let deepSleepLastRunWarning = null;
@@ -50868,6 +50874,8 @@ var GraphDashboardServer = class {
 // ../remnic-core/src/access-service.ts
 import { stat as stat19 } from "fs/promises";
 import * as nodeFs from "fs/promises";
+import { constants as fsConstants2 } from "fs";
+import { createHash as createHash13 } from "crypto";
 
 // ../remnic-core/src/access-idempotency.ts
 import { mkdir as mkdir44, open as open4, readFile as readFile40, rename as rename7, stat as stat18, unlink as unlink11, utimes as utimes2, writeFile as writeFile39 } from "fs/promises";
@@ -53338,6 +53346,18 @@ async function recordMemoryOutcome(storage, input) {
 // ../remnic-core/src/access-service.ts
 var EngramAccessInputError = class extends Error {
 };
+var cachedPackageVersion = null;
+async function getPackageVersion() {
+  if (cachedPackageVersion !== null) return cachedPackageVersion;
+  try {
+    const raw = await nodeFs.readFile(new URL("../package.json", import.meta.url), "utf-8");
+    const parsed = JSON.parse(raw);
+    cachedPackageVersion = typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown";
+  } catch {
+    cachedPackageVersion = "unknown";
+  }
+  return cachedPackageVersion;
+}
 function normalizeTrustZoneInputError(error) {
   const message = error instanceof Error ? error.message : null;
   if (!message) {
@@ -54942,6 +54962,147 @@ var EngramAccessService = class {
     });
     return { namespace: resolvedNamespace, ...report };
   }
+  async memorySummarizeHourly() {
+    await this.orchestrator.summarizer.runHourly();
+    return {
+      ok: true,
+      message: "Hourly summarization completed. Check the summaries directory for results."
+    };
+  }
+  async conversationIndexUpdate(request = {}) {
+    if (!this.orchestrator.config.conversationIndexEnabled) {
+      return {
+        enabled: false,
+        sessions: 0,
+        chunks: 0,
+        skipped: 0,
+        skippedSessionKeys: [],
+        embeddedRuns: 0,
+        reason: "disabled"
+      };
+    }
+    const hours = typeof request.hours === "number" && Number.isFinite(request.hours) ? Math.max(1, Math.floor(request.hours)) : 24;
+    let sessionKey;
+    if (request.sessionKey !== void 0) {
+      if (typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+        throw new EngramAccessInputError("sessionKey must be a non-empty string when provided");
+      }
+      sessionKey = request.sessionKey.trim();
+    }
+    if (sessionKey) {
+      const result = await this.orchestrator.updateConversationIndex(
+        sessionKey,
+        hours,
+        { embed: request.embed }
+      );
+      return {
+        enabled: true,
+        sessionKey,
+        sessions: 1,
+        chunks: result.chunks,
+        skipped: result.skipped ? 1 : 0,
+        skippedSessionKeys: result.skipped ? [sessionKey] : [],
+        embeddedRuns: result.embedded ? 1 : 0,
+        reason: result.reason,
+        retryAfterMs: result.retryAfterMs
+      };
+    }
+    const sessionKeys = await this.orchestrator.transcript.listSessionKeys();
+    let chunks = 0;
+    let skipped = 0;
+    const skippedSessionKeys = [];
+    let embeddedRuns = 0;
+    for (const sessionKey2 of sessionKeys) {
+      const result = await this.orchestrator.updateConversationIndex(
+        sessionKey2,
+        hours,
+        { embed: request.embed }
+      );
+      chunks += result.chunks;
+      if (result.skipped) {
+        skipped += 1;
+        skippedSessionKeys.push(sessionKey2);
+      }
+      if (result.embedded) {
+        embeddedRuns += 1;
+      }
+    }
+    return {
+      enabled: true,
+      sessions: sessionKeys.length,
+      chunks,
+      skipped,
+      skippedSessionKeys,
+      embeddedRuns
+    };
+  }
+  async profilingReport(request = {}) {
+    const profiler = this.orchestrator.profiler;
+    if (!profiler.isEnabled) {
+      return {
+        enabled: false,
+        reason: "disabled",
+        message: "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
+      };
+    }
+    const format = request.format ?? "ascii";
+    if (format !== "ascii" && format !== "json") {
+      throw new EngramAccessInputError("format must be one of: ascii, json");
+    }
+    const limit = request.limit ?? 5;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 20) {
+      throw new EngramAccessInputError("limit must be an integer between 1 and 20");
+    }
+    const traces = profiler.getRecentTraces(limit);
+    const stats = profiler.getStats();
+    const bottleneck = profiler.identifyBottleneck();
+    if (format === "json") {
+      return {
+        enabled: true,
+        format,
+        traces,
+        stats,
+        bottleneck
+      };
+    }
+    const lines = [];
+    lines.push("Engram Profiling Report");
+    lines.push("=".repeat(60));
+    lines.push("");
+    const allBuckets = [
+      ["byKind", stats.byKind],
+      ["bySpan", stats.bySpan]
+    ];
+    const hasStats = allBuckets.some(([, entries]) => Object.keys(entries).length > 0);
+    if (hasStats) {
+      lines.push("Aggregate Stats (all retained traces):");
+      for (const [bucket, entries] of allBuckets) {
+        for (const [key, summary] of Object.entries(entries)) {
+          lines.push(
+            `  ${bucket}/${key}: avg=${summary.avgMs}ms p50=${summary.p50Ms}ms p95=${summary.p95Ms}ms max=${summary.maxMs}ms (n=${summary.count})`
+          );
+        }
+      }
+      lines.push("");
+    }
+    if (bottleneck) {
+      lines.push(`Bottleneck: ${bottleneck}`);
+      lines.push("");
+    }
+    if (traces.length === 0) {
+      lines.push("No traces recorded yet. Trigger a recall or extraction to see timing data.");
+    } else {
+      for (const trace of traces) {
+        lines.push(formatProfileTraceAscii(trace));
+        lines.push("");
+      }
+    }
+    return {
+      enabled: true,
+      format,
+      report: lines.join("\n")
+    };
+  }
   async trustZoneStatus(namespace, principal) {
     const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
@@ -55861,22 +56022,82 @@ ${next}`);
     });
     return { promoted: true, memoryId: request.memoryId };
   }
+  async memoryActionApply(request) {
+    const actionTypes = /* @__PURE__ */ new Set([
+      "store_episode",
+      "store_note",
+      "update_note",
+      "create_artifact",
+      "summarize_node",
+      "discard",
+      "link_graph"
+    ]);
+    if (!actionTypes.has(request.action)) {
+      throw new EngramAccessInputError(
+        `memory_action_apply: invalid action ${JSON.stringify(request.action)}`
+      );
+    }
+    if (this.orchestrator.config.contextCompressionActionsEnabled !== true) {
+      throw new EngramAccessInputError(
+        "memory_action_apply is disabled; enable contextCompressionActionsEnabled to use this tool"
+      );
+    }
+    const outcome = request.outcome ?? "skipped";
+    if (outcome !== "applied" && outcome !== "skipped" && outcome !== "failed") {
+      throw new EngramAccessInputError(
+        `memory_action_apply: outcome must be "applied", "skipped", or "failed"; got ${JSON.stringify(outcome)}`
+      );
+    }
+    const resolvedNs = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.principal
+    );
+    const inputSummaryParts = [
+      request.content,
+      request.category ? `category=${request.category}` : void 0,
+      request.linkTargetId ? `linkTargetId=${request.linkTargetId}` : void 0,
+      request.linkType ? `linkType=${request.linkType}` : void 0,
+      typeof request.linkStrength === "number" ? `linkStrength=${request.linkStrength}` : void 0,
+      request.artifactType ? `artifactType=${request.artifactType}` : void 0,
+      typeof request.execute === "boolean" ? `execute=${request.execute}` : void 0
+    ].filter((part) => typeof part === "string" && part.length > 0);
+    const event = {
+      action: request.action,
+      outcome,
+      namespace: resolvedNs,
+      actor: "access.memory_action_apply",
+      subsystem: "access.memory_action_apply",
+      reason: request.reason,
+      memoryId: request.memoryId,
+      sourceSessionKey: request.sessionKey,
+      inputSummary: inputSummaryParts.length > 0 ? inputSummaryParts.join(" | ").slice(0, 500) : void 0,
+      dryRun: request.dryRun === true,
+      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash13("sha256").update(request.sourcePrompt).digest("hex") : void 0
+    };
+    const preview = this.orchestrator.previewMemoryActionEvent(event);
+    if (request.dryRun === true) {
+      return { recorded: false, dryRun: true, event: preview };
+    }
+    const recorded = await this.orchestrator.appendMemoryActionEvent(event);
+    return { recorded, event: preview };
+  }
   async contextCheckpoint(request) {
     const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
     const { writeFile: writeFile45, mkdir: mkdir52 } = await import("fs/promises");
-    const { join: join5, resolve: resolve2 } = await import("path");
+    const { join: join6, resolve: resolve2 } = await import("path");
     const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
     if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
-    const checkpointDir = join5(storageDir, "checkpoints", safeKey);
+    const checkpointDir = join6(storageDir, "checkpoints", safeKey);
     const resolved = resolve2(checkpointDir);
     if (!resolved.startsWith(resolve2(storageDir))) {
       throw new EngramAccessInputError("Invalid sessionKey");
     }
     await mkdir52(checkpointDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = join5(checkpointDir, `checkpoint-${ts}.md`);
+    const filePath = join6(checkpointDir, `checkpoint-${ts}.md`);
     await writeFile45(filePath, request.context, "utf-8");
     return { saved: true };
   }
@@ -56157,13 +56378,158 @@ ${next}`);
    * caller having to construct the config object.
    */
   async capsuleImport(opts) {
-    const root = opts.root ?? this.orchestrator.config.memoryDir;
-    const versioning = opts.versioning ?? {
+    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
+    const resolvedNamespace = this.resolveWritableNamespace(namespace, void 0, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const root = explicitRoot ?? storage.dir;
+    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
+    const versioning = importOptions.versioning ?? {
       enabled: this.orchestrator.config.versioningEnabled,
       maxVersionsPerPage: this.orchestrator.config.versioningMaxPerPage,
       sidecarDir: this.orchestrator.config.versioningSidecarDir
     };
-    return importCapsule({ ...opts, root, versioning });
+    await this.validateCapsuleImportArchivePath(importOptions.archivePath);
+    try {
+      return await importCapsule({ ...importOptions, root, memoryDir, versioning });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (this.isCapsuleImportArchiveInputError(err, message)) {
+        throw new EngramAccessInputError(`capsule import failed: ${message}`);
+      }
+      throw err;
+    }
+  }
+  async validateCapsuleImportArchivePath(archivePath) {
+    let archiveStat;
+    try {
+      archiveStat = await stat19(archivePath);
+    } catch (err) {
+      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    }
+    if (!archiveStat.isFile()) {
+      throw new EngramAccessInputError("capsule import failed: archivePath must point to a file");
+    }
+    try {
+      await nodeFs.access(archivePath, fsConstants2.R_OK);
+    } catch (err) {
+      if (!this.isCapsuleImportPathInputFsError(err)) throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      throw new EngramAccessInputError(`capsule import failed: archive is not readable: ${message}`);
+    }
+  }
+  isCapsuleImportPathInputFsError(err) {
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+    return code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "ELOOP";
+  }
+  isCapsuleImportArchiveInputError(err, message) {
+    if (err instanceof ZodError) return true;
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+    if (typeof code === "string" && code.startsWith("Z_")) return true;
+    return message.startsWith("importCapsule: archive") || message.startsWith("importCapsule: bundle") || message.startsWith("importCapsule: manifest") || message.startsWith("importCapsule: record") || /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message);
+  }
+  /**
+   * Export a capsule archive from the orchestrator's memory directory.
+   *
+   * HTTP and future MCP surfaces use this rather than calling the transfer
+   * helper directly so namespace ACL checks stay consistent with the archive
+   * write side effect. The exporter still owns archive construction and
+   * validation.
+   */
+  async capsuleExport(opts) {
+    const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...exportOptions } = opts;
+    const resolvedNamespace = this.resolveWritableNamespace(namespace, void 0, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const root = explicitRoot ?? storage.dir;
+    const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
+    const pluginVersion = exportOptions.pluginVersion ?? await getPackageVersion();
+    return exportCapsule({
+      ...exportOptions,
+      pluginVersion,
+      root,
+      memoryDir: exportOptions.encrypt === true ? memoryDir : void 0
+    });
+  }
+  /**
+   * List capsule archives in the namespace-scoped capsule store.
+   *
+   * MCP uses this access-layer method instead of reading arbitrary paths so
+   * capsule discovery remains bound to the same namespace ACLs as export and
+   * import.
+   */
+  async capsuleList(options) {
+    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const capsulesDir = defaultCapsulesDir(storage.dir);
+    let dirEntries;
+    try {
+      const capsulesDirStat = await nodeFs.lstat(capsulesDir);
+      if (capsulesDirStat.isSymbolicLink()) {
+        throw new EngramAccessInputError("capsule list failed: capsule store directory must not be a symlink");
+      }
+      if (!capsulesDirStat.isDirectory()) {
+        throw new EngramAccessInputError("capsule list failed: capsule store path must be a directory");
+      }
+      dirEntries = await nodeFs.readdir(capsulesDir, { withFileTypes: true });
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+      if (code === "ENOENT") {
+        return { namespace: resolvedNamespace, capsulesDir, capsules: [] };
+      }
+      throw err;
+    }
+    const archiveNames = dirEntries.filter(
+      (entry) => entry.isFile() && (entry.name.endsWith(".capsule.json.gz") || entry.name.endsWith(".capsule.json.gz.enc"))
+    ).map((entry) => entry.name).sort();
+    const capsules = [];
+    for (const archiveName of archiveNames) {
+      const archivePath = nodePath.join(capsulesDir, archiveName);
+      const id = archiveName.replace(/\.capsule\.json\.gz\.enc$/, "").replace(/\.capsule\.json\.gz$/, "");
+      const manifestPath2 = nodePath.join(capsulesDir, `${id}.manifest.json`);
+      let createdAt = null;
+      let pluginVersion = null;
+      let fileCount = null;
+      let description = null;
+      let manifestPathOrNull = manifestPath2;
+      try {
+        const manifestStat = await nodeFs.lstat(manifestPath2);
+        if (manifestStat.isSymbolicLink() || !manifestStat.isFile()) {
+          capsules.push({
+            id,
+            archivePath,
+            manifestPath: manifestPathOrNull,
+            createdAt,
+            pluginVersion,
+            fileCount,
+            description
+          });
+          continue;
+        }
+        const raw = await nodeFs.readFile(manifestPath2, "utf-8");
+        const sidecar = JSON.parse(raw);
+        createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
+        pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
+        fileCount = Array.isArray(sidecar.files) ? sidecar.files.length : null;
+        const capsule = sidecar.capsule;
+        description = capsule && typeof capsule.description === "string" ? capsule.description : null;
+      } catch (err) {
+        const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+        if (code === "ENOENT") {
+          manifestPathOrNull = null;
+        }
+      }
+      capsules.push({
+        id,
+        archivePath,
+        manifestPath: manifestPathOrNull,
+        createdAt,
+        pluginVersion,
+        fileCount,
+        description
+      });
+    }
+    return { namespace: resolvedNamespace, capsulesDir, capsules };
   }
   // ── Dreams pipeline telemetry surfaces (issue #678 PR 3+4) ──────────────
   /**
@@ -56257,14 +56623,247 @@ import { createServer as createServer3 } from "http";
 import { randomUUID as randomUUID6, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { AsyncLocalStorage } from "async_hooks";
 import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile43 } from "fs/promises";
+import { readFile as readFile44 } from "fs/promises";
 import path70 from "path";
 import { fileURLToPath as fileURLToPath3, URL as URL3 } from "url";
 
 // ../remnic-core/src/access-mcp.ts
-import { readFile as readFile42 } from "fs/promises";
+import { readFile as readFile43 } from "fs/promises";
 import { randomUUID as randomUUID5 } from "crypto";
 
+// ../remnic-core/src/access-schema.ts
+function formatZodError(error) {
+  return {
+    error: "request validation failed",
+    code: "validation_error",
+    details: error.issues.map((issue) => ({
+      field: issue.path.join(".") || "(root)",
+      message: issue.message
+    }))
+  };
+}
+var namespaceSchema = external_exports.string().trim().max(256).optional();
+var sessionKeySchema = external_exports.string().trim().min(1).max(512).optional();
+var idempotencyKeySchema = external_exports.string().trim().min(1).max(256).optional();
+var dryRunSchema = external_exports.boolean().optional();
+var schemaVersionSchema = external_exports.number().int().optional();
+var codingContextSchema = external_exports.object({
+  projectId: external_exports.string().trim().min(1, "codingContext.projectId is required").max(128),
+  branch: external_exports.string().trim().max(256).nullable(),
+  rootPath: external_exports.string().trim().min(1, "codingContext.rootPath is required").max(1024),
+  defaultBranch: external_exports.string().trim().max(256).nullable()
+}).nullable();
+var recallDisclosureSchema = external_exports.enum(["chunk", "section", "raw"]);
+var tagMatchSchema = external_exports.enum(["any", "all"]);
+var recallRequestSchema = external_exports.object({
+  query: external_exports.string().min(1, "query is required"),
+  sessionKey: sessionKeySchema,
+  namespace: namespaceSchema,
+  topK: external_exports.number().int().min(0).max(200).optional(),
+  mode: external_exports.enum(["auto", "no_recall", "minimal", "full", "graph_mode"]).optional(),
+  includeDebug: external_exports.boolean().optional(),
+  disclosure: recallDisclosureSchema.optional(),
+  codingContext: codingContextSchema.optional(),
+  /** Working directory for auto git-context resolution (issue #569). */
+  cwd: external_exports.string().trim().min(1, "cwd must be non-empty when provided").max(2048).optional(),
+  /**
+   * Arbitrary project tag for non-git-based project scoping (issue #569).
+   * Creates a coding context with `projectId: "tag:<projectTag>"`.
+   */
+  projectTag: external_exports.string().trim().min(1, "projectTag must be non-empty when provided").max(256).optional(),
+  /**
+   * Historical recall pin (issue #680).  ISO 8601 timestamp.  The
+   * schema only enforces the basic shape; the access service runs
+   * `Date.parse` and emits a structured 400 on malformed input
+   * (CLAUDE.md rule 51).
+   */
+  asOf: external_exports.string().trim().min(1, "asOf must be a non-empty ISO 8601 timestamp").max(64).optional(),
+  /**
+   * Free-form recall tag filter (issue #689). When provided, recall results
+   * whose frontmatter `tags` do not match the filter are removed before the
+   * response is returned. Comparison is case-sensitive exact match.
+   */
+  tags: external_exports.array(external_exports.string().trim().min(1).max(256)).max(50).optional(),
+  /**
+   * Match mode for `tags` (issue #689). Defaults to `"any"` when `tags` is
+   * provided and `tagMatch` is omitted. Ignored when `tags` is absent.
+   */
+  tagMatch: tagMatchSchema.optional(),
+  /**
+   * Include graph edges below `graphTraversalConfidenceFloor` for diagnostic
+   * recall traversal (issue #681). Defaults to false.
+   */
+  includeLowConfidence: external_exports.boolean().optional()
+});
+var recallExplainRequestSchema = external_exports.object({
+  sessionKey: sessionKeySchema,
+  namespace: namespaceSchema
+});
+var setCodingContextRequestSchema = external_exports.object({
+  sessionKey: external_exports.string().trim().min(1, "sessionKey is required").max(512),
+  codingContext: codingContextSchema
+});
+var messageSchema = external_exports.object({
+  role: external_exports.enum(["user", "assistant"]),
+  content: external_exports.string().min(1, "message content must be non-empty")
+});
+var observeRequestSchema = external_exports.object({
+  sessionKey: external_exports.string().trim().min(1, "sessionKey is required").max(512),
+  messages: external_exports.array(messageSchema).min(1, "messages must be a non-empty array"),
+  namespace: namespaceSchema,
+  skipExtraction: external_exports.boolean().optional(),
+  /** Working directory for auto git-context resolution (issue #569). */
+  cwd: external_exports.string().trim().min(1, "cwd must be non-empty when provided").max(2048).optional(),
+  /**
+   * Arbitrary project tag for non-git-based project scoping (issue #569).
+   * Creates a coding context with `projectId: "tag:<projectTag>"`.
+   */
+  projectTag: external_exports.string().trim().min(1, "projectTag must be non-empty when provided").max(256).optional()
+});
+var writeContentSchema = external_exports.string().min(1, "content is required").max(5e4);
+var categorySchema = external_exports.enum([
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace"
+]).optional();
+var confidenceSchema = external_exports.number().min(0).max(1).optional();
+var tagsSchema = external_exports.array(external_exports.string().max(256)).max(50).optional();
+var entityRefSchema = external_exports.string().trim().max(512).optional();
+var ttlSchema = external_exports.string().trim().max(128).optional();
+var sourceReasonSchema = external_exports.string().trim().max(2e3).optional();
+var memoryStoreRequestSchema = external_exports.object({
+  schemaVersion: schemaVersionSchema,
+  idempotencyKey: idempotencyKeySchema,
+  dryRun: dryRunSchema,
+  sessionKey: sessionKeySchema,
+  content: writeContentSchema,
+  category: categorySchema,
+  confidence: confidenceSchema,
+  namespace: namespaceSchema,
+  tags: tagsSchema,
+  entityRef: entityRefSchema,
+  ttl: ttlSchema,
+  sourceReason: sourceReasonSchema
+});
+var suggestionSubmitRequestSchema = memoryStoreRequestSchema;
+var reviewDispositionRequestSchema = external_exports.object({
+  memoryId: external_exports.string().trim().min(1, "memoryId is required"),
+  status: external_exports.enum([
+    "active",
+    "pending_review",
+    "quarantined",
+    "rejected",
+    "superseded",
+    "archived"
+  ]),
+  reasonCode: external_exports.string().trim().min(1, "reasonCode is required"),
+  namespace: namespaceSchema
+});
+var trustZonePromoteRequestSchema = external_exports.object({
+  recordId: external_exports.string().trim().min(1, "recordId is required"),
+  targetZone: external_exports.enum(["working", "trusted"], {
+    errorMap: () => ({ message: "targetZone must be 'working' or 'trusted'" })
+  }),
+  promotionReason: external_exports.string().trim().min(1, "promotionReason is required"),
+  recordedAt: external_exports.string().trim().optional(),
+  summary: external_exports.string().trim().max(5e3).optional(),
+  dryRun: dryRunSchema,
+  namespace: namespaceSchema
+});
+var trustZoneDemoSeedRequestSchema = external_exports.object({
+  scenario: external_exports.string().trim().max(256).optional(),
+  recordedAt: external_exports.string().trim().optional(),
+  dryRun: dryRunSchema,
+  namespace: namespaceSchema
+});
+var lcmSearchRequestSchema = external_exports.object({
+  query: external_exports.string().min(1, "query is required"),
+  sessionKey: sessionKeySchema,
+  namespace: namespaceSchema,
+  limit: external_exports.number().int().min(1).max(100).optional()
+});
+var daySummaryRequestSchema = external_exports.object({
+  memories: external_exports.string().max(1e5).optional(),
+  sessionKey: sessionKeySchema,
+  namespace: namespaceSchema
+});
+var capsuleTopLevelSegmentSchema = external_exports.string().trim().min(1).max(128).refine(
+  (value) => !value.includes("/") && !value.includes("\\"),
+  "must be a top-level directory name without path separators"
+);
+var capsulePeerIdSchema = external_exports.string().trim().min(1).max(256).refine(
+  (value) => value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\"),
+  "must be a plain peer id without path separators"
+);
+var capsuleIsoSinceSchema = external_exports.string().trim().min(1, "since must be a non-empty ISO 8601 timestamp").max(128).refine(
+  isValidCapsuleSince,
+  "since must be a valid ISO 8601 timestamp with no calendar overflow"
+);
+var capsuleExportRequestSchema = external_exports.object({
+  name: external_exports.string().trim().min(1, "name is required").max(64, "name must be 64 characters or fewer").regex(
+    CAPSULE_ID_PATTERN,
+    "name must be alphanumeric with single dashes (no spaces, no leading/trailing dashes)"
+  ),
+  namespace: namespaceSchema,
+  since: capsuleIsoSinceSchema.optional(),
+  includeKinds: external_exports.array(capsuleTopLevelSegmentSchema).max(50).optional(),
+  peerIds: external_exports.array(capsulePeerIdSchema).max(100).optional(),
+  includeTranscripts: external_exports.boolean().optional(),
+  encrypt: external_exports.boolean().optional()
+});
+var capsuleImportRequestSchema = external_exports.object({
+  archivePath: external_exports.string().trim().min(1, "archivePath is required").max(4096),
+  namespace: namespaceSchema,
+  mode: external_exports.enum(["skip", "overwrite", "fork"]).optional()
+});
+var capsuleListRequestSchema = external_exports.object({
+  namespace: namespaceSchema
+});
+var schemas = {
+  recall: recallRequestSchema,
+  recallExplain: recallExplainRequestSchema,
+  setCodingContext: setCodingContextRequestSchema,
+  observe: observeRequestSchema,
+  memoryStore: memoryStoreRequestSchema,
+  suggestionSubmit: suggestionSubmitRequestSchema,
+  reviewDisposition: reviewDispositionRequestSchema,
+  trustZonePromote: trustZonePromoteRequestSchema,
+  trustZoneDemoSeed: trustZoneDemoSeedRequestSchema,
+  lcmSearch: lcmSearchRequestSchema,
+  daySummary: daySummaryRequestSchema,
+  capsuleExport: capsuleExportRequestSchema,
+  capsuleImport: capsuleImportRequestSchema,
+  capsuleList: capsuleListRequestSchema
+};
+function validateRequest(schemaName, body) {
+  const schema = schemas[schemaName];
+  if (!schema) {
+    return {
+      success: false,
+      error: {
+        error: `unknown schema: ${schemaName}`,
+        code: "validation_error",
+        details: []
+      }
+    };
+  }
+  const result = schema.safeParse(body);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: formatZodError(result.error) };
+}
+
 // ../remnic-core/src/citations.ts
 var OPEN_TAG = "<oai-mem-citation>";
 var CLOSE_TAG = "</oai-mem-citation>";
@@ -56321,12 +56920,43 @@ function withToolAliases(tool) {
   if (canonicalName === tool.name) return [canonicalTool];
   return [canonicalTool, tool];
 }
+var STRICT_MCP_SCHEMA_KEYS = {
+  capsuleExport: [
+    "name",
+    "namespace",
+    "since",
+    "includeKinds",
+    "peerIds",
+    "includeTranscripts",
+    "encrypt"
+  ],
+  capsuleImport: ["archivePath", "namespace", "mode"],
+  capsuleList: ["namespace"]
+};
+function parseMcpRequest(schemaName, args) {
+  const allowedKeys = STRICT_MCP_SCHEMA_KEYS[schemaName];
+  if (allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    const unexpected = Object.keys(args).filter((key) => !allowed.has(key));
+    if (unexpected.length > 0) {
+      throw new EngramAccessInputError(
+        `request validation failed: (root): Unrecognized key(s) in object: ${unexpected.join(", ")}`
+      );
+    }
+  }
+  const validation = validateRequest(schemaName, args);
+  if (validation.success) return validation.data;
+  const details = validation.error.details.map((detail) => `${detail.field}: ${detail.message}`).join("; ");
+  throw new EngramAccessInputError(
+    details.length > 0 ? `${validation.error.error}: ${details}` : validation.error.error
+  );
+}
 async function getMcpServerVersion() {
   const envVersion = readEnvVar("OPENCLAW_ENGRAM_VERSION")?.trim() || readEnvVar("npm_package_version")?.trim();
   if (envVersion) return envVersion;
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile42(pkgPath, "utf-8");
+    const raw = await readFile43(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version?.trim() || "unknown";
   } catch {
@@ -56494,6 +57124,70 @@ var EngramMcpServer = class {
           additionalProperties: false
         }
       },
+      {
+        name: "engram.capsule_export",
+        description: "Export a portable Remnic capsule archive from the namespace-scoped memory store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Capsule id (alphanumeric with single dashes, max 64 characters)."
+            },
+            namespace: { type: "string" },
+            since: {
+              type: "string",
+              description: "Only include files modified on or after this ISO 8601 timestamp."
+            },
+            includeKinds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional top-level directory allow-list."
+            },
+            peerIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional peer id allow-list for the peers/ subtree."
+            },
+            includeTranscripts: { type: "boolean" },
+            encrypt: { type: "boolean" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.capsule_import",
+        description: "Import a Remnic capsule archive into the namespace-scoped memory store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            archivePath: {
+              type: "string",
+              description: "Path to a .capsule.json.gz or .capsule.json.gz.enc archive."
+            },
+            namespace: { type: "string" },
+            mode: {
+              type: "string",
+              enum: ["skip", "overwrite", "fork"],
+              description: "Conflict handling mode. Defaults to skip."
+            }
+          },
+          required: ["archivePath"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.capsule_list",
+        description: "List capsule archives in the namespace-scoped capsule store.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
       {
         name: "engram.memory_governance_run",
         description: "Run Remnic memory governance in a bounded shadow/apply pass.",
@@ -57149,6 +57843,43 @@ var EngramMcpServer = class {
           additionalProperties: false
         }
       },
+      {
+        name: "engram.memory_action_apply",
+        description: "Record a memory-action application event for policy-learning telemetry.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "store_episode",
+                "store_note",
+                "update_note",
+                "create_artifact",
+                "summarize_node",
+                "discard",
+                "link_graph"
+              ]
+            },
+            category: { type: "string" },
+            content: { type: "string" },
+            outcome: { type: "string", enum: ["applied", "skipped", "failed"] },
+            reason: { type: "string" },
+            memoryId: { type: "string" },
+            sessionKey: { type: "string" },
+            linkTargetId: { type: "string" },
+            linkType: { type: "string" },
+            linkStrength: { type: "number" },
+            artifactType: { type: "string" },
+            execute: { type: "boolean" },
+            sourcePrompt: { type: "string" },
+            namespace: { type: "string" },
+            dryRun: { type: "boolean" }
+          },
+          required: ["action"],
+          additionalProperties: false
+        }
+      },
       {
         name: "engram.context_checkpoint",
         description: "Save a structured context checkpoint for a session (preserves conversation state to disk).",
@@ -57220,6 +57951,49 @@ var EngramMcpServer = class {
           additionalProperties: false
         }
       },
+      {
+        name: "engram.memory_summarize_hourly",
+        description: "Generate hourly summaries for recent conversations.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.conversation_index_update",
+        description: "Chunk transcript history into conversation-index documents.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string" },
+            hours: { type: "number", description: "How many hours of transcript history to include." },
+            embed: { type: "boolean", description: "If true, run QMD embed after update for this invocation." }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.profiling_report",
+        description: "Return timing and performance data for Remnic recall and extraction pipelines. Requires profilingEnabled: true.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            format: {
+              type: "string",
+              enum: ["ascii", "json"],
+              description: "Output format. Defaults to ascii."
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 20,
+              description: "Number of recent traces to include. Defaults to 5."
+            }
+          },
+          additionalProperties: false
+        }
+      },
       {
         name: "engram.graph_edge_decay_run",
         description: "Run the graph-edge-confidence decay maintenance pass (issue #681 PR 2/3). Respects graphEdgeDecayEnabled; writes a structured telemetry record to state/graph-edge-decay-status.json.",
@@ -57472,8 +58246,14 @@ var EngramMcpServer = class {
     if (method === "tools/call") {
       const params = request.params ?? {};
       const name = typeof params.name === "string" ? params.name : "";
-      const argumentsObject = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {};
       try {
+        let argumentsObject = {};
+        if ("arguments" in params && params.arguments !== void 0) {
+          if (params.arguments === null || typeof params.arguments !== "object" || Array.isArray(params.arguments)) {
+            throw new EngramAccessInputError("tools/call arguments must be an object when provided");
+          }
+          argumentsObject = params.arguments;
+        }
         const effectivePrincipal = options?.principalOverride ?? this.authenticatedPrincipal;
         const result = await this.callTool(name, argumentsObject, effectivePrincipal, options?.sessionId);
         return {
@@ -57792,6 +58572,35 @@ ${body}`;
           sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
           namespace: typeof args.namespace === "string" ? args.namespace : void 0
         });
+      case "engram.capsule_export": {
+        const body = parseMcpRequest("capsuleExport", args);
+        return this.service.capsuleExport({
+          name: body.name,
+          namespace: body.namespace,
+          principal: effectivePrincipal,
+          since: body.since,
+          includeKinds: body.includeKinds,
+          peerIds: body.peerIds,
+          includeTranscripts: body.includeTranscripts,
+          encrypt: body.encrypt
+        });
+      }
+      case "engram.capsule_import": {
+        const body = parseMcpRequest("capsuleImport", args);
+        return this.service.capsuleImport({
+          archivePath: expandTildePath(body.archivePath),
+          namespace: body.namespace,
+          principal: effectivePrincipal,
+          mode: body.mode
+        });
+      }
+      case "engram.capsule_list": {
+        const body = parseMcpRequest("capsuleList", args);
+        return this.service.capsuleList({
+          namespace: body.namespace,
+          principal: effectivePrincipal
+        });
+      }
       case "engram.memory_governance_run":
         return this.service.governanceRun({
           namespace: typeof args.namespace === "string" ? args.namespace : void 0,
@@ -58176,6 +58985,25 @@ ${body}`;
           timestamp: typeof args.timestamp === "string" ? args.timestamp : void 0
         });
       }
+      case "engram.memory_action_apply":
+        return this.service.memoryActionApply({
+          action: typeof args.action === "string" ? args.action : "",
+          outcome: typeof args.outcome === "string" ? args.outcome : void 0,
+          reason: typeof args.reason === "string" ? args.reason : void 0,
+          memoryId: typeof args.memoryId === "string" ? args.memoryId : void 0,
+          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          principal: effectivePrincipal,
+          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : void 0,
+          content: typeof args.content === "string" ? args.content : void 0,
+          category: typeof args.category === "string" ? args.category : void 0,
+          linkTargetId: typeof args.linkTargetId === "string" ? args.linkTargetId : void 0,
+          linkType: typeof args.linkType === "string" ? args.linkType : void 0,
+          linkStrength: typeof args.linkStrength === "number" ? args.linkStrength : void 0,
+          artifactType: typeof args.artifactType === "string" ? args.artifactType : void 0,
+          execute: typeof args.execute === "boolean" ? args.execute : void 0,
+          sourcePrompt: typeof args.sourcePrompt === "string" ? args.sourcePrompt : void 0,
+          dryRun: args.dryRun === true
+        });
       case "engram.context_checkpoint":
         return this.service.contextCheckpoint({
           sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : "",
@@ -58235,6 +59063,34 @@ ${body}`;
           namespace: typeof args.namespace === "string" ? args.namespace : void 0
         });
       }
+      case "engram.memory_summarize_hourly":
+      case "remnic.memory_summarize_hourly":
+        return this.service.memorySummarizeHourly();
+      case "engram.conversation_index_update":
+      case "remnic.conversation_index_update": {
+        if ("sessionKey" in args && args.sessionKey !== void 0 && typeof args.sessionKey !== "string") {
+          throw new Error("sessionKey must be a string when provided");
+        }
+        const sessionKey = typeof args.sessionKey === "string" ? args.sessionKey : void 0;
+        return this.service.conversationIndexUpdate({
+          sessionKey,
+          hours: typeof args.hours === "number" && Number.isFinite(args.hours) ? args.hours : void 0,
+          embed: typeof args.embed === "boolean" ? args.embed : void 0
+        });
+      }
+      case "engram.profiling_report":
+      case "remnic.profiling_report": {
+        if ("format" in args && args.format !== void 0 && typeof args.format !== "string") {
+          throw new EngramAccessInputError("format must be a string when provided");
+        }
+        if ("limit" in args && args.limit !== void 0 && typeof args.limit !== "number") {
+          throw new EngramAccessInputError("limit must be a number when provided");
+        }
+        return this.service.profilingReport({
+          format: typeof args.format === "string" ? args.format : void 0,
+          limit: typeof args.limit === "number" ? args.limit : void 0
+        });
+      }
       case "engram.graph_edge_decay_run":
       case "remnic.graph_edge_decay_run": {
         const cfg = this.service.configRef;
@@ -58383,204 +59239,6 @@ ${body}`;
   }
 };
 
-// ../remnic-core/src/access-schema.ts
-function formatZodError(error) {
-  return {
-    error: "request validation failed",
-    code: "validation_error",
-    details: error.issues.map((issue) => ({
-      field: issue.path.join(".") || "(root)",
-      message: issue.message
-    }))
-  };
-}
-var namespaceSchema = external_exports.string().trim().max(256).optional();
-var sessionKeySchema = external_exports.string().trim().min(1).max(512).optional();
-var idempotencyKeySchema = external_exports.string().trim().min(1).max(256).optional();
-var dryRunSchema = external_exports.boolean().optional();
-var schemaVersionSchema = external_exports.number().int().optional();
-var codingContextSchema = external_exports.object({
-  projectId: external_exports.string().trim().min(1, "codingContext.projectId is required").max(128),
-  branch: external_exports.string().trim().max(256).nullable(),
-  rootPath: external_exports.string().trim().min(1, "codingContext.rootPath is required").max(1024),
-  defaultBranch: external_exports.string().trim().max(256).nullable()
-}).nullable();
-var recallDisclosureSchema = external_exports.enum(["chunk", "section", "raw"]);
-var tagMatchSchema = external_exports.enum(["any", "all"]);
-var recallRequestSchema = external_exports.object({
-  query: external_exports.string().min(1, "query is required"),
-  sessionKey: sessionKeySchema,
-  namespace: namespaceSchema,
-  topK: external_exports.number().int().min(0).max(200).optional(),
-  mode: external_exports.enum(["auto", "no_recall", "minimal", "full", "graph_mode"]).optional(),
-  includeDebug: external_exports.boolean().optional(),
-  disclosure: recallDisclosureSchema.optional(),
-  codingContext: codingContextSchema.optional(),
-  /** Working directory for auto git-context resolution (issue #569). */
-  cwd: external_exports.string().trim().min(1, "cwd must be non-empty when provided").max(2048).optional(),
-  /**
-   * Arbitrary project tag for non-git-based project scoping (issue #569).
-   * Creates a coding context with `projectId: "tag:<projectTag>"`.
-   */
-  projectTag: external_exports.string().trim().min(1, "projectTag must be non-empty when provided").max(256).optional(),
-  /**
-   * Historical recall pin (issue #680).  ISO 8601 timestamp.  The
-   * schema only enforces the basic shape; the access service runs
-   * `Date.parse` and emits a structured 400 on malformed input
-   * (CLAUDE.md rule 51).
-   */
-  asOf: external_exports.string().trim().min(1, "asOf must be a non-empty ISO 8601 timestamp").max(64).optional(),
-  /**
-   * Free-form recall tag filter (issue #689). When provided, recall results
-   * whose frontmatter `tags` do not match the filter are removed before the
-   * response is returned. Comparison is case-sensitive exact match.
-   */
-  tags: external_exports.array(external_exports.string().trim().min(1).max(256)).max(50).optional(),
-  /**
-   * Match mode for `tags` (issue #689). Defaults to `"any"` when `tags` is
-   * provided and `tagMatch` is omitted. Ignored when `tags` is absent.
-   */
-  tagMatch: tagMatchSchema.optional(),
-  /**
-   * Include graph edges below `graphTraversalConfidenceFloor` for diagnostic
-   * recall traversal (issue #681). Defaults to false.
-   */
-  includeLowConfidence: external_exports.boolean().optional()
-});
-var recallExplainRequestSchema = external_exports.object({
-  sessionKey: sessionKeySchema,
-  namespace: namespaceSchema
-});
-var setCodingContextRequestSchema = external_exports.object({
-  sessionKey: external_exports.string().trim().min(1, "sessionKey is required").max(512),
-  codingContext: codingContextSchema
-});
-var messageSchema = external_exports.object({
-  role: external_exports.enum(["user", "assistant"]),
-  content: external_exports.string().min(1, "message content must be non-empty")
-});
-var observeRequestSchema = external_exports.object({
-  sessionKey: external_exports.string().trim().min(1, "sessionKey is required").max(512),
-  messages: external_exports.array(messageSchema).min(1, "messages must be a non-empty array"),
-  namespace: namespaceSchema,
-  skipExtraction: external_exports.boolean().optional(),
-  /** Working directory for auto git-context resolution (issue #569). */
-  cwd: external_exports.string().trim().min(1, "cwd must be non-empty when provided").max(2048).optional(),
-  /**
-   * Arbitrary project tag for non-git-based project scoping (issue #569).
-   * Creates a coding context with `projectId: "tag:<projectTag>"`.
-   */
-  projectTag: external_exports.string().trim().min(1, "projectTag must be non-empty when provided").max(256).optional()
-});
-var writeContentSchema = external_exports.string().min(1, "content is required").max(5e4);
-var categorySchema = external_exports.enum([
-  "fact",
-  "preference",
-  "correction",
-  "entity",
-  "decision",
-  "relationship",
-  "principle",
-  "commitment",
-  "moment",
-  "skill",
-  "rule",
-  "procedure",
-  "reasoning_trace"
-]).optional();
-var confidenceSchema = external_exports.number().min(0).max(1).optional();
-var tagsSchema = external_exports.array(external_exports.string().max(256)).max(50).optional();
-var entityRefSchema = external_exports.string().trim().max(512).optional();
-var ttlSchema = external_exports.string().trim().max(128).optional();
-var sourceReasonSchema = external_exports.string().trim().max(2e3).optional();
-var memoryStoreRequestSchema = external_exports.object({
-  schemaVersion: schemaVersionSchema,
-  idempotencyKey: idempotencyKeySchema,
-  dryRun: dryRunSchema,
-  sessionKey: sessionKeySchema,
-  content: writeContentSchema,
-  category: categorySchema,
-  confidence: confidenceSchema,
-  namespace: namespaceSchema,
-  tags: tagsSchema,
-  entityRef: entityRefSchema,
-  ttl: ttlSchema,
-  sourceReason: sourceReasonSchema
-});
-var suggestionSubmitRequestSchema = memoryStoreRequestSchema;
-var reviewDispositionRequestSchema = external_exports.object({
-  memoryId: external_exports.string().trim().min(1, "memoryId is required"),
-  status: external_exports.enum([
-    "active",
-    "pending_review",
-    "quarantined",
-    "rejected",
-    "superseded",
-    "archived"
-  ]),
-  reasonCode: external_exports.string().trim().min(1, "reasonCode is required"),
-  namespace: namespaceSchema
-});
-var trustZonePromoteRequestSchema = external_exports.object({
-  recordId: external_exports.string().trim().min(1, "recordId is required"),
-  targetZone: external_exports.enum(["working", "trusted"], {
-    errorMap: () => ({ message: "targetZone must be 'working' or 'trusted'" })
-  }),
-  promotionReason: external_exports.string().trim().min(1, "promotionReason is required"),
-  recordedAt: external_exports.string().trim().optional(),
-  summary: external_exports.string().trim().max(5e3).optional(),
-  dryRun: dryRunSchema,
-  namespace: namespaceSchema
-});
-var trustZoneDemoSeedRequestSchema = external_exports.object({
-  scenario: external_exports.string().trim().max(256).optional(),
-  recordedAt: external_exports.string().trim().optional(),
-  dryRun: dryRunSchema,
-  namespace: namespaceSchema
-});
-var lcmSearchRequestSchema = external_exports.object({
-  query: external_exports.string().min(1, "query is required"),
-  sessionKey: sessionKeySchema,
-  namespace: namespaceSchema,
-  limit: external_exports.number().int().min(1).max(100).optional()
-});
-var daySummaryRequestSchema = external_exports.object({
-  memories: external_exports.string().max(1e5).optional(),
-  sessionKey: sessionKeySchema,
-  namespace: namespaceSchema
-});
-var schemas = {
-  recall: recallRequestSchema,
-  recallExplain: recallExplainRequestSchema,
-  setCodingContext: setCodingContextRequestSchema,
-  observe: observeRequestSchema,
-  memoryStore: memoryStoreRequestSchema,
-  suggestionSubmit: suggestionSubmitRequestSchema,
-  reviewDisposition: reviewDispositionRequestSchema,
-  trustZonePromote: trustZonePromoteRequestSchema,
-  trustZoneDemoSeed: trustZoneDemoSeedRequestSchema,
-  lcmSearch: lcmSearchRequestSchema,
-  daySummary: daySummaryRequestSchema
-};
-function validateRequest(schemaName, body) {
-  const schema = schemas[schemaName];
-  if (!schema) {
-    return {
-      success: false,
-      error: {
-        error: `unknown schema: ${schemaName}`,
-        code: "validation_error",
-        details: []
-      }
-    };
-  }
-  const result = schema.safeParse(body);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return { success: false, error: formatZodError(result.error) };
-}
-
 // ../remnic-core/src/adapters/types.ts
 function headerValue(headers, key) {
   const raw = headers[key];
@@ -59099,6 +59757,36 @@ var EngramAccessHttpServer = class {
       this.respondJson(res, 200, { ok: true });
       return;
     }
+    if (req.method === "POST" && (pathname === "/engram/v1/capsules/export" || pathname === "/remnic/v1/capsules/export")) {
+      const body = await this.readValidatedBody(req, "capsuleExport");
+      this.ensureWriteRateLimitAvailable();
+      const result = await this.service.capsuleExport({
+        name: body.name,
+        namespace: this.resolveNamespace(req, body.namespace),
+        principal: this.resolveRequestPrincipal(req),
+        since: body.since,
+        includeKinds: body.includeKinds,
+        peerIds: body.peerIds,
+        includeTranscripts: body.includeTranscripts,
+        encrypt: body.encrypt
+      });
+      this.recordWriteRateLimitHit();
+      this.respondJson(res, 200, result);
+      return;
+    }
+    if (req.method === "POST" && (pathname === "/engram/v1/capsules/import" || pathname === "/remnic/v1/capsules/import")) {
+      const body = await this.readValidatedBody(req, "capsuleImport");
+      this.ensureWriteRateLimitAvailable();
+      const result = await this.service.capsuleImport({
+        archivePath: expandTildePath(body.archivePath),
+        namespace: this.resolveNamespace(req, body.namespace),
+        principal: this.resolveRequestPrincipal(req),
+        mode: body.mode
+      });
+      this.recordWriteRateLimitHit();
+      this.respondJson(res, 200, result);
+      return;
+    }
     if (req.method === "POST" && pathname === "/engram/v1/recall/explain") {
       const body = await this.readValidatedBody(req, "recallExplain");
       const response = await this.service.recallExplain({
@@ -59882,7 +60570,8 @@ var EngramAccessHttpServer = class {
     const toolName = typeof request.params?.name === "string" ? request.params.name : "";
     const toolArgs = request.params?.arguments;
     const dreamsRunDryRun = (toolName === "engram.dreams_run" || toolName === "remnic.dreams_run") && toolArgs !== null && typeof toolArgs === "object" && !Array.isArray(toolArgs) && toolArgs.dryRun === true;
-    const isMcpWrite = request.method === "tools/call" && (toolName === "engram.memory_store" || toolName === "remnic.memory_store" || toolName === "engram.suggestion_submit" || toolName === "remnic.suggestion_submit" || toolName === "engram.observe" || toolName === "remnic.observe" || !dreamsRunDryRun && (toolName === "engram.dreams_run" || toolName === "remnic.dreams_run"));
+    const memoryActionApplyDryRun = (toolName === "engram.memory_action_apply" || toolName === "remnic.memory_action_apply") && toolArgs !== null && typeof toolArgs === "object" && !Array.isArray(toolArgs) && toolArgs.dryRun === true;
+    const isMcpWrite = request.method === "tools/call" && (toolName === "engram.memory_store" || toolName === "remnic.memory_store" || toolName === "engram.suggestion_submit" || toolName === "remnic.suggestion_submit" || toolName === "engram.observe" || toolName === "remnic.observe" || toolName === "engram.capsule_export" || toolName === "remnic.capsule_export" || toolName === "engram.capsule_import" || toolName === "remnic.capsule_import" || !dreamsRunDryRun && (toolName === "engram.dreams_run" || toolName === "remnic.dreams_run") || !memoryActionApplyDryRun && (toolName === "engram.memory_action_apply" || toolName === "remnic.memory_action_apply"));
     if (isMcpWrite) {
       this.ensureWriteRateLimitAvailable();
     }
@@ -59946,7 +60635,7 @@ var EngramAccessHttpServer = class {
   }
   async respondStatic(res, filePath, contentType) {
     try {
-      const body = await readFile43(filePath, "utf-8");
+      const body = await readFile44(filePath, "utf-8");
       res.statusCode = 200;
       res.setHeader("content-type", contentType);
       res.setHeader("content-length", String(Buffer.byteLength(body)));
@@ -60121,7 +60810,7 @@ async function resolveAgentAccessAuthToken(value, options = {}) {
 }
 
 // ../remnic-core/src/compat/checks.ts
-import { access as access5, readFile as readFile44 } from "fs/promises";
+import { access as access6, readFile as readFile45 } from "fs/promises";
 import path71 from "path";
 var REQUIRED_HOOKS_LEGACY = ["before_agent_start", "agent_end"];
 var REQUIRED_HOOKS_NEW = ["before_prompt_build", "agent_end"];
@@ -60303,7 +60992,7 @@ async function runCompatChecks(options) {
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
-    pluginRaw = await readFile44(pluginJsonPath, "utf-8");
+    pluginRaw = await readFile45(pluginJsonPath, "utf-8");
     pluginManifestPresent = true;
     checks.push({
       id: "plugin-manifest-present",
@@ -60353,7 +61042,7 @@ async function runCompatChecks(options) {
   let packageRaw = "";
   let packageJsonPresent = false;
   try {
-    packageRaw = await readFile44(packageJsonPath, "utf-8");
+    packageRaw = await readFile45(packageJsonPath, "utf-8");
     packageJsonPresent = true;
   } catch {
     checks.push({
@@ -60423,8 +61112,8 @@ async function runCompatChecks(options) {
     }
   }
   try {
-    await access5(indexPath);
-    const indexRaw = await readFile44(indexPath, "utf-8");
+    await access6(indexPath);
+    const indexRaw = await readFile45(indexPath, "utf-8");
     const structuralSource = stripCommentsAndStrings(indexRaw);
     const hooks = parseHookRegistrations(indexRaw);
     const missingLegacy = REQUIRED_HOOKS_LEGACY.filter((hook) => !hooks.has(hook));
@@ -60849,7 +61538,7 @@ async function promoteSemanticRuleFromMemory(options) {
 }
 
 // ../remnic-core/src/training-export/converter.ts
-import { lstat as lstat2, readdir as readdir26, readFile as readFile45, realpath as realpath4 } from "fs/promises";
+import { lstat as lstat3, readdir as readdir27, readFile as readFile46, realpath as realpath4 } from "fs/promises";
 import path73 from "path";
 
 // ../remnic-core/src/training-export/date-parse.ts
@@ -61455,7 +62144,7 @@ async function runRepairMemoryProjectionCliCommand(options) {
   });
 }
 async function runMemoryTimelineCliCommand(options) {
-  const storage = new (await import("./storage-T2OGFUF4.js")).StorageManager(options.memoryDir);
+  const storage = new (await import("./storage-PTQ2H2YJ.js")).StorageManager(options.memoryDir);
   return storage.getMemoryTimeline(options.memoryId, options.limit);
 }
 async function runMemoryGovernanceCliCommand(options) {
@@ -61483,7 +62172,7 @@ async function runMemoryGovernanceRestoreCliCommand(options) {
   });
 }
 async function runMemoryReviewDispositionCliCommand(options) {
-  const storage = new (await import("./storage-T2OGFUF4.js")).StorageManager(options.memoryDir);
+  const storage = new (await import("./storage-PTQ2H2YJ.js")).StorageManager(options.memoryDir);
   const memory = await storage.getMemoryById(options.memoryId);
   if (!memory) throw new Error(`memory not found: ${options.memoryId}`);
   const updated = await storage.writeMemoryFrontmatter(memory, {
@@ -61662,7 +62351,7 @@ async function runSemanticRulePromoteCliCommand(options) {
   });
 }
 async function runCompoundingPromoteCliCommand(options) {
-  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-VMTFKFGO.js");
+  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-BIYI3P4J.js");
   const config = parseConfig({
     memoryDir: options.memoryDir,
     qmdEnabled: false,
@@ -62076,7 +62765,7 @@ function effectivePolicyValuesForVersion(values, config) {
 }
 function policyVersionForValues(values, config) {
   const normalized = effectivePolicyValuesForVersion(values, config);
-  return createHash13("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
+  return createHash14("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
   const filePath = path74.join(config.memoryDir, "state", fileName);
@@ -62667,7 +63356,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile46(options.inputPath, "utf-8");
+  const inputRaw = await readFile47(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -62759,7 +63448,7 @@ async function runBulkImportCliCommand(opts) {
       "Bulk import persistence is not wired: no ingestBatch callback was provided by the host CLI. Use --dry-run to validate without persisting, or invoke via `openclaw engram bulk-import` which supplies the orchestrator-backed ingestion path."
     );
   }
-  const inputRaw = await readFile46(opts.file, "utf-8");
+  const inputRaw = await readFile47(opts.file, "utf-8");
   let inputParsed;
   try {
     inputParsed = JSON.parse(inputRaw);
@@ -62823,7 +63512,7 @@ async function runBulkImportCliCommand(opts) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile46(pkgPath, "utf-8");
+    const raw = await readFile47(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -62832,7 +63521,7 @@ async function getPluginVersion() {
 }
 async function exists3(p) {
   try {
-    await access6(p);
+    await access7(p);
     return true;
   } catch {
     return false;
@@ -62858,7 +63547,7 @@ async function walkMemoryMarkdownFiles(memoryDir, visit) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir27(dir, { withFileTypes: true });
+      entries = await readdir28(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -62888,7 +63577,7 @@ async function readAllMemoryFiles(memoryDir) {
   const out = [];
   await walkMemoryMarkdownFiles(memoryDir, async (fullPath) => {
     try {
-      const raw = await readFile46(fullPath, "utf-8");
+      const raw = await readFile47(fullPath, "utf-8");
       const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
       if (!parsed) return;
       const fmRaw = parsed[1];
@@ -63634,8 +64323,8 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const memoryDir = await resolveMemoryDirForNamespace(orchestrator, namespace, {
           rejectUnsupportedOverride: true
         });
-        const { exportCapsule } = await import("./capsule-export-CVA3CKUQ.js");
-        const result = await exportCapsule({
+        const { exportCapsule: exportCapsule2 } = await import("./capsule-export-IXVERCQG.js");
+        const result = await exportCapsule2({
           name,
           root: memoryDir,
           since,
@@ -63680,7 +64369,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const memoryDir = await resolveMemoryDirForNamespace(orchestrator, namespace, {
           rejectUnsupportedOverride: true
         });
-        const { importCapsule: importCapsule2 } = await import("./capsule-import-CFX7BY5W.js");
+        const { importCapsule: importCapsule2 } = await import("./capsule-import-IA6VIOPQ.js");
         const result = await importCapsule2({
           archivePath: expandTildePath(archivePath),
           root: memoryDir,
@@ -63703,11 +64392,11 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const opts = args[1] ?? {};
         const {
           parseCapsuleMergeOptions,
-          defaultCapsulesDir
-        } = await import("./capsule-cli-TFKLAG3S.js");
+          defaultCapsulesDir: defaultCapsulesDir2
+        } = await import("./capsule-cli-GBM3WPAM.js");
         const parsed = parseCapsuleMergeOptions(archiveArg, opts);
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
-        const capsulesDir = defaultCapsulesDir(memoryDir);
+        const capsulesDir = defaultCapsulesDir2(memoryDir);
         const { stat: statMerge } = await import("fs/promises");
         let sourceArchive = expandTildePath(parsed.archive);
         const looksLikePath = sourceArchive.startsWith("/") || sourceArchive.startsWith("./") || sourceArchive.startsWith("../") || sourceArchive.includes(path74.sep);
@@ -63739,7 +64428,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
             );
           }
         }
-        const { mergeCapsule } = await import("./capsule-merge-7RVOHJK3.js");
+        const { mergeCapsule } = await import("./capsule-merge-IWOQ34KL.js");
         const result = await mergeCapsule({
           sourceArchive,
           targetRoot: memoryDir,
@@ -63769,17 +64458,17 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const {
           parseCapsuleListOptions,
           renderCapsuleList,
-          defaultCapsulesDir
-        } = await import("./capsule-cli-TFKLAG3S.js");
+          defaultCapsulesDir: defaultCapsulesDir2
+        } = await import("./capsule-cli-GBM3WPAM.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
-        const defaultDir = defaultCapsulesDir(memoryDir);
+        const defaultDir = defaultCapsulesDir2(memoryDir);
         const dirWasExplicit = typeof opts.dir === "string" && opts.dir.trim() !== "";
         const parsed = parseCapsuleListOptions(opts, defaultDir);
         const capsulesDir = expandTildePath(parsed.capsulesDir);
-        const { readdir: readdir29, readFile: readFile53, stat: stat21 } = await import("fs/promises");
+        const { readdir: readdir30, readFile: readFile54, stat: stat21 } = await import("fs/promises");
         let dirEntries;
         try {
-          dirEntries = await readdir29(capsulesDir);
+          dirEntries = await readdir30(capsulesDir);
         } catch (err) {
           const code = err.code;
           if (dirWasExplicit) {
@@ -63815,7 +64504,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
           if (hasManifest) {
             try {
-              const raw = await readFile53(manifestPath2, "utf-8");
+              const raw = await readFile54(manifestPath2, "utf-8");
               const sidecar = JSON.parse(raw);
               createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
               pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
@@ -63850,10 +64539,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const {
           parseCapsuleInspectOptions,
           renderCapsuleInspect,
-          defaultCapsulesDir
-        } = await import("./capsule-cli-TFKLAG3S.js");
+          defaultCapsulesDir: defaultCapsulesDir2
+        } = await import("./capsule-cli-GBM3WPAM.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
-        const capsulesDir = defaultCapsulesDir(memoryDir);
+        const capsulesDir = defaultCapsulesDir2(memoryDir);
         const parsed = parseCapsuleInspectOptions(archiveArg, opts);
         const { stat: stat21 } = await import("fs/promises");
         let archivePath = expandTildePath(parsed.archive);
@@ -63881,8 +64570,8 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const sidecarPath = archivePath.replace(/\.enc$/, "").replace(/\.capsule\.json\.gz$/, ".manifest.json");
         let sidecar = null;
         try {
-          const { readFile: readFile53 } = await import("fs/promises");
-          const raw = await readFile53(sidecarPath, "utf-8");
+          const { readFile: readFile54 } = await import("fs/promises");
+          const raw = await readFile54(sidecarPath, "utf-8");
           sidecar = JSON.parse(raw);
         } catch {
         }
@@ -63891,7 +64580,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           manifest = sidecar;
         } else if (isEncrypted) {
           const { gunzipSync } = await import("zlib");
-          const { parseExportBundle } = await import("./types-H5R5D3WF.js");
+          const { parseExportBundle } = await import("./types-R4DO7AKM.js");
           let decryptedBuf;
           try {
             const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-K3IRTKRH.js");
@@ -63919,10 +64608,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
           manifest = parsed2.bundle.manifest;
         } else {
-          const { readFile: readFile53 } = await import("fs/promises");
+          const { readFile: readFile54 } = await import("fs/promises");
           const { gunzipSync } = await import("zlib");
-          const { parseExportBundle } = await import("./types-H5R5D3WF.js");
-          const buf = await readFile53(archivePath);
+          const { parseExportBundle } = await import("./types-R4DO7AKM.js");
+          const buf = await readFile54(archivePath);
           const json = gunzipSync(buf).toString("utf-8");
           const parsed2 = parseExportBundle(JSON.parse(json));
           if (parsed2.capsuleVersion !== 2) {
@@ -66689,7 +67378,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           runSecureStoreInit,
           createPassphraseReader,
           renderInitReport
-        } = await import("./secure-store-FWJ7LBPH.js");
+        } = await import("./secure-store-A4NGCNXV.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
         const kdf = typeof options.kdf === "string" ? options.kdf.trim() : "argon2id";
         if (kdf !== "argon2id" && kdf !== "scrypt") {
@@ -66717,7 +67406,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           runSecureStoreUnlock,
           createPassphraseReader,
           renderUnlockReport
-        } = await import("./secure-store-FWJ7LBPH.js");
+        } = await import("./secure-store-A4NGCNXV.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
         const report = await runSecureStoreUnlock({
           memoryDir,
@@ -66736,7 +67425,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         "Lock the secure-store. Clears the master key from the daemon's in-memory keyring. Idempotent \u2014 succeeds even if the store is already locked."
       ).option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const options = args[0] ?? {};
-        const { runSecureStoreLock, renderLockReport } = await import("./secure-store-FWJ7LBPH.js");
+        const { runSecureStoreLock, renderLockReport } = await import("./secure-store-A4NGCNXV.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
         const report = runSecureStoreLock({ memoryDir });
         if (options.json === true) {
@@ -66749,7 +67438,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         "Encrypt existing plaintext storage-managed memory files in an initialized, unlocked secure-store. Idempotent; already-encrypted files are skipped."
       ).option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const options = args[0] ?? {};
-        const { runSecureStoreMigrate, renderMigrateReport } = await import("./secure-store-FWJ7LBPH.js");
+        const { runSecureStoreMigrate, renderMigrateReport } = await import("./secure-store-A4NGCNXV.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
         const report = await runSecureStoreMigrate({ memoryDir });
         if (options.json === true) {
@@ -66761,11 +67450,34 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           process.exitCode = 1;
         }
       });
+      async function runSecureStoreDisableCommand(options) {
+        const { runSecureStoreDisable, renderDisableReport } = await import("./secure-store-A4NGCNXV.js");
+        const memoryDir = expandTildePath(orchestrator.config.memoryDir);
+        const report = await runSecureStoreDisable({ memoryDir });
+        if (options.json === true) {
+          console.log(JSON.stringify(report, null, 2));
+        } else {
+          console.log(renderDisableReport(report));
+        }
+        if (!report.ok) {
+          process.exitCode = 1;
+        }
+      }
+      secureStoreCmd.command("disable").description(
+        "Decrypt storage-managed secure-store files back to plaintext. Requires an initialized, unlocked secure-store and keeps .secure-store metadata in place."
+      ).option("--json", "Emit machine-readable JSON only").action(async (...args) => {
+        const options = args[0] ?? {};
+        await runSecureStoreDisableCommand(options);
+      });
+      secureStoreCmd.command("decrypt").description("Alias for `secure-store disable`.").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
+        const options = args[0] ?? {};
+        await runSecureStoreDisableCommand(options);
+      });
       secureStoreCmd.command("status").description(
         "Report secure-store status: whether a header exists, whether the daemon currently holds the key, KDF parameters, and last-unlock timestamp."
       ).option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const options = args[0] ?? {};
-        const { runSecureStoreStatus, renderStatusReport } = await import("./secure-store-FWJ7LBPH.js");
+        const { runSecureStoreStatus, renderStatusReport } = await import("./secure-store-A4NGCNXV.js");
         const memoryDir = expandTildePath(orchestrator.config.memoryDir);
         const report = await runSecureStoreStatus({ memoryDir });
         if (options.json === true) {
@@ -67425,13 +68137,13 @@ async function probeQmdAvailability(host) {
 }
 
 // ../../src/index.ts
-import { readFile as readFile52, realpath as realpath7, writeFile as writeFile44 } from "fs/promises";
+import { readFile as readFile53, realpath as realpath7, writeFile as writeFile44 } from "fs/promises";
 import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
 import path99 from "path";
 import os7 from "os";
 
 // ../remnic-core/src/opik-exporter.ts
-import { createHash as createHash14, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash15, randomBytes as randomBytes2 } from "crypto";
 import { readFileSync as readFileSync4 } from "fs";
 import path75 from "path";
 var OPIK_EXPORTER_SLOT = "__openclawOpikExporter";
@@ -67752,7 +68464,7 @@ var OpikExporter = class _OpikExporter {
    * the version/variant bits, not timestamp ordering.
    */
   sessionToTraceId(sessionKey) {
-    const digest = createHash14("sha256").update(sessionKey).digest();
+    const digest = createHash15("sha256").update(sessionKey).digest();
     digest[6] = digest[6] & 15 | 112;
     digest[8] = digest[8] & 63 | 128;
     const hex = digest.slice(0, 16).toString("hex");
@@ -67799,7 +68511,7 @@ function cleanUserMessage(content) {
 }
 
 // src/public-artifacts.ts
-import { readdir as readdir28, access as access7, stat as stat20, lstat as lstat3, realpath as realpath5 } from "fs/promises";
+import { readdir as readdir29, access as access8, stat as stat20, lstat as lstat4, realpath as realpath5 } from "fs/promises";
 import path76 from "path";
 var PUBLIC_DIRS = [
   { dir: "facts", kind: "fact", contentType: "markdown" },
@@ -67832,7 +68544,7 @@ async function listMarkdownFilesRecursive(rootDir, boundary, ancestorRealPaths)
   nextAncestors.add(resolvedRoot);
   let entries;
   try {
-    entries = await readdir28(rootDir, { withFileTypes: true });
+    entries = await readdir29(rootDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -67843,7 +68555,7 @@ async function listMarkdownFilesRecursive(rootDir, boundary, ancestorRealPaths)
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     try {
-      const linkStat = await lstat3(fullPath);
+      const linkStat = await lstat4(fullPath);
       if (linkStat.isSymbolicLink()) {
         if (!await isContainedWithin(fullPath, boundaryDir)) {
           continue;
@@ -67867,7 +68579,7 @@ async function listMarkdownFilesRecursive(rootDir, boundary, ancestorRealPaths)
 }
 async function pathExists2(inputPath) {
   try {
-    await access7(inputPath);
+    await access8(inputPath);
     return true;
   } catch {
     return false;
@@ -67907,7 +68619,7 @@ async function listRemnicPublicArtifacts(params) {
     if (!await pathExists2(absolutePath)) continue;
     if (!await isContainedWithin(absolutePath, memoryDir)) continue;
     try {
-      const linkStat = await lstat3(absolutePath);
+      const linkStat = await lstat4(absolutePath);
       if (linkStat.isSymbolicLink()) {
         const resolvedPath = await realpath5(absolutePath);
         const expectedParent = await realpath5(memoryDir);
@@ -68158,12 +68870,12 @@ import os6 from "os";
 import path92 from "path";
 
 // ../remnic-core/src/enrichment/audit.ts
-import { mkdir as mkdir47, readFile as readFile47, appendFile as appendFile5 } from "fs/promises";
+import { mkdir as mkdir47, readFile as readFile48, appendFile as appendFile5 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import path93 from "path";
 
 // ../remnic-core/src/transfer/capsule-fork.ts
-import { lstat as lstat4, mkdir as mkdir48, readFile as readFile48, realpath as realpath6, writeFile as writeFile41 } from "fs/promises";
+import { lstat as lstat5, mkdir as mkdir48, readFile as readFile49, realpath as realpath6, writeFile as writeFile41 } from "fs/promises";
 import path94 from "path";
 
 // src/openclaw-tools/shapes.ts
@@ -68943,7 +69655,7 @@ function validateSlotSelection(ctx) {
 }
 
 // ../remnic-core/src/session-toggles.ts
-import { mkdir as mkdir49, readFile as readFile49, writeFile as writeFile42 } from "fs/promises";
+import { mkdir as mkdir49, readFile as readFile50, writeFile as writeFile42 } from "fs/promises";
 import path95 from "path";
 function encodeToggleKey(sessionKey, agentId) {
   return `${encodeURIComponent(sessionKey)}::${encodeURIComponent(agentId)}`;
@@ -68958,7 +69670,7 @@ function decodeToggleKey(key) {
 }
 async function safeReadToggleFile(filePath) {
   try {
-    const raw = await readFile49(filePath, "utf8");
+    const raw = await readFile50(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.entries !== "object") {
       return { version: 1, entries: {} };
@@ -69441,14 +70153,14 @@ import {
 } from "@remnic/core";
 
 // ../remnic-core/src/surfaces/dreams.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { statSync, watch as watch2 } from "fs";
-import { mkdir as mkdir51, readFile as readFile50, writeFile as writeFile43 } from "fs/promises";
+import { mkdir as mkdir51, readFile as readFile51, writeFile as writeFile43 } from "fs/promises";
 import path97 from "path";
 var DIARY_START_MARKER = "<!-- openclaw:dreaming:diary:start -->";
 var DIARY_END_MARKER = "<!-- openclaw:dreaming:diary:end -->";
 function stableDreamId(params) {
-  const digest = createHash15("sha1").update(
+  const digest = createHash16("sha1").update(
     JSON.stringify({
       timestamp: params.timestamp,
       occurrence: params.occurrence
@@ -69609,7 +70321,7 @@ function createDreamsSurface() {
   return {
     async read(filePath) {
       try {
-        const content = await readFile50(filePath, "utf8");
+        const content = await readFile51(filePath, "utf8");
         return parseDreamEntries(content);
       } catch (error) {
         if (error.code === "ENOENT") {
@@ -69622,7 +70334,7 @@ function createDreamsSurface() {
       await mkdir51(path97.dirname(filePath), { recursive: true });
       let content = "";
       try {
-        content = await readFile50(filePath, "utf8");
+        content = await readFile51(filePath, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -69718,12 +70430,12 @@ ${ensured.slice(endIndex)}` : `${ensureDiary("")}${block}`;
 }
 
 // ../remnic-core/src/surfaces/heartbeat.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { statSync as statSync2, watch as watch3 } from "fs";
-import { readFile as readFile51 } from "fs/promises";
+import { readFile as readFile52 } from "fs/promises";
 import path98 from "path";
 function stableHeartbeatId(params) {
-  const digest = createHash16("sha1").update(
+  const digest = createHash17("sha1").update(
     JSON.stringify({
       sourceOffset: params.sourceOffset
     })
@@ -69735,7 +70447,7 @@ function slugify(value) {
   if (normalized.length > 0) return normalized;
   const trimmed = value.trim();
   if (trimmed.length === 0) return "heartbeat-untitled";
-  return `heartbeat-${createHash16("sha1").update(trimmed).digest("hex").slice(0, 8)}`;
+  return `heartbeat-${createHash17("sha1").update(trimmed).digest("hex").slice(0, 8)}`;
 }
 function parseTags(line) {
   const match = /^Tags:\s*(.*)$/i.exec(line.trim());
@@ -69884,7 +70596,7 @@ function createHeartbeatSurface() {
   return {
     async read(filePath) {
       try {
-        const content = await readFile51(filePath, "utf8");
+        const content = await readFile52(filePath, "utf8");
         return parseHeartbeatEntries(content);
       } catch (error) {
         if (error.code === "ENOENT") {
@@ -71562,7 +72274,7 @@ Keep the reflection grounded in the evidence below.
                 async readFile(params) {
                   const requestedPath = normalizeWorkspacePath(params.relPath);
                   const absolutePath = await resolveReadablePath(params.relPath);
-                  const text = await readFile52(absolutePath, "utf-8");
+                  const text = await readFile53(absolutePath, "utf-8");
                   const allLines = text.split(/\r?\n/);
                   const from = typeof params.from === "number" ? Math.max(1, Math.floor(params.from)) : 1;
                   const lines = typeof params.lines === "number" && Number.isFinite(params.lines) ? Math.max(1, Math.floor(params.lines)) : void 0;
@@ -72218,7 +72930,7 @@ Keep the reflection grounded in the evidence below.
           jobs: []
         };
         try {
-          const content = await readFile52(cronFilePath, "utf-8");
+          const content = await readFile53(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }