@remnic/core 1.1.4 → 1.1.5

package/dist/{chunk-NZS2BLTP.js → chunk-7NFZWXAY.js}

@@ -2,7 +2,7 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-XQ4EJLUD.js";
+} from "./chunk-Z665HFAD.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
@@ -142,7 +142,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-52PDY6GD.js";
+} from "./chunk-FLHPNR5W.js";
 import {
   buildCompressionGuidelinesMarkdown,
   computeCompressionGuidelineCandidate,
@@ -152,16 +152,16 @@ import {
 import {
   RoutingRulesStore,
   normalizeReplaySessionKey
-} from "./chunk-VTJVUHRK.js";
+} from "./chunk-SRBJUAMP.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-EGEPUGN4.js";
+} from "./chunk-5XVDDCMH.js";
 import {
   ThreadingManager
 } from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-W7WWT4FJ.js";
+} from "./chunk-HPJPGIGN.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
@@ -181,7 +181,7 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-V7TEH5I2.js";
+} from "./chunk-TMPLRVHD.js";
 import {
   parseQmdExplain
 } from "./chunk-WSZIHQBK.js";
@@ -228,7 +228,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-AGZHRWPT.js";
+} from "./chunk-ERWKQVCX.js";
 import {
   FallbackLlmClient
 } from "./chunk-CRU27Q4J.js";
@@ -263,7 +263,7 @@ import {
 } from "./chunk-EQINRHYR.js";
 import {
   buildXraySnapshot
-} from "./chunk-USFPPRAF.js";
+} from "./chunk-WMK6YP7C.js";
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-3FPTCC3Z.js";
@@ -303,7 +303,7 @@ import {
   normalizeAttributePairs,
   normalizeEntityName,
   parseEntityFile
-} from "./chunk-Y4A6M3B6.js";
+} from "./chunk-46AIFPQM.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -311,7 +311,7 @@ import {
 } from "./chunk-4KAN3GZ3.js";
 import {
   confidenceTier
-} from "./chunk-43EKP2UK.js";
+} from "./chunk-TOC3VOOF.js";
 import {
   isActiveMemoryStatus
 } from "./chunk-RULE4VG5.js";
@@ -1613,7 +1613,7 @@ function getTaxonomyFilePath(memoryDir) {
 // src/lcm/schema.ts
 import path4 from "path";
 import { mkdir as mkdir4 } from "fs/promises";
-var LCM_SCHEMA_VERSION = 1;
+var LCM_SCHEMA_VERSION = 2;
 function openLcmDatabase(memoryDir) {
   const dbPath = path4.join(memoryDir, "state", "lcm.sqlite");
   const db = openBetterSqlite3(dbPath);
@@ -1662,6 +1662,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,
@@ -1714,6 +1731,423 @@ function createTables(db) {
   );
 }
 
+// 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) => isRecord(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 (!isRecord(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(isRecord);
+  if (!isRecord(input)) return [];
+  if (Array.isArray(input.output)) return input.output.filter(isRecord);
+  if (Array.isArray(input.items)) return input.items.filter(isRecord);
+  return [input];
+}
+function gatherContentBlocks(input) {
+  if (Array.isArray(input)) return input.filter(isRecord);
+  if (typeof input === "string") return [{ type: "text", text: input }];
+  if (isRecord(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 isRecord(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 (!isRecord(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 (isRecord(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 basename = value.slice(lastSlash + 1);
+  const dot = basename.lastIndexOf(".");
+  if (dot <= 0 || dot === basename.length - 1) return false;
+  const ext = basename.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);
+}
+
 // src/lcm/archive.ts
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -1724,7 +2158,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 = estimateTokens(content);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const metaJson = metadata ? JSON.stringify(metadata) : null;
@@ -1735,18 +2169,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);
@@ -1868,6 +2342,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);
@@ -2019,6 +2542,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 basename = cleaned.split("/").pop();
+      if (basename && basename !== cleaned) terms.add(basename);
+    }
+  }
+  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 basename = value.slice(slash + 1);
+  const dot = basename.lastIndexOf(".");
+  if (dot <= 0 || dot === basename.length - 1) return false;
+  const ext = basename.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) {
@@ -2488,7 +3077,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 {
@@ -2620,9 +3211,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) {
@@ -2700,6 +3296,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;
@@ -4933,7 +5551,7 @@ ${doc.content}` : doc.content,
   }
   async runDeepSleepGovernanceNow(options) {
     const targetStorage = options?.storage ?? this.storage;
-    const { runMemoryGovernance } = await import("./memory-governance-JZHZDOLN.js");
+    const { runMemoryGovernance } = await import("./memory-governance-KXMAURFF.js");
     const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-LR2NBAZE.js");
     const govResult = await runMemoryGovernance({
       memoryDir: targetStorage.dir,
@@ -7027,6 +7645,7 @@ ${r.snippet.trim()}
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
       let xrayRecalledResults = [];
+      const lcmStructuredXrayResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
         hot_embedding: 0,
@@ -8950,6 +9569,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
@@ -9850,10 +10495,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),
@@ -10020,13 +10672,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((resolve, reject) => {
           void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
@@ -10115,10 +10782,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((resolve, reject) => {
       void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
         skipDedupeCheck: true,
@@ -14040,6 +14722,13 @@ export {
   openLcmDatabase,
   ensureLcmStateDir,
   applyLcmSchema,
+  isLcmMessagePartKind,
+  parseMessageParts,
+  normalizeExplicitParts,
+  parseOpenAiMessageParts,
+  parseAnthropicMessageParts,
+  parseOpenClawMessageParts,
+  partsFromRenderedText,
   projectNamespaceName,
   branchNamespaceName,
   resolveCodingNamespaceOverlay,
@@ -14072,4 +14761,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-NZS2BLTP.js.map
+//# sourceMappingURL=chunk-7NFZWXAY.js.map