@remnic/plugin-openclaw 1.0.12 → 1.0.14

package/dist/index.js

@@ -601,6 +601,9 @@ var MEMORY_OS_PRESETS = {
     contextCompressionActionsEnabled: true,
     compressionGuidelineLearningEnabled: true,
     compressionGuidelineSemanticRefinementEnabled: true,
+    explicitCueRecallEnabled: true,
+    explicitCueRecallMaxChars: 3200,
+    lcmEnabled: true,
     maxProactiveQuestionsPerExtraction: 4,
     maxCompressionTokensPerHour: 3e3,
     behaviorLoopAutoTuneEnabled: true
@@ -1897,6 +1900,9 @@ function parseConfig(raw) {
     temporalMemoryTreeEnabled: cfg.temporalMemoryTreeEnabled === true,
     tmtHourlyMinMemories: typeof cfg.tmtHourlyMinMemories === "number" ? cfg.tmtHourlyMinMemories : 3,
     tmtSummaryMaxTokens: typeof cfg.tmtSummaryMaxTokens === "number" ? cfg.tmtSummaryMaxTokens : 300,
+    explicitCueRecallEnabled: coerceBool(cfg.explicitCueRecallEnabled) === true,
+    explicitCueRecallMaxChars: coerceNumber(cfg.explicitCueRecallMaxChars) !== void 0 ? Math.max(0, Math.floor(coerceNumber(cfg.explicitCueRecallMaxChars))) : 2400,
+    explicitCueRecallMaxReferences: coerceNumber(cfg.explicitCueRecallMaxReferences) !== void 0 ? Math.max(0, Math.floor(coerceNumber(cfg.explicitCueRecallMaxReferences))) : 24,
     // Lossless Context Management (LCM)
     lcmEnabled: cfg.lcmEnabled === true,
     lcmLeafBatchSize: typeof cfg.lcmLeafBatchSize === "number" ? Math.max(2, Math.floor(cfg.lcmLeafBatchSize)) : 8,
@@ -1906,6 +1912,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: (() => {
@@ -2252,6 +2260,12 @@ function buildDefaultRecallPipeline(cfg) {
       enabled: cfg.sharedContextEnabled === true,
       maxChars: typeof cfg.sharedContextMaxInjectChars === "number" ? Math.max(0, Math.floor(cfg.sharedContextMaxInjectChars)) : 4e3
     },
+    {
+      id: "explicit-cue",
+      enabled: coerceBool(cfg.explicitCueRecallEnabled) === true,
+      maxChars: coerceNumber(cfg.explicitCueRecallMaxChars) !== void 0 ? Math.max(0, Math.floor(coerceNumber(cfg.explicitCueRecallMaxChars))) : 2400,
+      maxResults: coerceNumber(cfg.explicitCueRecallMaxReferences) !== void 0 ? Math.max(0, Math.floor(coerceNumber(cfg.explicitCueRecallMaxReferences))) : 24
+    },
     {
       id: "profile",
       enabled: true,
@@ -19349,7 +19363,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);
@@ -23083,6 +23099,630 @@ async function readRecentEntityTranscriptEntries(transcriptEntriesPromise, recen
 }
 var entityRecentTranscriptLookbackHours = RECENT_TRANSCRIPT_LOOKBACK_HOURS;
 
+// ../remnic-core/src/evidence-pack.ts
+var DEFAULT_MAX_ITEM_CHARS = 1200;
+function buildEvidencePack(items, options) {
+  const budget = normalizePositiveInteger(options.maxChars);
+  if (budget <= 0 || items.length === 0) {
+    return "";
+  }
+  const maxItemChars = normalizePositiveInteger(
+    options.maxItemChars ?? DEFAULT_MAX_ITEM_CHARS
+  );
+  if (maxItemChars <= 0) {
+    return "";
+  }
+  const title = options.title ?? "Evidence";
+  const lines = [`## ${title}`];
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenContent = /* @__PURE__ */ new Set();
+  let used = lines[0].length;
+  for (const item of items) {
+    const content = item.content.trim();
+    if (!content) continue;
+    const id = item.id ?? evidenceItemFallbackId(item);
+    if (id && seenIds.has(id)) continue;
+    const contentKey = normalizeEvidenceContent(content);
+    if (seenContent.has(contentKey)) continue;
+    const label = formatEvidenceLabel(item);
+    const clipped = clipText(content, maxItemChars);
+    const block = `${label}: ${clipped}`;
+    const separatorLength = lines.length > 0 ? 2 : 0;
+    const remaining = budget - used - separatorLength;
+    if (remaining <= 0) break;
+    const finalBlock = block.length > remaining ? clipText(block, remaining) : block;
+    if (!finalBlock.trim()) break;
+    lines.push(finalBlock);
+    used += separatorLength + finalBlock.length;
+    if (id) seenIds.add(id);
+    seenContent.add(contentKey);
+  }
+  return lines.length === 1 ? "" : lines.join("\n\n");
+}
+function normalizePositiveInteger(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return Math.floor(value);
+}
+function evidenceItemFallbackId(item) {
+  if (item.sessionId && typeof item.turnIndex === "number") {
+    return `${item.sessionId}:${item.turnIndex}`;
+  }
+  return void 0;
+}
+function normalizeEvidenceContent(content) {
+  return content.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function formatEvidenceLabel(item) {
+  const parts = [];
+  if (item.sessionId) parts.push(item.sessionId);
+  if (typeof item.turnIndex === "number") parts.push(`turn ${item.turnIndex}`);
+  if (item.role) parts.push(item.role);
+  if (typeof item.score === "number" && Number.isFinite(item.score)) {
+    parts.push(`score ${item.score.toFixed(3)}`);
+  }
+  return parts.length > 0 ? `[${parts.join(", ")}]` : "[evidence]";
+}
+function clipText(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  if (maxChars <= 1) {
+    return text.slice(0, maxChars);
+  }
+  if (maxChars <= 3) {
+    return text.slice(0, maxChars);
+  }
+  return `${text.slice(0, maxChars - 3).trimEnd()}...`;
+}
+
+// ../remnic-core/src/explicit-cue-recall.ts
+var DEFAULT_MAX_CHARS = 2400;
+var DEFAULT_MAX_ITEM_CHARS2 = 1200;
+var DEFAULT_MAX_REFERENCES = 24;
+var REFERENCE_SCAN_TOKEN_FACTOR = 3;
+var TURN_REFERENCE_WINDOW_RADIUS = 0;
+var LEXICAL_CUE_WINDOW_RADIUS = 1;
+var LEXICAL_CUE_SEARCH_LIMIT = 3;
+var LEXICAL_CUE_MAX_TOKENS = 400;
+var LATEST_STATE_CUES = /* @__PURE__ */ new Set([
+  "as of",
+  "currently",
+  "latest",
+  "most recent",
+  "newest",
+  "now",
+  "updated",
+  "changed",
+  "change"
+]);
+var RELATIVE_TEMPORAL_CUES = [
+  "as of",
+  "most recent",
+  "last time",
+  "last week",
+  "last month",
+  "last year",
+  "last session",
+  "last conversation",
+  "next time",
+  "next week",
+  "next month",
+  "next year",
+  "next session",
+  "next conversation",
+  "previous time",
+  "previous week",
+  "previous month",
+  "previous year",
+  "previous session",
+  "previous conversation",
+  "prior time",
+  "prior week",
+  "prior month",
+  "prior year",
+  "prior session",
+  "prior conversation",
+  "today",
+  "yesterday",
+  "tomorrow",
+  "tonight",
+  "earlier",
+  "later",
+  "recently",
+  "previously",
+  "currently",
+  "now",
+  "latest",
+  "newest",
+  "oldest",
+  "earliest",
+  "before",
+  "after",
+  "since",
+  "updated",
+  "changed",
+  "change"
+];
+var SPEAKER_NAME_STOPWORDS = /* @__PURE__ */ new Set([
+  "A",
+  "According",
+  "An",
+  "And",
+  "Are",
+  "As",
+  "At",
+  "Before",
+  "Can",
+  "Compare",
+  "Could",
+  "Did",
+  "Do",
+  "Does",
+  "For",
+  "From",
+  "Had",
+  "Has",
+  "Have",
+  "How",
+  "In",
+  "Is",
+  "It",
+  "Of",
+  "On",
+  "Or",
+  "Please",
+  "Review",
+  "Step",
+  "Tell",
+  "The",
+  "To",
+  "Turn",
+  "Use",
+  "Was",
+  "Were",
+  "What",
+  "When",
+  "Where",
+  "Which",
+  "Who",
+  "Why",
+  "Will",
+  "Would"
+]);
+var QUESTION_SLOT_STOPWORDS = /* @__PURE__ */ new Set([
+  "answer",
+  "choice",
+  "did",
+  "does",
+  "do",
+  "is",
+  "should",
+  "single",
+  "the",
+  "user",
+  "was",
+  "were"
+]);
+async function buildExplicitCueRecallSection(options) {
+  const engine = options.engine;
+  const query = options.query.trim();
+  const maxChars = normalizePositiveInteger2(options.maxChars, DEFAULT_MAX_CHARS);
+  if (!engine || query.length === 0 || maxChars <= 0) {
+    return "";
+  }
+  const maxReferences = normalizePositiveInteger2(
+    options.maxReferences,
+    DEFAULT_MAX_REFERENCES
+  );
+  if (maxReferences <= 0) {
+    return "";
+  }
+  const evidenceItems = [];
+  const seenTurns = /* @__PURE__ */ new Set();
+  await collectTurnReferenceEvidence({
+    engine,
+    sessionId: options.sessionId,
+    query,
+    maxReferences,
+    evidenceItems,
+    seenTurns
+  });
+  await collectLexicalCueEvidence({
+    engine,
+    sessionId: options.sessionId,
+    query,
+    maxReferences,
+    evidenceItems,
+    seenTurns
+  });
+  return buildEvidencePack(evidenceItems, {
+    title: "Explicit Cue Evidence",
+    maxChars,
+    maxItemChars: normalizePositiveInteger2(
+      options.maxItemChars,
+      DEFAULT_MAX_ITEM_CHARS2
+    )
+  });
+}
+async function collectTurnReferenceEvidence(options) {
+  if (!options.sessionId) {
+    return;
+  }
+  const references = collectExplicitTurnReferences(options.query).slice(
+    0,
+    options.maxReferences
+  );
+  if (references.length === 0) {
+    return;
+  }
+  const windows = /* @__PURE__ */ new Map();
+  for (const reference of references) {
+    for (const center of candidateTurnIndexesForReference(reference)) {
+      if (center < 0) {
+        continue;
+      }
+      const fromTurn = Math.max(0, center - TURN_REFERENCE_WINDOW_RADIUS);
+      const toTurn = center + TURN_REFERENCE_WINDOW_RADIUS;
+      windows.set(`${fromTurn}:${toTurn}`, { fromTurn, toTurn });
+    }
+  }
+  for (const window of [...windows.values()].sort(
+    (left, right) => left.fromTurn - right.fromTurn || left.toTurn - right.toTurn
+  )) {
+    const expanded = await options.engine.expandContext(
+      options.sessionId,
+      window.fromTurn,
+      window.toTurn,
+      2e3
+    );
+    appendExpandedEvidence(
+      options.evidenceItems,
+      options.seenTurns,
+      options.sessionId,
+      expanded
+    );
+  }
+}
+async function collectLexicalCueEvidence(options) {
+  const cues = collectLexicalCues(options.query).slice(0, options.maxReferences);
+  const preferLatest = hasLatestStateIntent(options.query);
+  for (const cue of cues) {
+    const results = sortLexicalCueResults(
+      await options.engine.searchContextFull(
+        cue,
+        LEXICAL_CUE_SEARCH_LIMIT,
+        options.sessionId
+      ),
+      preferLatest
+    );
+    for (const result of results) {
+      const windowRadius = preferLatest ? 0 : LEXICAL_CUE_WINDOW_RADIUS;
+      const fromTurn = Math.max(0, result.turn_index - windowRadius);
+      const toTurn = result.turn_index + windowRadius;
+      const expanded = await options.engine.expandContext(
+        result.session_id,
+        fromTurn,
+        toTurn,
+        LEXICAL_CUE_MAX_TOKENS
+      );
+      if (expanded.length === 0) {
+        appendEvidenceItem(options.evidenceItems, options.seenTurns, {
+          id: `${result.session_id}:${result.turn_index}`,
+          sessionId: result.session_id,
+          turnIndex: result.turn_index,
+          role: result.role,
+          content: result.content,
+          ...typeof result.score === "number" ? { score: result.score } : {}
+        });
+        continue;
+      }
+      appendExpandedEvidence(
+        options.evidenceItems,
+        options.seenTurns,
+        result.session_id,
+        expanded
+      );
+    }
+  }
+}
+function appendExpandedEvidence(evidenceItems, seenTurns, sessionId, expanded) {
+  for (const message of expanded) {
+    appendEvidenceItem(evidenceItems, seenTurns, {
+      id: `${sessionId}:${message.turn_index}`,
+      sessionId,
+      turnIndex: message.turn_index,
+      role: message.role,
+      content: message.content
+    });
+  }
+}
+function appendEvidenceItem(evidenceItems, seenTurns, item) {
+  if (seenTurns.has(item.id)) {
+    return;
+  }
+  seenTurns.add(item.id);
+  evidenceItems.push(item);
+}
+function collectExplicitTurnReferences(query) {
+  const references = /* @__PURE__ */ new Map();
+  const addReference = (value, label) => {
+    const existing = references.get(String(value));
+    references.set(String(value), {
+      number: value,
+      includeDirectTurn: (existing?.includeDirectTurn ?? false) || label === "turn"
+    });
+  };
+  const tokens = tokenizeReferenceQuery(query);
+  for (let index = 0; index < tokens.length; index += 1) {
+    const label = normalizeReferenceLabel(tokens[index]);
+    if (!label) {
+      continue;
+    }
+    const parsed = parseReferenceNumbers(tokens, index + 1);
+    for (const number of parsed.numbers) {
+      addReference(number, label);
+    }
+    index = Math.max(index, parsed.nextIndex - 1);
+  }
+  return [...references.values()].sort((left, right) => left.number - right.number);
+}
+function collectLexicalCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(/\b[A-Za-z][A-Za-z0-9]{0,12}\d+:\d+\b/g)) {
+    cues.add(match[0]);
+  }
+  for (const match of query.matchAll(/\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2})?Z?)?\b/g)) {
+    cues.add(match[0]);
+  }
+  for (const cue of collectTemporalLexicalCues(query)) {
+    cues.add(cue);
+  }
+  for (const cue of collectQuestionSlotCues(query)) {
+    cues.add(cue);
+  }
+  for (const match of query.matchAll(/\b(?:session|source|chat|plan|task|event|file|tool)[_-][A-Za-z0-9][A-Za-z0-9_.:-]{0,80}\b/gi)) {
+    cues.add(match[0]);
+  }
+  for (const match of query.matchAll(/\b[A-Z][a-z]{1,30}(?:\s+[A-Z][a-z]{1,30}){0,2}\b/g)) {
+    const value = normalizeSpeakerNameCue(match[0]);
+    if (value) {
+      cues.add(value);
+    }
+  }
+  for (const match of query.matchAll(/\[([A-Za-z0-9][A-Za-z0-9_.:/ -]{1,80})\]/g)) {
+    const value = match[1]?.trim();
+    if (value) {
+      cues.add(value);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function collectQuestionSlotCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(
+    /\b(?:what|which)\s+([a-z][a-z0-9_-]{2,30})\s+(?:does|do|did|is|are|was|were|should|would|could|can|will)\b/gi
+  )) {
+    const value = match[1]?.toLowerCase();
+    if (value && !QUESTION_SLOT_STOPWORDS.has(value)) {
+      cues.add(value);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function collectTemporalLexicalCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const cue of RELATIVE_TEMPORAL_CUES) {
+    let searchFrom = 0;
+    while (searchFrom < normalizedQuery.length) {
+      const index = normalizedQuery.indexOf(cue, searchFrom);
+      if (index < 0) {
+        break;
+      }
+      const afterIndex = index + cue.length;
+      if (isTemporalCueBoundary(normalizedQuery[index - 1]) && isTemporalCueBoundary(normalizedQuery[afterIndex])) {
+        cues.add(cue);
+        break;
+      }
+      searchFrom = afterIndex;
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function hasLatestStateIntent(query) {
+  return collectTemporalLexicalCues(query).some(
+    (cue) => LATEST_STATE_CUES.has(cue)
+  );
+}
+function sortLexicalCueResults(results, preferLatest) {
+  return [...results].sort((left, right) => {
+    if (preferLatest) {
+      const sessionOrder2 = left.session_id.localeCompare(right.session_id);
+      if (sessionOrder2 !== 0) {
+        return sessionOrder2;
+      }
+      const turnOrder = right.turn_index - left.turn_index;
+      if (turnOrder !== 0) {
+        return turnOrder;
+      }
+      return (right.score ?? 0) - (left.score ?? 0);
+    }
+    const scoreDelta = (right.score ?? 0) - (left.score ?? 0);
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+    const sessionOrder = left.session_id.localeCompare(right.session_id);
+    if (sessionOrder !== 0) {
+      return sessionOrder;
+    }
+    return left.turn_index - right.turn_index;
+  });
+}
+function normalizeSpeakerNameCue(value) {
+  const words = value.trim().split(/\s+/).filter(Boolean);
+  while (words.length > 0 && SPEAKER_NAME_STOPWORDS.has(words[0])) {
+    words.shift();
+  }
+  while (words.length > 0 && SPEAKER_NAME_STOPWORDS.has(words[words.length - 1])) {
+    words.pop();
+  }
+  return words.length > 0 ? words.join(" ") : void 0;
+}
+function isTemporalCueBoundary(char) {
+  if (!char) {
+    return true;
+  }
+  return !isAsciiLetterOrDigit(char);
+}
+function tokenizeReferenceQuery(query) {
+  const tokens = [];
+  let current = "";
+  const flushCurrent = () => {
+    if (current) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+  for (const char of query) {
+    if (isAsciiLetterOrDigit(char)) {
+      current += char;
+      continue;
+    }
+    flushCurrent();
+    if (char === "#" || char === ",") {
+      tokens.push(char);
+    } else if (isReferenceDash(char)) {
+      tokens.push("-");
+    }
+  }
+  flushCurrent();
+  return tokens;
+}
+function parseReferenceNumbers(tokens, startIndex) {
+  const numbers = [];
+  let lastNumber;
+  let pendingRangeStart;
+  let index = startIndex;
+  const scanEnd = Math.min(
+    tokens.length,
+    startIndex + DEFAULT_MAX_REFERENCES * REFERENCE_SCAN_TOKEN_FACTOR
+  );
+  for (; index < scanEnd; index += 1) {
+    const token = tokens[index];
+    const normalized = token.toLowerCase();
+    const value = parseNonNegativeIntegerToken(token);
+    if (value !== void 0) {
+      if (pendingRangeStart !== void 0) {
+        numbers.push(...expandReferenceRange(pendingRangeStart, value));
+        pendingRangeStart = void 0;
+      } else {
+        numbers.push(value);
+      }
+      lastNumber = value;
+      continue;
+    }
+    if (normalized === "#" || normalized === "number" || normalized === ",") {
+      continue;
+    }
+    if (normalized === "-" || normalized === "to" || normalized === "through" || normalized === "thru") {
+      if (lastNumber !== void 0) {
+        if (numbers[numbers.length - 1] === lastNumber) {
+          numbers.pop();
+        }
+        pendingRangeStart = lastNumber;
+      }
+      continue;
+    }
+    if (normalized === "and" && numbers.length > 0) {
+      continue;
+    }
+    if (normalizeReferenceLabel(token)) {
+      break;
+    }
+    break;
+  }
+  if (pendingRangeStart !== void 0) {
+    numbers.push(pendingRangeStart);
+  }
+  return {
+    numbers: [...new Set(numbers)],
+    nextIndex: index
+  };
+}
+function expandReferenceRange(start, end) {
+  const low = Math.min(start, end);
+  const high = Math.max(start, end);
+  if (high - low + 1 > DEFAULT_MAX_REFERENCES) {
+    return [start, end];
+  }
+  const values = [];
+  for (let value = low; value <= high; value += 1) {
+    values.push(value);
+  }
+  return values;
+}
+function normalizeReferenceLabel(token) {
+  const normalized = token?.toLowerCase();
+  switch (normalized) {
+    case "step":
+    case "steps":
+      return "step";
+    case "turn":
+    case "turns":
+      return "turn";
+    case "action":
+    case "actions":
+      return "action";
+    case "observation":
+    case "observations":
+      return "observation";
+    default:
+      return void 0;
+  }
+}
+function candidateTurnIndexesForReference(reference) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (reference.includeDirectTurn) {
+    for (let offset = -1; offset <= 1; offset += 1) {
+      candidates.add(reference.number + offset);
+    }
+  }
+  const pairedBase = reference.number * 2;
+  for (let offset = -2; offset <= 3; offset += 1) {
+    candidates.add(pairedBase + offset);
+  }
+  return [...candidates].sort((left, right) => left - right);
+}
+function parseNonNegativeIntegerToken(token) {
+  if (token.length === 0) {
+    return void 0;
+  }
+  let value = 0;
+  for (const char of token) {
+    const code = char.charCodeAt(0);
+    if (code < 48 || code > 57) {
+      return void 0;
+    }
+    value = value * 10 + (code - 48);
+  }
+  return value;
+}
+function normalizePositiveInteger2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function isAsciiLetterOrDigit(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isReferenceDash(char) {
+  return char === "-" || char === "\u2010" || char === "\u2011" || char === "\u2012" || char === "\u2013" || char === "\u2014" || char === "\u2015";
+}
+
 // ../remnic-core/src/recall-query-policy.ts
 var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
   "the",
@@ -26180,7 +26820,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 +26866,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 +26935,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 +27362,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 +27373,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 +27546,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 +27746,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 +28281,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 +28415,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 +28500,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 +36762,7 @@ ${r.snippet.trim()}
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
       let xrayRecalledResults = [];
+      const lcmStructuredXrayResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
         hot_embedding: 0,
@@ -37307,6 +38566,27 @@ ${formatted}`;
       this.profiler.startSpan("assembly", profileTraceId);
       if (sharedCtx)
         this.appendRecallSection(sectionBuckets, "shared-context", sharedCtx);
+      const explicitCueMaxChars = this.getRecallSectionMaxChars("explicit-cue") ?? this.config.explicitCueRecallMaxChars;
+      if (this.config.explicitCueRecallEnabled && this.isRecallSectionEnabled("explicit-cue") && explicitCueMaxChars !== 0 && this.lcmEngine?.enabled && recallMode !== "no_recall") {
+        try {
+          const explicitCueSection = await buildExplicitCueRecallSection({
+            engine: this.lcmEngine,
+            sessionId: sessionKey,
+            query: retrievalQuery,
+            maxChars: explicitCueMaxChars,
+            maxReferences: this.getRecallSectionNumber("explicit-cue", "maxResults") ?? this.config.explicitCueRecallMaxReferences
+          });
+          if (explicitCueSection) {
+            this.appendRecallSection(
+              sectionBuckets,
+              "explicit-cue",
+              explicitCueSection
+            );
+          }
+        } catch (err) {
+          log.debug(`Explicit cue recall assembly error: ${err}`);
+        }
+      }
       if (profile)
         this.appendRecallSection(
           sectionBuckets,
@@ -37427,6 +38707,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 +39633,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 +39810,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 +39920,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 +44467,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 +44522,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 +44672,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 +44681,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 +45567,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 +45736,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 +45748,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 +46658,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 +46677,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 +46708,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 +46721,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 +46769,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 +46787,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 +46803,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 +46811,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 +46848,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 +46868,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 +47134,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 +47205,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 +56663,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 +58053,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 +58725,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 +60110,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 +61303,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 +69247,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 +69263,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 +69277,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 +69310,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 +69356,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";
@@ -70148,8 +71571,7 @@ function buildTurnFingerprint(input) {
 // ../../src/index.ts
 import {
   resolvePrincipal as resolvePrincipal2,
-  resolveAgentAccessAuthToken as resolveAgentAccessAuthToken2,
-  hasEnabledLiveConnector as hasEnabledLiveConnector2
+  resolveAgentAccessAuthToken as resolveAgentAccessAuthToken2
 } from "@remnic/core";
 
 // ../remnic-core/src/surfaces/dreams.ts
@@ -70728,6 +72150,17 @@ function liveConnectorCronExprForConfig(connectors) {
   return hasEnabledConnector ? ENABLED_LIVE_CONNECTOR_CRON_EXPR : DEFAULT_LIVE_CONNECTOR_CRON_EXPR;
 }
 
+// ../../src/openclaw-live-connector-config.ts
+function hasEnabledLiveConnectorConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) return false;
+  return Object.values(config).some((connector) => {
+    if (!connector || typeof connector !== "object" || Array.isArray(connector)) {
+      return false;
+    }
+    return connector.enabled === true;
+  });
+}
+
 // ../../src/index.ts
 var ENGRAM_MIGRATION_PROMISE = "__openclawEngramMigrationPromise";
 var CLI_REGISTERED_GUARD = "__openclawEngramCliRegistered";
@@ -70839,7 +72272,7 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
   return loadPluginEntryFromFile(pluginId)?.["hooks"];
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
-  if (!hasEnabledLiveConnector2(orchestrator.config.connectors)) return;
+  if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
   const jobsPath = path99.join(resolveHomeDir(), ".openclaw", "cron", "jobs.json");
   try {
     if (!existsSync12(jobsPath)) {
@@ -72525,7 +73958,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(