@remnic/plugin-openclaw 1.0.12 → 1.0.13

package/dist/index.js

@@ -1906,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: (() => {
@@ -19349,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);
@@ -26180,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);
@@ -26226,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,
@@ -26278,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);
@@ -26288,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;
@@ -26299,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);
@@ -26432,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);
@@ -26583,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) {
@@ -27052,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 {
@@ -27184,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) {
@@ -27264,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;
@@ -35504,6 +36126,7 @@ ${r.snippet.trim()}
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
       let xrayRecalledResults = [];
+      const lcmStructuredXrayResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
         hot_embedding: 0,
@@ -37427,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
@@ -38327,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),
@@ -38497,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", {
@@ -38592,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,
@@ -43124,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;
@@ -43179,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;
 }
@@ -43329,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;
@@ -43338,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)}`;
@@ -44224,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,
@@ -44393,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,
@@ -44405,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)
         };
@@ -45315,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`.");
             }
@@ -45334,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`.");
             }
@@ -45365,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`.");
             }
@@ -45378,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`.");
             }
@@ -45426,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`.");
             }
@@ -45444,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`.");
             }
@@ -45460,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`.");
             }
@@ -45468,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`.");
             }
@@ -45505,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();
@@ -45525,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 });
           }
@@ -45791,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();
@@ -45862,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();
@@ -55320,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}`);
         });
@@ -56705,7 +57396,33 @@ var setCodingContextRequestSchema = external_exports.object({
 });
 var messageSchema = external_exports.object({
   role: external_exports.enum(["user", "assistant"]),
-  content: external_exports.string().min(1, "message content must be non-empty")
+  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),
@@ -57351,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"
             },
@@ -58694,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":
@@ -59886,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,
@@ -67824,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) {
@@ -67840,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;
   }
@@ -67854,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 "";
@@ -67887,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 });
@@ -67933,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";
@@ -72525,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(

package/openclaw.plugin.json

@@ -4260,6 +4260,16 @@
         "default": 90,
         "description": "Days to retain archived LCM summaries"
       },
+      "messagePartsEnabled": {
+        "type": "boolean",
+        "default": false,
+        "description": "Opt in to structured LCM message-part capture for tool calls, file references, patches, and reasoning markers."
+      },
+      "messagePartsRecallMaxResults": {
+        "type": "number",
+        "default": 6,
+        "description": "Maximum structured message-part matches to inject into recall when messagePartsEnabled is true."
+      },
       "ircEnabled": {
         "type": "boolean",
         "default": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/plugin-openclaw",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "OpenClaw adapter for Remnic memory — thin wrapper delegating to @remnic/core",
   "type": "module",
   "main": "dist/index.js",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "openai": "^6.0.0",
-    "@remnic/core": "^1.1.4"
+    "@remnic/core": "^1.1.5"
   },
   "peerDependencies": {
     "openclaw": ">=2026.4.8"