@remnic/plugin-openclaw 1.0.13 → 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,
@@ -2254,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,
@@ -23087,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",
@@ -37930,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,
@@ -70914,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
@@ -71494,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";
@@ -71605,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)) {

package/openclaw.plugin.json

@@ -2192,6 +2192,23 @@
         "default": 300,
         "description": "Max tokens for each TMT summary node. Default: 300."
       },
+      "explicitCueRecallEnabled": {
+        "type": "boolean",
+        "default": false,
+        "description": "Front-load exact LCM evidence for query-visible cues such as turns, dates, ids, files, and tools."
+      },
+      "explicitCueRecallMaxChars": {
+        "type": "number",
+        "default": 2400,
+        "minimum": 0,
+        "description": "Character budget for the explicit cue evidence recall section."
+      },
+      "explicitCueRecallMaxReferences": {
+        "type": "number",
+        "default": 24,
+        "minimum": 0,
+        "description": "Maximum query-visible cues expanded by explicit cue recall."
+      },
       "queryExpansionEnabled": {
         "type": "boolean",
         "default": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/plugin-openclaw",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "OpenClaw adapter for Remnic memory — thin wrapper delegating to @remnic/core",
   "type": "module",
   "main": "dist/index.js",