@remnic/plugin-openclaw 1.0.11 → 1.0.13

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
@@ -1899,6 +1906,8 @@ function parseConfig(raw) {
     lcmRecallBudgetShare: typeof cfg.lcmRecallBudgetShare === "number" ? Math.max(0, Math.min(1, cfg.lcmRecallBudgetShare)) : 0.15,
     lcmDeterministicMaxTokens: typeof cfg.lcmDeterministicMaxTokens === "number" ? Math.max(64, Math.floor(cfg.lcmDeterministicMaxTokens)) : 512,
     lcmArchiveRetentionDays: typeof cfg.lcmArchiveRetentionDays === "number" ? Math.max(1, Math.floor(cfg.lcmArchiveRetentionDays)) : 90,
+    messagePartsEnabled: coerceBooleanLike(cfg.messagePartsEnabled) === true,
+    messagePartsRecallMaxResults: typeof cfg.messagePartsRecallMaxResults === "number" ? Math.max(0, Math.floor(cfg.messagePartsRecallMaxResults)) : 6,
     // v9.1 Parallel Specialized Retrieval
     parallelRetrievalEnabled: cfg.parallelRetrievalEnabled === true,
     parallelAgentWeights: (() => {
@@ -19342,7 +19351,9 @@ var RECALL_XRAY_SERVED_BY_VALUES = [
   "graph",
   "recent-scan",
   "procedural",
-  "review-context"
+  "review-context",
+  "lcm-file-parts",
+  "lcm-tool-parts"
 ];
 function isRecallXrayServedBy(value) {
   return typeof value === "string" && RECALL_XRAY_SERVED_BY_VALUES.includes(value);
@@ -26173,7 +26184,7 @@ function validateReplayTurn(turn, index) {
 // ../remnic-core/src/lcm/schema.ts
 import path37 from "path";
 import { mkdir as mkdir26 } from "fs/promises";
-var LCM_SCHEMA_VERSION = 1;
+var LCM_SCHEMA_VERSION = 2;
 function openLcmDatabase(memoryDir) {
   const dbPath = path37.join(memoryDir, "state", "lcm.sqlite");
   const db = openBetterSqlite3(dbPath);
@@ -26219,6 +26230,23 @@ function createTables(db) {
     CREATE INDEX IF NOT EXISTS idx_lcm_messages_session
       ON lcm_messages(session_id, turn_index);
 
+    CREATE TABLE IF NOT EXISTS lcm_message_parts (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      message_id  INTEGER NOT NULL REFERENCES lcm_messages(id) ON DELETE CASCADE,
+      ordinal     INTEGER NOT NULL,
+      kind        TEXT NOT NULL,
+      payload     TEXT NOT NULL,
+      tool_name   TEXT,
+      file_path   TEXT,
+      created_at  TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_lcm_message_parts_msg
+      ON lcm_message_parts(message_id, ordinal);
+    CREATE INDEX IF NOT EXISTS idx_lcm_message_parts_tool
+      ON lcm_message_parts(tool_name);
+    CREATE INDEX IF NOT EXISTS idx_lcm_message_parts_file
+      ON lcm_message_parts(file_path);
+
     CREATE TABLE IF NOT EXISTS lcm_summary_nodes (
       id            TEXT PRIMARY KEY,
       session_id    TEXT NOT NULL,
@@ -26271,6 +26299,423 @@ function createTables(db) {
   );
 }
 
+// ../remnic-core/src/message-parts/index.ts
+var LCM_MESSAGE_PART_KINDS = [
+  "text",
+  "tool_call",
+  "tool_result",
+  "patch",
+  "file_read",
+  "file_write",
+  "step_start",
+  "step_finish",
+  "snapshot",
+  "retry"
+];
+var SECRET_KEY_RE = /(api[_-]?key|authorization|bearer|credential|password|secret|token)/i;
+var MAX_PAYLOAD_STRING = 8e3;
+var MAX_FILE_SCAN_CHARS = 2e4;
+function isLcmMessagePartKind(value) {
+  return typeof value === "string" && LCM_MESSAGE_PART_KINDS.includes(value);
+}
+function parseMessageParts(input, options = {}) {
+  const explicit = normalizeExplicitParts(input);
+  if (explicit.length > 0) return explicit;
+  const format = options.sourceFormat ?? inferSourceFormat(input);
+  switch (format) {
+    case "openai":
+      return withRenderedFallback(parseOpenAiMessageParts(input, options), options);
+    case "anthropic":
+      return withRenderedFallback(parseAnthropicMessageParts(input, options), options);
+    case "openclaw":
+      return withRenderedFallback(parseOpenClawMessageParts(input, options), options);
+    case "lossless-claw":
+    case "remnic":
+      return withRenderedFallback(normalizeExplicitParts(input), options);
+    default:
+      return renderedFallbackParts(options);
+  }
+}
+function normalizeExplicitParts(input) {
+  const rawParts = pickArray(input, "parts") ?? pickArray(input, "message_parts");
+  if (!rawParts) return [];
+  const parts = [];
+  rawParts.forEach((raw, index) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+    const obj = raw;
+    const kind = normalizeKind(obj.kind ?? obj.type);
+    if (!kind) return;
+    const payload = obj.payload && typeof obj.payload === "object" && !Array.isArray(obj.payload) ? obj.payload : { value: sanitizePayload(obj) };
+    const toolName = asNonEmptyString(obj.toolName ?? obj.tool_name ?? obj.name);
+    const filePath = asNonEmptyString(obj.filePath ?? obj.file_path ?? obj.path);
+    const ordinal = typeof obj.ordinal === "number" && Number.isInteger(obj.ordinal) ? Math.max(0, obj.ordinal) : index;
+    parts.push({
+      ordinal,
+      kind,
+      payload: sanitizePayload(payload),
+      toolName,
+      filePath,
+      createdAt: asNonEmptyString(obj.createdAt ?? obj.created_at)
+    });
+  });
+  return parts;
+}
+function parseOpenAiMessageParts(input, _options = {}) {
+  const items = gatherOpenAiItems(input);
+  const parts = [];
+  for (const item of items) {
+    const type = asNonEmptyString(item.type) ?? asNonEmptyString(item.kind);
+    if (!type) continue;
+    if (isOpenAiContentBlock(item)) {
+      const text = asNonEmptyString(item.text ?? item.content);
+      if (text) parts.push(makePart("text", { type, text }, { filePath: firstFilePath(text) }));
+      continue;
+    }
+    if (type === "message") {
+      for (const block of gatherContentBlocks(item.content)) {
+        const text = asNonEmptyString(block.text ?? block.content);
+        if (text) parts.push(makePart("text", { type, text }, { filePath: firstFilePath(text) }));
+      }
+      continue;
+    }
+    if (type === "function_call") {
+      const toolName = asNonEmptyString(item.name ?? item.tool_name);
+      const payload = {
+        id: item.id ?? item.call_id,
+        name: toolName,
+        arguments: parseMaybeJson(item.arguments)
+      };
+      parts.push(classifyToolPart(toolName, payload));
+      continue;
+    }
+    if (type === "function_call_output") {
+      const output = asNonEmptyString(item.output) ?? JSON.stringify(sanitizePayload(item.output ?? item));
+      parts.push(makePart("tool_result", { id: item.id ?? item.call_id, output }, {
+        filePath: firstFilePath(output)
+      }));
+      continue;
+    }
+    if (type === "reasoning") {
+      parts.push(makePart("step_start", { type, summary: sanitizePayload(item.summary ?? item) }));
+      continue;
+    }
+    if (type === "retry") {
+      parts.push(makePart("retry", { type, item: sanitizePayload(item) }));
+    }
+  }
+  return withOrdinals(parts);
+}
+function parseAnthropicMessageParts(input, _options = {}) {
+  const blocks = gatherContentBlocks(
+    Array.isArray(input) ? input : input && typeof input === "object" ? input.content : input
+  );
+  const parts = [];
+  for (const block of blocks) {
+    const type = asNonEmptyString(block.type);
+    if (type === "text") {
+      const text = asNonEmptyString(block.text);
+      if (text) parts.push(makePart("text", { type, text }, { filePath: firstFilePath(text) }));
+      continue;
+    }
+    if (type === "tool_use") {
+      const toolName = asNonEmptyString(block.name);
+      parts.push(classifyToolPart(toolName, {
+        id: block.id,
+        name: toolName,
+        input: sanitizePayload(block.input)
+      }));
+      continue;
+    }
+    if (type === "tool_result") {
+      const content = block.content;
+      const rendered = renderUnknownContent(content);
+      parts.push(makePart("tool_result", { id: block.tool_use_id, content: sanitizePayload(content) }, {
+        filePath: firstFilePath(rendered)
+      }));
+      continue;
+    }
+    if (type === "thinking") {
+      parts.push(makePart("step_start", {
+        type,
+        thinking: truncateString(asNonEmptyString(block.thinking) ?? ""),
+        signature: asNonEmptyString(block.signature)
+      }));
+      continue;
+    }
+    if (type === "redacted_thinking") {
+      parts.push(makePart("step_finish", { type }));
+    }
+  }
+  return withOrdinals(parts);
+}
+function parseOpenClawMessageParts(input, options = {}) {
+  const explicit = normalizeExplicitParts(input);
+  if (explicit.length > 0) return explicit;
+  if (!input || typeof input !== "object") return [];
+  const obj = input;
+  const content = obj.content;
+  if (Array.isArray(content)) {
+    const hasOpenAiBlocks = content.some(isOpenAiContentBlock);
+    if (hasOpenAiBlocks) return parseOpenAiMessageParts(content, options);
+    const hasAnthropicBlocks = content.some(
+      (block) => block && typeof block === "object" && typeof block.type === "string"
+    );
+    if (hasAnthropicBlocks) return parseAnthropicMessageParts({ content }, options);
+  }
+  const toolName = asNonEmptyString(obj.toolName ?? obj.tool_name ?? obj.name);
+  if (toolName) {
+    return withOrdinals([
+      classifyToolPart(toolName, {
+        name: toolName,
+        input: sanitizePayload(obj.input ?? obj.arguments ?? obj.params),
+        output: sanitizePayload(obj.output ?? obj.result)
+      })
+    ]);
+  }
+  const rendered = options.renderedContent ?? asNonEmptyString(obj.content);
+  return rendered ? withOrdinals(partsFromRenderedText(rendered)) : [];
+}
+function partsFromRenderedText(text) {
+  if (text.includes("*** Begin Patch")) {
+    const paths2 = extractFilePaths(text);
+    const patchPaths = extractPatchPaths(text);
+    return withOrdinals((patchPaths.length > 0 ? patchPaths : paths2).map(
+      (filePath) => makePart("patch", { text: truncateString(text) }, { filePath })
+    ));
+  }
+  const paths = extractFilePaths(text);
+  if (paths.length === 0) return [];
+  return withOrdinals(paths.map(
+    (filePath) => makePart("file_read", { text: truncateString(text) }, { filePath })
+  ));
+}
+function inferSourceFormat(input) {
+  if (input && typeof input === "object") {
+    const obj = input;
+    const explicit = asNonEmptyString(obj.sourceFormat ?? obj.source_format);
+    if (explicit === "openai" || explicit === "anthropic" || explicit === "openclaw" || explicit === "lossless-claw" || explicit === "remnic") {
+      return explicit;
+    }
+    if (Array.isArray(obj.output)) return "openai";
+    if (isOpenAiResponseItem(obj)) return "openai";
+    if (Array.isArray(obj.content) && obj.content.some(isOpenAiContentBlock)) return "openai";
+    if (Array.isArray(obj.content)) return "anthropic";
+  }
+  if (Array.isArray(input)) {
+    return input.some(
+      (item) => isRecord3(item) && (isOpenAiResponseItem(item) || isOpenAiContentBlock(item))
+    ) ? "openai" : "anthropic";
+  }
+  return void 0;
+}
+function isOpenAiResponseItem(obj) {
+  const type = asNonEmptyString(obj.type ?? obj.kind);
+  return type === "message" || type === "function_call" || type === "function_call_output" || type === "reasoning" || type === "retry";
+}
+function isOpenAiContentBlock(value) {
+  if (!isRecord3(value)) return false;
+  const type = asNonEmptyString(value.type);
+  return type === "input_text" || type === "output_text" || type === "input_image" || type === "input_file" || type === "refusal";
+}
+function gatherOpenAiItems(input) {
+  if (Array.isArray(input)) return input.filter(isRecord3);
+  if (!isRecord3(input)) return [];
+  if (Array.isArray(input.output)) return input.output.filter(isRecord3);
+  if (Array.isArray(input.items)) return input.items.filter(isRecord3);
+  return [input];
+}
+function gatherContentBlocks(input) {
+  if (Array.isArray(input)) return input.filter(isRecord3);
+  if (typeof input === "string") return [{ type: "text", text: input }];
+  if (isRecord3(input)) return [input];
+  return [];
+}
+function classifyToolPart(toolName, payload) {
+  const normalized = (toolName ?? "").toLowerCase();
+  const rendered = renderUnknownContent(payload);
+  const filePath = firstFilePathFromObject(payload) ?? firstFilePath(rendered) ?? null;
+  if (normalized.includes("apply_patch") || rendered.includes("*** Begin Patch")) {
+    return makePart("patch", payload, { toolName, filePath: filePath ?? extractPatchPaths(rendered)[0] ?? null });
+  }
+  if (/(write|edit|multiedit|create|save)/i.test(normalized)) {
+    return makePart("file_write", payload, { toolName, filePath });
+  }
+  if (/(read|grep|glob|search|list|ls)/i.test(normalized)) {
+    return makePart("file_read", payload, { toolName, filePath });
+  }
+  return makePart("tool_call", payload, { toolName, filePath });
+}
+function makePart(kind, payload, options = {}) {
+  return {
+    kind,
+    payload: sanitizePayload(payload),
+    toolName: options.toolName ?? null,
+    filePath: options.filePath ?? null
+  };
+}
+function withOrdinals(parts) {
+  return parts.map((part, ordinal) => ({ ...part, ordinal: part.ordinal ?? ordinal }));
+}
+function withRenderedFallback(parts, options) {
+  return parts.length > 0 ? parts : renderedFallbackParts(options);
+}
+function renderedFallbackParts(options) {
+  const rendered = asNonEmptyString(options.renderedContent);
+  return rendered ? partsFromRenderedText(rendered) : [];
+}
+function normalizeKind(value) {
+  if (isLcmMessagePartKind(value)) return value;
+  if (value === "tool_use" || value === "function_call") return "tool_call";
+  if (value === "function_call_output") return "tool_result";
+  if (value === "thinking" || value === "reasoning") return "step_start";
+  return null;
+}
+function pickArray(input, key) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const value = input[key];
+  return Array.isArray(value) ? value : null;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseMaybeJson(value) {
+  if (typeof value !== "string") return sanitizePayload(value);
+  try {
+    return sanitizePayload(JSON.parse(value));
+  } catch {
+    return truncateString(value);
+  }
+}
+function sanitizePayload(value, depth = 0) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") return truncateString(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    if (depth >= 4) return "[truncated]";
+    return value.slice(0, 100).map((item) => sanitizePayload(item, depth + 1));
+  }
+  if (typeof value === "object") {
+    if (depth >= 4) return "[truncated]";
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = SECRET_KEY_RE.test(key) ? "[redacted]" : sanitizePayload(child, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+function truncateString(value) {
+  return value.length > MAX_PAYLOAD_STRING ? `${value.slice(0, MAX_PAYLOAD_STRING)}...[truncated]` : value;
+}
+function renderUnknownContent(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value ?? "");
+  } catch {
+    return String(value ?? "");
+  }
+}
+function firstFilePathFromObject(value) {
+  if (!isRecord3(value)) return null;
+  const keys = ["file_path", "filePath", "path", "filename", "cwd"];
+  for (const key of keys) {
+    const candidate = asNonEmptyString(value[key]);
+    if (candidate) return candidate;
+  }
+  for (const child of Object.values(value)) {
+    if (typeof child === "string") {
+      const fromText = extractPatchPaths(child)[0] ?? firstFilePath(child);
+      if (fromText) return fromText;
+    }
+    if (isRecord3(child)) {
+      const nested = firstFilePathFromObject(child);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+function firstFilePath(text) {
+  return extractFilePaths(text)[0] ?? null;
+}
+function extractFilePaths(text) {
+  const out = /* @__PURE__ */ new Set();
+  let token = "";
+  const scanLength = Math.min(text.length, MAX_FILE_SCAN_CHARS);
+  for (let index = 0; index <= scanLength; index += 1) {
+    const char = index < scanLength ? text[index] : " ";
+    if (isFilePathTokenSeparator(char)) {
+      addFilePathCandidate(out, token);
+      token = "";
+      continue;
+    }
+    token += char;
+    if (token.length > 512) {
+      addFilePathCandidate(out, token);
+      token = "";
+    }
+  }
+  return [...out].slice(0, 20);
+}
+function isFilePathTokenSeparator(char) {
+  return char === " " || char === "\n" || char === "\r" || char === "	" || char === '"' || char === "'" || char === "`" || char === "(" || char === ")" || char === "[" || char === "]" || char === "{" || char === "}" || char === "<" || char === ">" || char === ",";
+}
+function addFilePathCandidate(out, raw) {
+  const candidate = trimFilePathPunctuation(raw);
+  if (candidate.length === 0 || candidate.includes("://")) return;
+  if (isLikelyFilePath(candidate)) out.add(candidate);
+}
+function trimFilePathPunctuation(raw) {
+  let start = 0;
+  let end = raw.length;
+  while (start < end && isLeadingFilePathPunctuation(raw[start])) start += 1;
+  while (end > start && isTrailingFilePathPunctuation(raw[end - 1])) end -= 1;
+  return raw.slice(start, end);
+}
+function isLeadingFilePathPunctuation(char) {
+  return char === ":" || char === ";" || char === "!" || char === "?" || char === "|" || char === "*" || char === "=";
+}
+function isTrailingFilePathPunctuation(char) {
+  return char === "." || char === ":" || char === ";" || char === "!" || char === "?" || char === "|" || char === "*" || char === "=";
+}
+function isLikelyFilePath(value) {
+  if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/")) {
+    return hasValidFileExtension(value);
+  }
+  if (value.includes("/")) return hasValidFileExtension(value);
+  return hasValidFileExtension(value);
+}
+function hasValidFileExtension(value) {
+  const lastSlash = value.lastIndexOf("/");
+  const basename3 = value.slice(lastSlash + 1);
+  const dot = basename3.lastIndexOf(".");
+  if (dot <= 0 || dot === basename3.length - 1) return false;
+  const ext = basename3.slice(dot + 1);
+  if (ext.length < 1 || ext.length > 12) return false;
+  for (const char of ext) {
+    if (!isFileExtensionChar(char)) return false;
+  }
+  return true;
+}
+function isFileExtensionChar(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "_" || char === "+" || char === "-";
+}
+function extractPatchPaths(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const line of text.split(/\r?\n/)) {
+    const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/);
+    if (match?.[1]) out.add(match[1].trim());
+    const move = line.match(/^\*\*\* Move to: (.+)$/);
+    if (move?.[1]) out.add(move[1].trim());
+  }
+  return [...out].slice(0, 20);
+}
+
 // ../remnic-core/src/lcm/archive.ts
 function estimateTokens3(text) {
   return Math.ceil(text.length / 4);
@@ -26281,7 +26726,7 @@ var LcmArchive = class {
   }
   db;
   /** Append a message to the archive. Returns the row id. */
-  appendMessage(sessionId, turnIndex, role, content, metadata) {
+  appendMessage(sessionId, turnIndex, role, content, metadata, parts) {
     const tokenCount = estimateTokens3(content);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const metaJson = metadata ? JSON.stringify(metadata) : null;
@@ -26292,18 +26737,58 @@ var LcmArchive = class {
     const result = stmt.run(sessionId, turnIndex, role, content, tokenCount, now, metaJson);
     const rowId = Number(result.lastInsertRowid);
     this.db.prepare("INSERT INTO lcm_messages_fts (rowid, content) VALUES (?, ?)").run(rowId, content);
+    if (parts && parts.length > 0) {
+      this.insertMessageParts(rowId, parts, now);
+    }
     return rowId;
   }
   /** Append multiple messages in a single transaction. */
-  appendMessages(sessionId, messages) {
+  appendMessages(sessionId, messages, options = {}) {
     if (messages.length === 0) return;
+    const captureMessageParts = options.messagePartsEnabled !== false;
     const txn = this.db.transaction(() => {
       for (const msg of messages) {
-        this.appendMessage(sessionId, msg.turnIndex, msg.role, msg.content, msg.metadata);
+        const explicitParts = msg.parts && msg.parts.length > 0 ? msg.parts : void 0;
+        const rawContent = msg.rawContent ?? msg.content;
+        const parts = captureMessageParts ? explicitParts ?? parseMessageParts(rawContent, {
+          sourceFormat: msg.sourceFormat,
+          renderedContent: msg.content
+        }) : void 0;
+        this.appendMessage(
+          sessionId,
+          msg.turnIndex,
+          msg.role,
+          msg.content,
+          msg.metadata,
+          parts
+        );
       }
     });
     txn();
   }
+  insertMessageParts(messageId, parts, fallbackCreatedAt) {
+    if (parts.length === 0) return;
+    const stmt = this.db.prepare(`
+      INSERT INTO lcm_message_parts (message_id, ordinal, kind, payload, tool_name, file_path, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (let index = 0; index < parts.length; index += 1) {
+      const part = parts[index];
+      const rawPart = part;
+      const toolName = part.toolName ?? asNullableString(rawPart.tool_name);
+      const filePath = part.filePath ?? asNullableString(rawPart.file_path);
+      const createdAt = part.createdAt ?? asNullableString(rawPart.created_at);
+      stmt.run(
+        messageId,
+        part.ordinal ?? index,
+        part.kind,
+        JSON.stringify(part.payload ?? {}),
+        toolName ?? null,
+        filePath ?? null,
+        createdAt ?? fallbackCreatedAt
+      );
+    }
+  }
   /** Get the highest turn_index for a session, or -1 if none. */
   getMaxTurnIndex(sessionId) {
     const row = this.db.prepare("SELECT MAX(turn_index) as max_turn FROM lcm_messages WHERE session_id = ?").get(sessionId);
@@ -26425,6 +26910,55 @@ var LcmArchive = class {
       return [];
     }
   }
+  searchStructuredParts(query, limit, sessionId) {
+    const cappedLimit = Math.max(0, Math.min(20, Math.floor(limit)));
+    if (cappedLimit === 0) return [];
+    const fileTerms = extractStructuredFileTerms(query);
+    const toolTerms = extractStructuredToolTerms(query);
+    if (fileTerms.length === 0 && toolTerms.length === 0) return [];
+    const matchWhere = [];
+    const whereParams = [];
+    for (const term of fileTerms) {
+      matchWhere.push("(p.file_path = ? OR p.file_path LIKE ? ESCAPE '\\')");
+      whereParams.push(term, `%${escapeLike(term)}%`);
+    }
+    for (const term of toolTerms) {
+      matchWhere.push("p.tool_name LIKE ? ESCAPE '\\'");
+      whereParams.push(`%${escapeLike(term)}%`);
+    }
+    const where = [`(${matchWhere.join(" OR ")})`];
+    if (sessionId) {
+      where.push("m.session_id = ?");
+      whereParams.push(sessionId);
+    }
+    const exactFileScoreParams = [...fileTerms];
+    const sqlParams = [...exactFileScoreParams, ...whereParams, cappedLimit];
+    const rows = this.db.prepare(`
+      SELECT
+        p.id AS part_id,
+        p.message_id AS message_id,
+        m.turn_index AS turn_index,
+        m.role AS role,
+        m.content AS content,
+        m.session_id AS session_id,
+        p.kind AS kind,
+        p.tool_name AS tool_name,
+        p.file_path AS file_path,
+        p.payload AS payload,
+        CASE
+          WHEN p.file_path IN (${fileTerms.map(() => "?").join(",") || "NULL"}) THEN 3
+          WHEN p.file_path IS NOT NULL THEN 2
+          WHEN p.tool_name IS NOT NULL THEN 1
+          ELSE 0
+        END AS score
+      FROM lcm_message_parts p
+      JOIN lcm_messages m ON m.id = p.message_id
+      WHERE ${where.join(" AND ")}
+      ORDER BY score DESC, m.turn_index DESC, p.ordinal ASC
+      LIMIT ?
+    `).all(...sqlParams);
+    return rows;
+  }
   /** Get total message count for a session. */
   getMessageCount(sessionId) {
     const row = this.db.prepare("SELECT COUNT(*) as cnt FROM lcm_messages WHERE session_id = ?").get(sessionId);
@@ -26576,6 +27110,72 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "we",
   "they"
 ]);
+function extractStructuredFileTerms(query) {
+  const terms = /* @__PURE__ */ new Set();
+  for (const raw of splitQueryTerms(query)) {
+    const cleaned = trimStructuredQueryTerm(raw);
+    if (cleaned.includes("/") || hasStructuredFileExtension(cleaned)) {
+      terms.add(cleaned);
+      const basename3 = cleaned.split("/").pop();
+      if (basename3 && basename3 !== cleaned) terms.add(basename3);
+    }
+  }
+  return [...terms].filter((term) => term.length > 1).slice(0, 12);
+}
+function splitQueryTerms(query) {
+  const terms = [];
+  let term = "";
+  for (const char of query.slice(0, 2e4)) {
+    if (char === " " || char === "\n" || char === "\r" || char === "	") {
+      if (term.length > 0) terms.push(term);
+      term = "";
+      continue;
+    }
+    term += char;
+    if (term.length > 512) {
+      terms.push(term);
+      term = "";
+    }
+  }
+  if (term.length > 0) terms.push(term);
+  return terms;
+}
+function trimStructuredQueryTerm(raw) {
+  const leading = /* @__PURE__ */ new Set(["`", "'", '"', "(", "[", "{"]);
+  const trailing = /* @__PURE__ */ new Set(["`", "'", '"', ",", ".", "?", "!", ":", ";", ")", "]", "}"]);
+  let start = 0;
+  let end = raw.length;
+  while (start < end && leading.has(raw[start])) start += 1;
+  while (end > start && trailing.has(raw[end - 1])) end -= 1;
+  return raw.slice(start, end);
+}
+function hasStructuredFileExtension(value) {
+  const slash = value.lastIndexOf("/");
+  const basename3 = value.slice(slash + 1);
+  const dot = basename3.lastIndexOf(".");
+  if (dot <= 0 || dot === basename3.length - 1) return false;
+  const ext = basename3.slice(dot + 1);
+  if (ext.length < 1 || ext.length > 12) return false;
+  for (const char of ext) {
+    const code = char.charCodeAt(0);
+    const valid = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "_" || char === "+" || char === "-";
+    if (!valid) return false;
+  }
+  return true;
+}
+function extractStructuredToolTerms(query) {
+  const lower = query.toLowerCase();
+  if (!/\b(tool|command|invocation|called|used|ran|read|write|patch|edit|grep|search)\b/.test(lower)) {
+    return [];
+  }
+  return query.replace(/[^\w.-]/g, " ").split(/\s+/).filter((term) => term.length > 2 && !STOPWORDS.has(term.toLowerCase())).slice(0, 8);
+}
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function asNullableString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
 function sanitizeFtsQuery(raw) {
   const words = raw.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1 && !STOPWORDS.has(w.toLowerCase()));
   if (words.length === 0) {
@@ -27045,7 +27645,9 @@ function extractLcmConfig(cfg) {
     maxDepth: cfg.lcmMaxDepth ?? 5,
     deterministicMaxTokens: cfg.lcmDeterministicMaxTokens ?? 512,
     archiveRetentionDays: cfg.lcmArchiveRetentionDays ?? 90,
-    recallBudgetShare: cfg.lcmRecallBudgetShare ?? 0.15
+    recallBudgetShare: cfg.lcmRecallBudgetShare ?? 0.15,
+    messagePartsEnabled: cfg.messagePartsEnabled === true,
+    messagePartsRecallMaxResults: typeof cfg.messagePartsRecallMaxResults === "number" ? Math.max(0, Math.floor(cfg.messagePartsRecallMaxResults)) : 6
   };
 }
 var LcmEngine = class {
@@ -27177,9 +27779,14 @@ var LcmEngine = class {
     const newMessages = messages.map((m, i) => ({
       turnIndex: currentMax + 1 + i,
       role: m.role,
-      content: m.content
+      content: m.content,
+      parts: this.config.messagePartsEnabled ? m.parts : void 0,
+      rawContent: this.config.messagePartsEnabled ? m.rawContent : void 0,
+      sourceFormat: this.config.messagePartsEnabled ? m.sourceFormat : void 0
     }));
-    this.archive.appendMessages(sessionId, newMessages);
+    this.archive.appendMessages(sessionId, newMessages, {
+      messagePartsEnabled: this.config.messagePartsEnabled
+    });
     try {
       await this.summarizer.summarizeIncremental(sessionId);
     } catch (err) {
@@ -27257,6 +27864,28 @@ var LcmEngine = class {
       budgetChars: effectiveBudget
     });
   }
+  async searchStructuredParts(sessionId, query, limit = this.config.messagePartsRecallMaxResults) {
+    if (!this.config.enabled || !this.config.messagePartsEnabled) return [];
+    await this.ensureInitialized();
+    if (!this.archive) return [];
+    return this.archive.searchStructuredParts(query, limit, sessionId);
+  }
+  formatStructuredRecall(matches, budgetChars) {
+    if (matches.length === 0 || budgetChars <= 0) return "";
+    const lines = [];
+    let used = "## Structured Session Matches\n\n".length;
+    for (const match of matches) {
+      const label = match.file_path ? `${match.kind} ${match.file_path}` : match.tool_name ? `${match.kind} ${match.tool_name}` : match.kind;
+      const excerpt = match.content.replace(/\s+/g, " ").slice(0, 220);
+      const line = `- turn ${match.turn_index} (${match.role}): ${label} \u2014 ${excerpt}`;
+      if (used + line.length + 1 > budgetChars) break;
+      lines.push(line);
+      used += line.length + 1;
+    }
+    return lines.length > 0 ? `## Structured Session Matches
+
+${lines.join("\n")}` : "";
+  }
   /** Flush pending summaries before compaction (called from before_compaction hook). */
   async preCompactionFlush(sessionId) {
     if (!this.config.enabled) return;
@@ -32443,7 +33072,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 +33374,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 +34032,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,
@@ -35498,6 +36126,7 @@ ${r.snippet.trim()}
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
       let xrayRecalledResults = [];
+      const lcmStructuredXrayResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
         hot_embedding: 0,
@@ -37421,6 +38050,32 @@ ${tmtNode.summary}`
       }
       if (this.lcmEngine?.enabled && recallMode !== "minimal" && recallMode !== "no_recall") {
         try {
+          const structuredMatches = await this.lcmEngine.searchStructuredParts(
+            sessionKey ?? "default",
+            retrievalQuery
+          );
+          const structuredSection = this.lcmEngine.formatStructuredRecall(
+            structuredMatches,
+            Math.ceil(this.config.recallBudgetChars * 0.08)
+          );
+          if (structuredSection) {
+            const structuredAppended = this.appendRecallSection(
+              sectionBuckets,
+              "lcm-message-parts",
+              structuredSection
+            );
+            if (structuredAppended) {
+              for (const match of structuredMatches) {
+                lcmStructuredXrayResults.push({
+                  memoryId: `lcm-message-part-${match.part_id}`,
+                  path: `lcm://${match.session_id}/turn/${match.turn_index}/part/${match.part_id}`,
+                  servedBy: match.file_path ? "lcm-file-parts" : "lcm-tool-parts",
+                  scoreDecomposition: { final: match.score },
+                  admittedBy: ["lcm-message-parts"]
+                });
+              }
+            }
+          }
           const lcmSection = await this.lcmEngine.assembleRecall(
             sessionKey ?? "default",
             this.config.recallBudgetChars
@@ -38321,10 +38976,17 @@ _Context: ${topQuestion.context}_`
               admitted: recalledMemoryIds.length
             }
           ];
+          if (lcmStructuredXrayResults.length > 0) {
+            filters.push({
+              name: "lcm-message-parts",
+              considered: lcmStructuredXrayResults.length,
+              admitted: lcmStructuredXrayResults.length
+            });
+          }
           this.lastXraySnapshot = buildXraySnapshot({
             query: retrievalQuery,
             tierExplain: null,
-            results,
+            results: [...results, ...lcmStructuredXrayResults],
             filters,
             budget: {
               chars: this.getRecallBudgetChars(options.budgetCharsOverride),
@@ -38491,13 +39153,28 @@ _Context: ${topQuestion.context}_`
         role: turn.role,
         content: turn.content,
         timestamp: turn.timestamp,
-        sessionKey: key
+        sessionKey: key,
+        parts: turn.parts,
+        rawContent: turn.rawContent,
+        sourceFormat: turn.sourceFormat
       });
       bySession.set(key, list);
     }
     const replayTasks = [];
     for (const [key, sessionTurns] of bySession.entries()) {
       if (sessionTurns.length === 0) continue;
+      if (options.archiveLcm !== false && this.lcmEngine?.enabled) {
+        await this.lcmEngine.observeMessages(
+          key,
+          sessionTurns.map((turn) => ({
+            role: turn.role,
+            content: turn.content,
+            parts: turn.parts,
+            rawContent: turn.rawContent,
+            sourceFormat: turn.sourceFormat
+          }))
+        );
+      }
       replayTasks.push(
         new Promise((resolve2, reject) => {
           void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
@@ -38586,10 +39263,25 @@ _Context: ${topQuestion.context}_`
         role: turn.role,
         content: turn.content,
         timestamp: turn.timestamp,
-        sessionKey
+        sessionKey,
+        parts: turn.parts,
+        rawContent: turn.rawContent,
+        sourceFormat: turn.sourceFormat
       });
     }
     if (sessionTurns.length === 0) return;
+    if (this.lcmEngine?.enabled) {
+      await this.lcmEngine.observeMessages(
+        sessionKey,
+        sessionTurns.map((turn) => ({
+          role: turn.role,
+          content: turn.content,
+          parts: turn.parts,
+          rawContent: turn.rawContent,
+          sourceFormat: turn.sourceFormat
+        }))
+      );
+    }
     await new Promise((resolve2, reject) => {
       void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
         skipDedupeCheck: true,
@@ -43118,13 +43810,13 @@ function toolJsonResult(value, options) {
 function workLayerTextResult(text, options) {
   return toolResult2(wrapWorkLayerContext(text, { linkToMemory: options?.linkToMemory === true }));
 }
-function asNonEmptyString(value) {
+function asNonEmptyString2(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function normalizeToolNamespace(value) {
-  return asNonEmptyString(value);
+  return asNonEmptyString2(value);
 }
 function clampUnitInterval(value, fallback) {
   if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
@@ -43173,17 +43865,17 @@ var WORK_TASK_STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress", "blocke
 var WORK_TASK_PRIORITIES = /* @__PURE__ */ new Set(["low", "medium", "high"]);
 var WORK_PROJECT_STATUSES = /* @__PURE__ */ new Set(["active", "on_hold", "completed", "archived"]);
 function asTaskStatus(value) {
-  const normalized = asNonEmptyString(value);
+  const normalized = asNonEmptyString2(value);
   if (!normalized || !WORK_TASK_STATUSES.has(normalized)) return void 0;
   return normalized;
 }
 function asTaskPriority(value) {
-  const normalized = asNonEmptyString(value);
+  const normalized = asNonEmptyString2(value);
   if (!normalized || !WORK_TASK_PRIORITIES.has(normalized)) return void 0;
   return normalized;
 }
 function asProjectStatus(value) {
-  const normalized = asNonEmptyString(value);
+  const normalized = asNonEmptyString2(value);
   if (!normalized || !WORK_PROJECT_STATUSES.has(normalized)) return void 0;
   return normalized;
 }
@@ -43323,7 +44015,7 @@ function registerTools(api, orchestrator) {
     return createHash10("sha256").update(input).digest("hex").slice(0, 16);
   }
   function normalizeMemoryCategory(value, fallback) {
-    const normalized = asNonEmptyString(value);
+    const normalized = asNonEmptyString2(value);
     if (!normalized) return fallback;
     if (!VALID_MEMORY_CATEGORIES.has(normalized)) return void 0;
     return normalized;
@@ -43332,8 +44024,8 @@ function registerTools(api, orchestrator) {
     return typeof value === "string" && actionTypeSet.has(value);
   }
   function buildActionInputSummary(action, params) {
-    const primary = asNonEmptyString(params.memoryId) ?? asNonEmptyString(params.category) ?? asNonEmptyString(params.linkTargetId);
-    const content = asNonEmptyString(params.content);
+    const primary = asNonEmptyString2(params.memoryId) ?? asNonEmptyString2(params.category) ?? asNonEmptyString2(params.linkTargetId);
+    const content = asNonEmptyString2(params.content);
     let summary = primary ? `${action} => ${primary}` : action;
     if (content) {
       summary += ` | ${content.slice(0, 120)}`;
@@ -44218,14 +44910,14 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           return toolResult2(`Recorded context checkpoint telemetry in namespace=${ns}.`);
         }
         const validationErrors = [];
-        if (!asNonEmptyString(sessionKey)) validationErrors.push("sessionKey is required");
+        if (!asNonEmptyString2(sessionKey)) validationErrors.push("sessionKey is required");
         if (!Array.isArray(turns) || turns.length === 0) validationErrors.push("turns must be a non-empty array");
         const baseEvent = {
           action: "summarize_node",
           namespace: ns,
           actor: "tool.context_checkpoint",
           subsystem: "tools.context_checkpoint",
-          sourceSessionKey: asNonEmptyString(sessionKey),
+          sourceSessionKey: asNonEmptyString2(sessionKey),
           inputSummary: summary,
           checkpointTurnCount: Array.isArray(turns) ? turns.length : void 0,
           dryRun: dryRun === true,
@@ -44387,10 +45079,10 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           return toolResult2(`Validation failed: invalid action ${String(action)}.`);
         }
         const validationErrors = [];
-        const contentValue = asNonEmptyString(content);
-        const memoryIdValue = asNonEmptyString(memoryId);
-        const linkTargetIdValue = asNonEmptyString(linkTargetId);
-        const linkTypeValue = asNonEmptyString(linkType);
+        const contentValue = asNonEmptyString2(content);
+        const memoryIdValue = asNonEmptyString2(memoryId);
+        const linkTargetIdValue = asNonEmptyString2(linkTargetId);
+        const linkTypeValue = asNonEmptyString2(linkType);
         const structuredActionRequest = execute === true || Object.prototype.hasOwnProperty.call(params, "content") || Object.prototype.hasOwnProperty.call(params, "category") || Object.prototype.hasOwnProperty.call(params, "linkTargetId") || Object.prototype.hasOwnProperty.call(params, "linkType") || Object.prototype.hasOwnProperty.call(params, "linkStrength") || Object.prototype.hasOwnProperty.call(params, "artifactType");
         const baseEvent = {
           action,
@@ -44399,7 +45091,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           subsystem: "tools.memory_action_apply",
           reason,
           memoryId: memoryIdValue,
-          sourceSessionKey: asNonEmptyString(sessionKey),
+          sourceSessionKey: asNonEmptyString2(sessionKey),
           inputSummary: buildActionInputSummary(action, params),
           promptHash: promptHashForTelemetry(sourcePrompt)
         };
@@ -45309,16 +46001,16 @@ Best for:
               description: typeof p.description === "string" ? p.description : void 0,
               status: asTaskStatus(p.status),
               priority: asTaskPriority(p.priority),
-              owner: asNonEmptyString(p.owner),
-              assignee: asNonEmptyString(p.assignee),
-              projectId: asNonEmptyString(p.projectId),
+              owner: asNonEmptyString2(p.owner),
+              assignee: asNonEmptyString2(p.assignee),
+              projectId: asNonEmptyString2(p.projectId),
               tags: Array.isArray(p.tags) ? p.tags.filter((x) => typeof x === "string") : void 0,
-              dueAt: asNonEmptyString(p.dueAt)
+              dueAt: asNonEmptyString2(p.dueAt)
             });
             return toolJsonResult({ action, task: created });
           }
           if (action === "get") {
-            const taskId = asNonEmptyString(p.id);
+            const taskId = asNonEmptyString2(p.id);
             if (!taskId) {
               return workLayerTextResult("work_task.get requires `id`.");
             }
@@ -45328,14 +46020,14 @@ Best for:
           if (action === "list") {
             const tasks = await storage.listTasks({
               status: asTaskStatus(p.status),
-              owner: asNonEmptyString(p.owner),
-              assignee: asNonEmptyString(p.assignee),
-              projectId: asNonEmptyString(p.projectId)
+              owner: asNonEmptyString2(p.owner),
+              assignee: asNonEmptyString2(p.assignee),
+              projectId: asNonEmptyString2(p.projectId)
             });
             return toolJsonResult({ action, count: tasks.length, tasks });
           }
           if (action === "update") {
-            const taskId = asNonEmptyString(p.id);
+            const taskId = asNonEmptyString2(p.id);
             if (!taskId) {
               return workLayerTextResult("work_task.update requires `id`.");
             }
@@ -45359,8 +46051,8 @@ Best for:
             return toolJsonResult({ action, task: updated });
           }
           if (action === "transition") {
-            const taskId = asNonEmptyString(p.id);
-            const rawStatus = asNonEmptyString(p.status);
+            const taskId = asNonEmptyString2(p.id);
+            const rawStatus = asNonEmptyString2(p.status);
             if (!taskId || !rawStatus) {
               return workLayerTextResult("work_task.transition requires `id` and `status`.");
             }
@@ -45372,7 +46064,7 @@ Best for:
             return toolJsonResult({ action, task });
           }
           if (action === "delete") {
-            const taskId = asNonEmptyString(p.id);
+            const taskId = asNonEmptyString2(p.id);
             if (!taskId) {
               return workLayerTextResult("work_task.delete requires `id`.");
             }
@@ -45420,13 +46112,13 @@ Best for:
               name: p.name,
               description: typeof p.description === "string" ? p.description : void 0,
               status: asProjectStatus(p.status),
-              owner: asNonEmptyString(p.owner),
+              owner: asNonEmptyString2(p.owner),
               tags: Array.isArray(p.tags) ? p.tags.filter((x) => typeof x === "string") : void 0
             });
             return toolJsonResult({ action, project });
           }
           if (action === "get") {
-            const projectId = asNonEmptyString(p.id);
+            const projectId = asNonEmptyString2(p.id);
             if (!projectId) {
               return workLayerTextResult("work_project.get requires `id`.");
             }
@@ -45438,7 +46130,7 @@ Best for:
             return toolJsonResult({ action, count: projects.length, projects });
           }
           if (action === "update") {
-            const projectId = asNonEmptyString(p.id);
+            const projectId = asNonEmptyString2(p.id);
             if (!projectId) {
               return workLayerTextResult("work_project.update requires `id`.");
             }
@@ -45454,7 +46146,7 @@ Best for:
             return toolJsonResult({ action, project });
           }
           if (action === "delete") {
-            const projectId = asNonEmptyString(p.id);
+            const projectId = asNonEmptyString2(p.id);
             if (!projectId) {
               return workLayerTextResult("work_project.delete requires `id`.");
             }
@@ -45462,8 +46154,8 @@ Best for:
             return toolJsonResult({ action, deleted });
           }
           if (action === "link_task") {
-            const taskId = asNonEmptyString(p.taskId);
-            const projectId = asNonEmptyString(p.projectId);
+            const taskId = asNonEmptyString2(p.taskId);
+            const projectId = asNonEmptyString2(p.projectId);
             if (!taskId || !projectId) {
               return workLayerTextResult("work_project.link_task requires `taskId` and `projectId`.");
             }
@@ -45499,7 +46191,7 @@ Best for:
       async execute(_toolCallId, params) {
         const p = params;
         const action = String(p.action ?? "");
-        const projectId = asNonEmptyString(p.projectId);
+        const projectId = asNonEmptyString2(p.projectId);
         const linkToMemory = p.linkToMemory === true;
         try {
           await new WorkStorage(orchestrator.config.memoryDir).ensureDirectories();
@@ -45519,7 +46211,7 @@ Best for:
             const result = await importWorkBoardSnapshot({
               memoryDir: orchestrator.config.memoryDir,
               snapshot,
-              projectId: asNonEmptyString(p.projectId)
+              projectId: asNonEmptyString2(p.projectId)
             });
             return toolJsonResult({ action, result }, { linkToMemory });
           }
@@ -45785,7 +46477,7 @@ Returns: Performance trace data with timing breakdown`,
             "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
           );
         }
-        const format = asNonEmptyString(params.format) ?? "ascii";
+        const format = asNonEmptyString2(params.format) ?? "ascii";
         const limit = Math.min(typeof params.limit === "number" ? params.limit : 5, 20);
         const traces = profiler.getRecentTraces(limit);
         const stats = profiler.getStats();
@@ -45856,7 +46548,7 @@ Returns: Performance trace data with timing breakdown`,
             "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
           );
         }
-        const format = asNonEmptyString(params.format) ?? "ascii";
+        const format = asNonEmptyString2(params.format) ?? "ascii";
         const limit = Math.min(typeof params.limit === "number" ? params.limit : 5, 20);
         const traces = profiler.getRecentTraces(limit);
         const stats = profiler.getStats();
@@ -45905,8 +46597,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 +46712,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 +46722,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 +49744,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 +50021,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 +50072,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 +50105,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 +50262,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 +50308,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 +51560,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 +54032,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 +55648,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);
@@ -55159,10 +56006,15 @@ var EngramAccessService = class {
         sessionKey: lcmSessionKey,
         role: m.role,
         content: m.content,
+        parts: m.parts,
+        rawContent: m.rawContent,
+        sourceFormat: m.sourceFormat,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
       try {
-        const extractionPromise = this.orchestrator.ingestReplayBatch(turns);
+        const extractionPromise = this.orchestrator.ingestReplayBatch(turns, {
+          archiveLcm: false
+        });
         extractionPromise.catch((err) => {
           log.error(`access-observe background extraction failed: ${err}`);
         });
@@ -55861,22 +56713,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 +57069,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 +57314,273 @@ 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"),
+  sourceFormat: external_exports.enum(["openai", "anthropic", "openclaw", "lossless-claw", "remnic"]).nullable().optional(),
+  rawContent: external_exports.unknown().nullable().optional(),
+  parts: external_exports.array(
+    external_exports.object({
+      ordinal: external_exports.number().int().min(0).nullable().optional(),
+      kind: external_exports.enum([
+        "text",
+        "tool_call",
+        "tool_result",
+        "patch",
+        "file_read",
+        "file_write",
+        "step_start",
+        "step_finish",
+        "snapshot",
+        "retry"
+      ]),
+      payload: external_exports.record(external_exports.string(), external_exports.unknown()),
+      toolName: external_exports.string().nullable().optional(),
+      tool_name: external_exports.string().nullable().optional(),
+      filePath: external_exports.string().nullable().optional(),
+      file_path: external_exports.string().nullable().optional(),
+      createdAt: external_exports.string().nullable().optional(),
+      created_at: external_exports.string().nullable().optional()
+    })
+  ).nullable().optional()
+});
+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 +57637,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 +57841,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.",
@@ -56657,9 +58068,51 @@ var EngramMcpServer = class {
                 type: "object",
                 properties: {
                   role: { type: "string", enum: ["user", "assistant"] },
-                  content: { type: "string" }
+                  content: { type: "string" },
+                  sourceFormat: {
+                    type: "string",
+                    enum: ["openai", "anthropic", "openclaw", "lossless-claw", "remnic"]
+                  },
+                  rawContent: {
+                    description: "Optional native provider content blocks for structured message-part capture."
+                  },
+                  parts: {
+                    type: "array",
+                    description: "Optional normalized Remnic LCM message parts.",
+                    items: {
+                      type: "object",
+                      properties: {
+                        ordinal: { type: ["number", "null"], minimum: 0 },
+                        kind: {
+                          type: "string",
+                          enum: [
+                            "text",
+                            "tool_call",
+                            "tool_result",
+                            "patch",
+                            "file_read",
+                            "file_write",
+                            "step_start",
+                            "step_finish",
+                            "snapshot",
+                            "retry"
+                          ]
+                        },
+                        payload: { type: "object", additionalProperties: true },
+                        toolName: { type: ["string", "null"] },
+                        tool_name: { type: ["string", "null"] },
+                        filePath: { type: ["string", "null"] },
+                        file_path: { type: ["string", "null"] },
+                        createdAt: { type: ["string", "null"] },
+                        created_at: { type: ["string", "null"] }
+                      },
+                      required: ["kind", "payload"],
+                      additionalProperties: false
+                    }
+                  }
                 },
-                required: ["role", "content"]
+                required: ["role", "content"],
+                additionalProperties: false
               },
               description: "Conversation messages to observe"
             },
@@ -57149,6 +58602,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 +58710,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 +59005,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 +59331,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,
@@ -57885,20 +59453,21 @@ ${body}`;
           effectivePrincipal
         );
       case "engram.observe": {
-        if ("cwd" in args && args.cwd !== void 0 && args.cwd !== null && typeof args.cwd !== "string") {
-          throw new EngramAccessInputError("cwd must be a string");
-        }
-        if ("projectTag" in args && args.projectTag !== void 0 && args.projectTag !== null && typeof args.projectTag !== "string") {
-          throw new EngramAccessInputError("projectTag must be a string");
-        }
+        const body = parseMcpRequest("observe", args);
         return this.service.observe({
-          sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : "",
-          messages: Array.isArray(args.messages) ? args.messages : [],
-          namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+          sessionKey: body.sessionKey,
+          messages: body.messages.map((message) => ({
+            role: message.role,
+            content: message.content,
+            parts: message.parts ?? void 0,
+            rawContent: message.rawContent ?? void 0,
+            sourceFormat: message.sourceFormat ?? void 0
+          })),
+          namespace: body.namespace,
           authenticatedPrincipal: effectivePrincipal,
-          skipExtraction: args.skipExtraction === true,
-          cwd: typeof args.cwd === "string" ? args.cwd : void 0,
-          projectTag: typeof args.projectTag === "string" ? args.projectTag : void 0
+          skipExtraction: body.skipExtraction === true,
+          cwd: body.cwd,
+          projectTag: body.projectTag
         });
       }
       case "engram.lcm_search":
@@ -58176,6 +59745,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 +59823,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 +59999,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 +60517,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({
@@ -59198,7 +60646,13 @@ var EngramAccessHttpServer = class {
       this.ensureWriteRateLimitAvailable();
       const response = await this.service.observe({
         sessionKey: body.sessionKey,
-        messages: body.messages,
+        messages: body.messages.map((message) => ({
+          role: message.role,
+          content: message.content,
+          sourceFormat: message.sourceFormat ?? void 0,
+          rawContent: message.rawContent ?? void 0,
+          parts: message.parts ?? void 0
+        })),
         namespace: this.resolveNamespace(req, body.namespace),
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
         skipExtraction: body.skipExtraction === true,
@@ -59882,7 +61336,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 +61401,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 +61576,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 +61758,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 +61808,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 +61878,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 +62304,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 +62910,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 +62938,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 +63117,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 +63531,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 +64122,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 +64214,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 +64278,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 +64287,7 @@ async function getPluginVersion() {
 }
 async function exists3(p) {
   try {
-    await access6(p);
+    await access7(p);
     return true;
   } catch {
     return false;
@@ -62858,7 +64313,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 +64343,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 +65089,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 +65135,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 +65158,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 +65194,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 +65224,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 +65270,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 +65305,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 +65336,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 +65346,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 +65374,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 +68144,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 +68172,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 +68191,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 +68204,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 +68216,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) {
@@ -67112,7 +68590,7 @@ import crypto2 from "crypto";
 function hashSha256(value) {
   return crypto2.createHash("sha256").update(value).digest("hex");
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString2(value) {
@@ -67128,11 +68606,11 @@ function normalizedToolName(toolName) {
   return toolNameTokens(toolName).join("_");
 }
 function parseToolArguments(value) {
-  if (isRecord3(value)) return value;
+  if (isRecord4(value)) return value;
   if (typeof value !== "string") return void 0;
   try {
     const parsed = JSON.parse(value);
-    return isRecord3(parsed) ? parsed : void 0;
+    return isRecord4(parsed) ? parsed : void 0;
   } catch {
     return void 0;
   }
@@ -67142,13 +68620,13 @@ function extractTextContent(value) {
   if (Array.isArray(value)) {
     return value.map((block) => {
       if (typeof block === "string") return block.trim();
-      if (isRecord3(block) && block.type === "text" && typeof block.text === "string") {
+      if (isRecord4(block) && block.type === "text" && typeof block.text === "string") {
         return block.text.trim();
       }
       return "";
     }).filter((item) => item.length > 0).join("\n");
   }
-  if (isRecord3(value)) {
+  if (isRecord4(value)) {
     return JSON.stringify(value);
   }
   return "";
@@ -67175,10 +68653,10 @@ function getToolCallContexts(messages) {
     const toolCalls = message.tool_calls ?? message.toolCalls;
     if (!Array.isArray(toolCalls)) continue;
     for (const call of toolCalls) {
-      if (!isRecord3(call)) continue;
+      if (!isRecord4(call)) continue;
       const toolCallId = optionalString2(call.id) ?? optionalString2(call.toolCallId);
       if (!toolCallId) continue;
-      const fn = isRecord3(call.function) ? call.function : void 0;
+      const fn = isRecord4(call.function) ? call.function : void 0;
       const toolName = optionalString2(fn?.name) ?? optionalString2(call.name);
       const args = parseToolArguments(fn?.arguments) ?? parseToolArguments(call.arguments) ?? parseToolArguments(call.args) ?? parseToolArguments(call.input);
       contexts.set(toolCallId, { toolCallId, toolName, args });
@@ -67221,7 +68699,7 @@ function fileContentHash(args) {
 }
 function inferOutcome(message, parsedPayload) {
   if (message.isError === true) return "failure";
-  if (isRecord3(parsedPayload)) {
+  if (isRecord4(parsedPayload)) {
     if (parsedPayload.partial === true || parsedPayload.status === "partial") return "partial";
     if (parsedPayload.success === false || parsedPayload.ok === false) return "failure";
     if (parsedPayload.success === true || parsedPayload.ok === true) return "success";
@@ -67425,13 +68903,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 +69230,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 +69277,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 +69310,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 +69321,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 +69345,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 +69385,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 +69636,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 +70421,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 +70436,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 +70919,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 +71087,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 +71100,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 +71196,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 +71213,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 +71362,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 +73040,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;
@@ -71813,7 +73291,12 @@ Keep the reflection grounded in the evidence below.
                 const lcmMessages = lastTurn.map((msg) => {
                   const rawRole = typeof msg.role === "string" ? msg.role : "";
                   const content = extractTextContent2(msg);
-                  return { role: rawRole, content };
+                  return {
+                    role: rawRole,
+                    content,
+                    rawContent: msg,
+                    sourceFormat: "openclaw"
+                  };
                 }).filter((m) => m.content.length > 0);
                 if (lcmMessages.length > 0) {
                   orchestrator.lcmEngine.enqueueObserveMessages(
@@ -72218,7 +73701,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 {
         }