@remnic/plugin-openclaw 1.0.13 → 1.0.15

package/dist/{calibration-WCHOK6DX.js → calibration-WBEDZUR3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5LE4HTVL.js";
 import {
   FallbackLlmClient
-} from "./chunk-RQCTMECT.js";
+} from "./chunk-BCKAR3OK.js";
 import "./chunk-3A5ELHTT.js";
 import {
   log

package/dist/{causal-consolidation-YI53C2AO.js → causal-consolidation-K65BZXWS.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-5LE4HTVL.js";
 import {
   FallbackLlmClient
-} from "./chunk-RQCTMECT.js";
+} from "./chunk-BCKAR3OK.js";
 import "./chunk-3A5ELHTT.js";
 import "./chunk-7UZNLMW5.js";
 import "./chunk-6OJAU466.js";

package/dist/{chunk-RQCTMECT.js → chunk-BCKAR3OK.js}

@@ -40,6 +40,17 @@ function buildChatCompletionTokenLimit(model, maxTokens, options) {
   }
   return { max_tokens: safeMaxTokens };
 }
+function supportsTemperature(model, options) {
+  const normalized = normalizedModel(model);
+  if (options?.assumeOpenAI === true && matchesModelFamily(normalized, /^gpt-5(?:$|[-.])/)) {
+    return false;
+  }
+  return true;
+}
+function buildChatCompletionTemperature(model, temperature, options) {
+  if (!supportsTemperature(model, options)) return {};
+  return { temperature };
+}
 
 // ../remnic-core/src/resolve-provider-secret.ts
 import path from "path";
@@ -255,6 +266,20 @@ function loadModelsJsonProviders() {
 }
 
 // ../remnic-core/src/fallback-llm.ts
+var PROVIDER_ALIASES = {
+  "openai-codex": ["codex"],
+  codex: ["openai-codex"],
+  "claude-cli": ["anthropic"]
+};
+var LEGACY_PROVIDER_IDS = /* @__PURE__ */ new Set(["openai-codex", "claude-cli"]);
+var BUILT_IN_PROVIDER_FALLBACKS = {
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    api: "anthropic-messages",
+    apiKey: "secretref-managed",
+    models: []
+  }
+};
 var FallbackLlmClient = class {
   gatewayConfig;
   runtimeContext;
@@ -412,14 +437,59 @@ var FallbackLlmClient = class {
       log.warn(`fallback LLM: invalid model format: ${modelString}`);
       return null;
     }
-    const providerId = parts[0];
+    const requestedProviderId = parts[0];
     const modelId = parts.slice(1).join("/");
-    const providerConfig = providers[providerId] ?? this.resolveFromModelsJson(providerId);
+    const resolvedProvider = this.resolveProviderConfig(requestedProviderId, providers);
+    const providerConfig = resolvedProvider?.config;
     if (!providerConfig) {
-      log.warn(`fallback LLM: provider not found: ${providerId}`);
+      log.warn(
+        `fallback LLM: provider not found: ${requestedProviderId} (tried: ${this.providerResolutionCandidates(requestedProviderId).join(", ")})`
+      );
       return null;
     }
-    return { providerId, modelId, providerConfig, modelString };
+    return {
+      providerId: resolvedProvider.providerId,
+      modelId,
+      providerConfig,
+      modelString
+    };
+  }
+  resolveProviderConfig(providerId, providers) {
+    const candidates = this.providerResolutionCandidates(providerId);
+    const aliasCandidates = candidates.filter((candidate) => candidate !== providerId);
+    const fallbackCandidates = LEGACY_PROVIDER_IDS.has(providerId) ? [...aliasCandidates, providerId] : [providerId, ...aliasCandidates];
+    for (const candidate of candidates) {
+      const config = providers[candidate];
+      if (config) {
+        if (candidate !== providerId) {
+          log.debug(`fallback LLM: provider "${providerId}" resolved via alias "${candidate}"`);
+        }
+        return { providerId: candidate, config };
+      }
+    }
+    for (const candidate of fallbackCandidates) {
+      const config = this.resolveFromModelsJson(candidate);
+      if (config) {
+        if (candidate !== providerId) {
+          log.debug(`fallback LLM: provider "${providerId}" resolved via models.json alias "${candidate}"`);
+        }
+        return { providerId: candidate, config };
+      }
+      const builtInConfig = BUILT_IN_PROVIDER_FALLBACKS[candidate];
+      if (builtInConfig) {
+        if (candidate === providerId) {
+          log.debug(`fallback LLM: provider "${providerId}" resolved from built-in defaults`);
+          return { providerId, config: builtInConfig };
+        }
+        log.debug(`fallback LLM: provider "${providerId}" resolved via built-in alias "${candidate}"`);
+        return { providerId: candidate, config: builtInConfig };
+      }
+    }
+    return null;
+  }
+  providerResolutionCandidates(providerId) {
+    const candidates = [providerId, ...PROVIDER_ALIASES[providerId] ?? []];
+    return [...new Set(candidates)];
   }
   /**
    * Look up a provider from the gateway's materialized models.json, which
@@ -540,7 +610,9 @@ var FallbackLlmClient = class {
     const body = {
       model: modelId,
       messages,
-      temperature: options.temperature ?? 0.3,
+      ...buildChatCompletionTemperature(modelId, options.temperature ?? 0.3, {
+        assumeOpenAI
+      }),
       ...buildChatCompletionTokenLimit(modelId, options.maxTokens ?? 4096, {
         assumeOpenAI
       })
@@ -593,7 +665,9 @@ var FallbackLlmClient = class {
       model: modelId,
       input,
       max_output_tokens: Math.max(0, Math.floor(options.maxTokens ?? 4096)),
-      temperature: options.temperature ?? 0.3
+      ...buildChatCompletionTemperature(modelId, options.temperature ?? 0.3, {
+        assumeOpenAI: shouldAssumeOpenAiChatCompletions(config.baseUrl)
+      })
     };
     if (instructions.length > 0) {
       body.instructions = instructions;

package/dist/{chunk-OAE7AQ6R.js → chunk-URJUGPZW.js}

@@ -831,7 +831,7 @@ var CompoundingEngine = class {
     let promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
     if (this.config.cmcConsolidationEnabled) {
       try {
-        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-YI53C2AO.js");
+        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-K65BZXWS.js");
         const causalCandidates = await deriveCausalPromotionCandidates({
           memoryDir: this.config.memoryDir,
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -863,7 +863,7 @@ var CompoundingEngine = class {
     }
     if (this.config.calibrationEnabled) {
       try {
-        const { runCalibrationConsolidation } = await import("./calibration-WCHOK6DX.js");
+        const { runCalibrationConsolidation } = await import("./calibration-WBEDZUR3.js");
         const calRules = await runCalibrationConsolidation({
           memoryDir: this.config.memoryDir,
           gatewayConfig: this.config.gatewayConfig,

package/dist/{engine-BIYI3P4J.js → engine-KJWHWWLM.js}

@@ -1,7 +1,7 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-OAE7AQ6R.js";
+} from "./chunk-URJUGPZW.js";
 import "./chunk-EXDYWXMB.js";
 import "./chunk-7UZNLMW5.js";
 import "./chunk-6OJAU466.js";

package/dist/{fallback-llm-WCWNGIQ3.js → fallback-llm-7PHTDZ4M.js}

@@ -1,6 +1,6 @@
 import {
   FallbackLlmClient
-} from "./chunk-RQCTMECT.js";
+} from "./chunk-BCKAR3OK.js";
 import "./chunk-3A5ELHTT.js";
 import "./chunk-UFU5GGGA.js";
 import "./chunk-I6B2W2IY.js";

package/dist/index.js

@@ -115,7 +115,7 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-OAE7AQ6R.js";
+} from "./chunk-URJUGPZW.js";
 import {
   ZodError,
   external_exports
@@ -132,7 +132,7 @@ import {
   buildChatCompletionTokenLimit,
   findGatewayRuntimeModules,
   shouldAssumeOpenAiChatCompletions
-} from "./chunk-RQCTMECT.js";
+} from "./chunk-BCKAR3OK.js";
 import {
   extractJsonCandidates
 } from "./chunk-3A5ELHTT.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,827 @@ 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 STRUCTURED_PLAN_FIELD_CUES = /* @__PURE__ */ new Set([
+  "accommodation",
+  "attraction",
+  "breakfast",
+  "current city",
+  "dinner",
+  "flight",
+  "flights",
+  "hotel",
+  "lunch",
+  "restaurant",
+  "restaurants",
+  "transportation",
+  "traveler",
+  "travelers"
+]);
+var STRUCTURED_PLAN_DEPENDENCY_CUES = /* @__PURE__ */ new Set([
+  "comparison",
+  "constraint",
+  "constraints",
+  "dependency",
+  "dependencies",
+  "join",
+  "same",
+  "shared"
+]);
+var BENCHMARK_ABILITY_CUES = /* @__PURE__ */ new Map([
+  ["information extraction", "ability=information_extraction"],
+  ["knowledge update", "ability=knowledge_update"],
+  ["multi session reasoning", "ability=multi_session_reasoning"],
+  ["multi-session reasoning", "ability=multi_session_reasoning"],
+  ["instruction following", "ability=instruction_following"]
+]);
+var BENCHMARK_ANCHOR_VALUE_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "an",
+  "for",
+  "from",
+  "in",
+  "on",
+  "the",
+  "to",
+  "use",
+  "using",
+  "with"
+]);
+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",
+  "Join",
+  "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,
+    includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
+    includeStructuredPlanCues: options.includeStructuredPlanCues,
+    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, {
+    includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
+    includeStructuredPlanCues: options.includeStructuredPlanCues
+  }).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, options = {}) {
+  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);
+  }
+  if (options.includeBenchmarkAnchorCues) {
+    for (const cue of collectBenchmarkAnchorCues(query)) {
+      cues.add(cue);
+    }
+  }
+  if (options.includeStructuredPlanCues) {
+    for (const cue of collectStructuredPlanCues(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 collectBenchmarkAnchorCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const [phrase, cue] of BENCHMARK_ABILITY_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, phrase)) {
+      cues.add(cue);
+    }
+  }
+  const tokens = tokenizeAnchorQuery(query);
+  for (let index = 0; index < tokens.length; index += 1) {
+    let prefix = normalizeBenchmarkAnchorPrefix(tokens[index]);
+    if (!prefix) {
+      continue;
+    }
+    let valueIndex = index + 1;
+    if (prefix === "source" && tokens[valueIndex]?.toLowerCase() === "chat") {
+      prefix = "source_chat";
+      valueIndex += 1;
+    }
+    const maybeIdLabel = tokens[valueIndex]?.toLowerCase();
+    if (maybeIdLabel === "id" || maybeIdLabel === "ids") {
+      valueIndex += 1;
+    }
+    let consumedValue = false;
+    for (let currentValueIndex = valueIndex; currentValueIndex < tokens.length; currentValueIndex += 1) {
+      const rawValue = tokens[currentValueIndex];
+      const normalizedValue = rawValue?.toLowerCase();
+      if (!rawValue || normalizeBenchmarkAnchorPrefix(rawValue)) {
+        break;
+      }
+      if (normalizedValue === "and" || normalizedValue === "or") {
+        continue;
+      }
+      if (BENCHMARK_ANCHOR_VALUE_STOPWORDS.has(normalizedValue)) {
+        break;
+      }
+      if (!isBenchmarkAnchorValue(rawValue)) {
+        break;
+      }
+      addBenchmarkAnchorCues(cues, prefix, rawValue);
+      consumedValue = true;
+      index = currentValueIndex;
+    }
+    if (!consumedValue) {
+      continue;
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function addBenchmarkAnchorCues(cues, prefix, rawValue) {
+  cues.add(`${prefix}_id=${rawValue}`);
+  cues.add(`${prefix}-${rawValue}`);
+  if (prefix === "source_chat") {
+    cues.add(`chat_id=${rawValue}`);
+  }
+}
+function isBenchmarkAnchorValue(token) {
+  for (const char of token) {
+    if (isAsciiDigitChar(char)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isAsciiDigitChar(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57;
+}
+function normalizeBenchmarkAnchorPrefix(token) {
+  switch (token?.toLowerCase()) {
+    case "ability":
+    case "chat":
+    case "plan":
+    case "rubric":
+    case "source":
+      return token.toLowerCase();
+    default:
+      return void 0;
+  }
+}
+function tokenizeAnchorQuery(query) {
+  const tokens = [];
+  let current = "";
+  const push = () => {
+    const token = trimTrailingAnchorTokenPunctuation(current);
+    if (token.length > 0) {
+      tokens.push(token);
+    }
+    current = "";
+  };
+  for (const char of query) {
+    if (isAsciiLetterOrDigit(char) || char === "_" || char === "-" || char === "." || char === ":") {
+      current += char;
+      continue;
+    }
+    push();
+  }
+  push();
+  return tokens;
+}
+function trimTrailingAnchorTokenPunctuation(token) {
+  let end = token.length;
+  while (end > 0) {
+    const char = token[end - 1];
+    if (char !== "." && char !== ":" && char !== ";" && char !== "!" && char !== "?") {
+      break;
+    }
+    end -= 1;
+  }
+  return token.slice(0, end);
+}
+function collectStructuredPlanCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const cue of STRUCTURED_PLAN_FIELD_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  if (cues.size === 0) {
+    return [];
+  }
+  for (const cue of STRUCTURED_PLAN_DEPENDENCY_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function containsBoundedPhrase(normalizedHaystack, phrase) {
+  let searchFrom = 0;
+  while (searchFrom < normalizedHaystack.length) {
+    const index = normalizedHaystack.indexOf(phrase, searchFrom);
+    if (index < 0) {
+      return false;
+    }
+    const afterIndex = index + phrase.length;
+    if (isTemporalCueBoundary(normalizedHaystack[index - 1]) && isTemporalCueBoundary(normalizedHaystack[afterIndex])) {
+      return true;
+    }
+    searchFrom = afterIndex;
+  }
+  return false;
+}
+function collectTemporalLexicalCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const cue of RELATIVE_TEMPORAL_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  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",
@@ -34089,7 +34922,7 @@ ${doc.content}` : doc.content,
       );
       return result;
     }
-    const { FallbackLlmClient: FallbackLlmClient2 } = await import("./fallback-llm-WCWNGIQ3.js");
+    const { FallbackLlmClient: FallbackLlmClient2 } = await import("./fallback-llm-7PHTDZ4M.js");
     const useGateway = this.config.modelSource === "gateway";
     const modelSetting = this.config.semanticConsolidationModel;
     if (modelSetting === "fast" && this.fastLlm && !useGateway) {
@@ -36852,7 +37685,7 @@ ${lines.join("\n\n")}`;
           return null;
         }
         try {
-          const { getCalibrationRulesForRecall, buildCalibrationRecallSection } = await import("./calibration-WCHOK6DX.js");
+          const { getCalibrationRulesForRecall, buildCalibrationRecallSection } = await import("./calibration-WBEDZUR3.js");
           const rules = await getCalibrationRulesForRecall(this.config.memoryDir);
           if (rules.length === 0) {
             recordRecallSectionMetric({
@@ -37930,6 +38763,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,
@@ -63117,7 +63971,7 @@ async function runSemanticRulePromoteCliCommand(options) {
   });
 }
 async function runCompoundingPromoteCliCommand(options) {
-  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-BIYI3P4J.js");
+  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-KJWHWWLM.js");
   const config = parseConfig({
     memoryDir: options.memoryDir,
     qmdEnabled: false,
@@ -70914,8 +71768,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 +72347,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 +72469,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.15",
   "description": "OpenClaw adapter for Remnic memory — thin wrapper delegating to @remnic/core",
   "type": "module",
   "main": "dist/index.js",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "openai": "^6.0.0",
-    "@remnic/core": "^1.1.5"
+    "@remnic/core": "^1.1.7"
   },
   "peerDependencies": {
     "openclaw": ">=2026.4.8"