agenr 2.1.0 → 3.1.0

package/dist/adapters/openclaw/index.js

@@ -1,60 +1,247 @@
 import {
   OpenClawTranscriptParser,
-  createOpenClawRepository,
   deriveOpenClawSessionIdFromFilePath,
-  ingestEpisodeTranscript,
   openClawTranscriptParser,
   parseTuiSessionKey,
-  readOpenClawSessionsStore,
-  storeEntriesDetailed
-} from "../../chunk-DGV6D6Q3.js";
+  readOpenClawSessionsStore
+} from "../../chunk-JSVQILB3.js";
 import {
   BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K,
   BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K,
   RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K,
-  RECALL_DEBUG_ARTIFACT_MAX_TOP_K,
+  RECALL_DEBUG_ARTIFACT_MAX_TOP_K
+} from "../../chunk-GELCEVFA.js";
+import {
+  EPISODE_SUMMARY_TIMEOUT_MS,
+  FETCH_TOOL_PARAMETERS,
+  RECALL_TOOL_PARAMETERS,
+  STORE_TOOL_PARAMETERS,
+  UPDATE_TOOL_PARAMETERS,
+  buildClaimExtractionRuntime,
+  buildRecallToolServices,
+  composeHostPluginServices,
+  createDeadlineAwareEpisodeSummaryLlm,
+  createSessionStartTracker,
+  embedEpisodeSummaryWithinBudget,
+  extractRecentTurnsFromMessages,
+  formatAgenrSessionStartRecall,
+  formatUnifiedRecallResults,
+  normalizeOptionalBoolean,
+  normalizeOptionalPositiveInteger,
+  normalizePluginInjectionMemoryPolicyConfig,
+  normalizePromptText,
+  parseFetchToolParams,
+  parseRecallToolParams,
+  parseStoreToolParams,
+  parseUpdateToolParams,
+  resolveBeforeTurnPolicy,
+  resolveSessionIdentityKey,
+  resolveSessionStartPolicy,
+  runFetchMemoryTool,
+  runRecallMemoryTool,
+  runSessionStart,
+  runStoreMemoryTool,
+  runUpdateMemoryTool,
+  writeBoundedSingleTranscriptEpisode
+} from "../../chunk-E2DHUFZK.js";
+import {
+  asRecord,
+  buildEntryMemoryResolverPorts,
+  createSingleTranscriptDiscoveryPort,
+  formatErrorMessage,
+  formatTargetSelector,
+  readBooleanParam,
+  resolveTargetEntry,
+  sanitizeFetchToolParams,
+  sanitizeUpdateToolParams
+} from "../../chunk-EEEL53X4.js";
+import {
   containsAgenrMemoryContext,
   formatAgenrBeforeTurnRecall,
   runBeforeTurn,
-  stripAgenrMemoryContext,
-  wrapAgenrMemoryContext
-} from "../../chunk-IMQIJPIP.js";
+  stripAgenrMemoryContext
+} from "../../chunk-V5CDMHRN.js";
 import {
   EMBEDDING_DIMENSIONS,
-  ENTRY_SELECT_COLUMNS,
-  ENTRY_TYPES,
-  EXPIRY_LEVELS,
-  attachCrossEncoderPort,
-  buildActiveEntryClause,
-  createDatabase,
-  createEmbeddingClient,
-  createOpenAICrossEncoder,
-  createRecallAdapter,
-  mapEntryRow,
-  normalizeManualClaimKeyUpdate,
-  projectClaimCentricRecallEntry,
-  readConfig,
-  resolveClaimExtractionConfig,
-  resolveConfigPath,
-  resolveCrossEncoderApiKey,
-  resolveDbPath,
-  resolveEmbeddingApiKey,
-  resolveEmbeddingModel,
-  resolveModel,
-  runUnifiedRecall,
-  validateTemporalValidityRange
-} from "../../chunk-7TDALVPY.js";
+  buildRecallToolDetails,
+  formatRecallToolSummary,
+  formatUnifiedRecallLogSummary,
+  sanitizeRecallToolParams,
+  sanitizeStoreToolParams,
+  truncate
+} from "../../chunk-NNO2V4GH.js";
 import {
-  recall,
   resolveClaimSlotPolicy
-} from "../../chunk-6T5RXGIR.js";
+} from "../../chunk-5LADPJ4C.js";
 
 // src/adapters/openclaw/index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 
+// src/adapters/openclaw/tools/shared.ts
+import { failedTextResult, readNumberParam, readStringArrayParam, readStringParam, textResult } from "openclaw/plugin-sdk/agent-runtime";
+var OPENCLAW_PARAM_READER = {
+  readString: readStringParam,
+  readNumber: readNumberParam,
+  readStringArray: readStringArrayParam
+};
+function toOpenClawToolResult(outcome) {
+  if (outcome.failed) {
+    return failedTextResult(outcome.text, {
+      ...outcome.details,
+      status: "failed"
+    });
+  }
+  return textResult(outcome.text, outcome.details);
+}
+async function resolveTargetEntry2(services, params, options = {}) {
+  return resolveTargetEntry(buildEntryMemoryResolverPorts(services), params, options);
+}
+function logToolCall(logger, toolName, ctx, summary, sanitizedParams) {
+  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} ${summary}`);
+  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} params=${JSON.stringify(sanitizedParams)}`);
+}
+function logToolFailure(logger, toolName, ctx, error) {
+  logger.warn(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} failed: ${formatErrorMessage(error)}`);
+}
+function sanitizeRetireToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {},
+    ...params.reason !== void 0 ? { reasonLength: params.reason.length } : {}
+  };
+}
+function sanitizeTraceToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {},
+    ...params.last !== void 0 ? { last: params.last } : {}
+  };
+}
+function formatTrace(entry, supersededBy, supersedes, claimFamily, recallEvents) {
+  const slotPolicy = entry.claim_key ? claimFamily ? {
+    policy: claimFamily.slotPolicy ?? resolveClaimSlotPolicy(claimFamily.claimKey).policy,
+    reason: claimFamily.slotPolicyReason ?? resolveClaimSlotPolicy(claimFamily.claimKey).reason
+  } : resolveClaimSlotPolicy(entry.claim_key) : void 0;
+  const lines = [
+    `Trace for ${entry.id} | ${entry.subject}`,
+    `type=${entry.type} expiry=${entry.expiry} importance=${entry.importance} retired=${entry.retired}`,
+    `content=${truncate(entry.content, 220)}`
+  ];
+  if (supersededBy) {
+    lines.push(`superseded_by=${supersededBy.id} | ${supersededBy.subject}`);
+  }
+  if (supersedes.length > 0) {
+    lines.push(`supersedes=${supersedes.map((item) => `${item.id} (${item.subject})`).join(", ")}`);
+  }
+  if (entry.claim_key) {
+    lines.push(`claim_key=${entry.claim_key}`);
+    if (slotPolicy) {
+      lines.push(`slot_policy=${slotPolicy.policy}`);
+      lines.push(`slot_policy_reason=${slotPolicy.reason}`);
+    }
+  }
+  if (claimFamily && claimFamily.entries.length > 0) {
+    lines.push(
+      `claim_family=${claimFamily.claimKey} | slot_policy=${slotPolicy?.policy ?? "exclusive"} | ${claimFamily.entries.map((item) => `${item.id}:${describeTraceEntryState(item)}:${formatClaimLifecycleLabel(item)}`).join(", ")}`
+    );
+    if (slotPolicy) {
+      lines.push(`claim_family_policy_reason=${slotPolicy.reason}`);
+    }
+    const transitionSummary = summarizeTraceClaimFamilyTransition(claimFamily.entries);
+    if (transitionSummary) {
+      lines.push(`transition=${transitionSummary}`);
+    }
+  }
+  if (entry.valid_from || entry.valid_to) {
+    lines.push(`validity=${entry.valid_from ?? "?"} -> ${entry.valid_to ?? "ongoing"}`);
+  }
+  if (entry.supersession_kind) {
+    lines.push(`supersession_kind=${entry.supersession_kind}${entry.supersession_reason ? ` reason=${truncate(entry.supersession_reason, 120)}` : ""}`);
+  }
+  if (recallEvents.length > 0) {
+    lines.push(
+      `recent_recalls=${recallEvents.map((event) => `${event.recalledAt}${event.query ? ` query=${event.query}` : ""}${event.sessionKey ? ` session=${event.sessionKey}` : ""}`).join(" ; ")}`
+    );
+  }
+  return lines.join("\n");
+}
+function toolFailureResult(error) {
+  return failedTextResult(formatErrorMessage(error), {
+    status: "failed"
+  });
+}
+function formatToolSessionContext(ctx) {
+  const normalizedSessionId = ctx.sessionId?.trim();
+  const normalizedSessionKey = ctx.sessionKey?.trim();
+  if (normalizedSessionId && normalizedSessionKey) {
+    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
+  }
+  if (normalizedSessionId) {
+    return `session=${normalizedSessionId}`;
+  }
+  if (normalizedSessionKey) {
+    return `key=${normalizedSessionKey}`;
+  }
+  return "session=unknown";
+}
+function describeTraceEntryState(entry) {
+  if (entry.superseded_by) {
+    return "superseded";
+  }
+  if (entry.retired || entry.valid_to) {
+    return "historical";
+  }
+  return "current";
+}
+function formatClaimLifecycleLabel(entry) {
+  if (!entry.claim_key) {
+    return "no-key";
+  }
+  return entry.claim_key_status ?? "legacy";
+}
+function summarizeTraceClaimFamilyTransition(entries) {
+  const current = entries.find((entry) => !entry.retired && !entry.superseded_by);
+  const prior = [...entries].reverse().find((entry) => entry.id !== current?.id && (entry.superseded_by !== void 0 || entry.retired || entry.valid_to !== void 0));
+  if (current && prior) {
+    return `${prior.id} -> ${current.id}`;
+  }
+  if (prior) {
+    return `${prior.id} is historical with no current sibling in the traced family`;
+  }
+  if (current) {
+    return `${current.id} is the only current sibling in the traced family`;
+  }
+  return void 0;
+}
+
+// src/adapters/openclaw/tools/fetch.ts
+function createAgenrFetchTool(ctx, servicesPromise, logger) {
+  return {
+    name: "agenr_fetch",
+    label: "Agenr Fetch",
+    description: "Fetch the full body and metadata for one durable memory entry by id or subject.",
+    parameters: FETCH_TOOL_PARAMETERS,
+    async execute(_toolCallId, rawParams) {
+      try {
+        const params = parseFetchToolParams(rawParams, OPENCLAW_PARAM_READER);
+        logToolCall(logger, "agenr_fetch", ctx, `target=${formatTargetSelector(params.id, params.subject)}`, sanitizeFetchToolParams(params));
+        const services = await servicesPromise;
+        return toOpenClawToolResult(
+          await runFetchMemoryTool(params, services, {
+            extraDetails: { sessionKey: ctx.sessionKey }
+          })
+        );
+      } catch (error) {
+        logToolFailure(logger, "agenr_fetch", ctx, error);
+        return toolFailureResult(error);
+      }
+    }
+  };
+}
+
 // src/adapters/openclaw/tools/recall.ts
+import { textResult as textResult2 } from "openclaw/plugin-sdk/agent-runtime";
 import { randomUUID } from "crypto";
-import { readNumberParam, readStringArrayParam, readStringParam as readStringParam2, textResult } from "openclaw/plugin-sdk/agent-runtime";
 
 // src/adapters/openclaw/debug/sink.ts
 import { appendFile, mkdir } from "fs/promises";
@@ -277,906 +464,158 @@ function buildTopCandidates(result, reasonsByEntryId, topK) {
   });
 }
 
-// src/adapters/openclaw/tools/shared.ts
-import { failedTextResult, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
-var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use fact for durable truth about a person, system, place, or how something works. Use decision for a standing rule, constraint, policy, or chosen approach future sessions should follow - not a progress update or completed action. Use preference for what someone likes, wants, values, or wants avoided. Use lesson for a non-obvious takeaway learned from experience that should change future behavior. Use milestone for a rare one-time event with durable future significance - not ordinary execution progress. Use relationship for a meaningful durable connection between people, groups, or systems.";
-var EXPIRY_DESCRIPTION = "Lifetime bucket: core (always injected at session start, use sparingly), permanent (durable and recalled on demand), or temporary (short-horizon).";
-var UPDATE_EXPIRY_DESCRIPTION = `${EXPIRY_DESCRIPTION} Accepted values: ${EXPIRY_LEVELS.join(", ")}.`;
-var DEFAULT_RECALL_LIMIT = 10;
-var RECALL_MODES = ["auto", "entries", "episodes", "procedures"];
-var RESULT_SUBJECT_LOG_LIMIT = 5;
-async function resolveTargetEntry(services, params, options = {}) {
-  const id = readStringParam(params, "id");
-  const subject = readStringParam(params, "subject");
-  const last = options.allowLast ? readBooleanParam(params, "last") : void 0;
-  const selectorCount = (id ? 1 : 0) + (subject ? 1 : 0) + (last === true ? 1 : 0);
-  const selectorDescription = options.allowLast ? "id, subject, or last" : "id or subject";
-  if (selectorCount !== 1) {
-    throw new Error(`Provide exactly one target selector: ${selectorDescription}.`);
-  }
-  if (last) {
-    const entry2 = await services.memory.findMostRecentEntry();
-    if (!entry2) {
-      throw new Error("No agenr entries exist yet.");
-    }
-    return entry2;
-  }
-  if (id) {
-    const entry2 = await services.entries.getEntry(id) ?? (await services.memory.getEntryTrace(id))?.entry;
-    if (!entry2) {
-      throw new Error(`No agenr entry found for id ${id}.`);
+// src/adapters/openclaw/tools/recall.ts
+function createAgenrRecallTool(ctx, servicesPromise, logger) {
+  return {
+    name: "agenr_recall",
+    label: "Agenr Recall",
+    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y and procedural questions like how to do something or what steps to follow; use mode=entries for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions; use mode=procedures for canonical methods and checklists. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
+    parameters: RECALL_TOOL_PARAMETERS,
+    async execute(_toolCallId, rawParams) {
+      try {
+        const params = parseRecallToolParams(rawParams, OPENCLAW_PARAM_READER);
+        const sanitizedParams = sanitizeRecallToolParams(params);
+        logToolCall(logger, "agenr_recall", ctx, formatRecallToolSummary(params), sanitizedParams);
+        const services = await servicesPromise;
+        void services.debugSink.emit({
+          type: "tool_call",
+          tool: "agenr_recall",
+          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+          params: sanitizedParams
+        });
+        const result = await runRecallMemoryTool(params, buildRecallToolServices(services), {
+          sessionKey: ctx.sessionKey,
+          slotPolicyConfig: services.pluginConfig.memoryPolicy?.slotPolicies,
+          debugLog: (message) => {
+            logger.debug?.(message);
+          }
+        });
+        logger.info(
+          `[agenr] tool=agenr_recall session=${ctx.sessionId ?? "unknown"} key=${ctx.sessionKey ?? "unknown"} result: ${formatUnifiedRecallLogSummary(result)}`
+        );
+        emitRecallDebugArtifacts(services, ctx, params.query, result);
+        return textResult2(formatUnifiedRecallResults(result), buildRecallToolDetails(result));
+      } catch (error) {
+        logToolFailure(logger, "agenr_recall", ctx, error);
+        await emitRecallError(servicesPromise, ctx, error);
+        return toolFailureResult(error);
+      }
     }
-    return entry2;
-  }
-  const entry = await services.memory.findEntryBySubject(subject ?? "");
-  if (!entry) {
-    throw new Error(`No agenr entry found for subject "${subject}".`);
-  }
-  return entry;
-}
-function readBooleanParam(params, key) {
-  const value = params[key];
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  throw new Error(`${key} must be a boolean.`);
-}
-function parseEntryTypes(values) {
-  return normalizeStringArray(values).map((value) => parseEntryType(value));
-}
-function parseRecallMode(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (value === "auto" || value === "entries" || value === "episodes" || value === "procedures") {
-    return value;
-  }
-  throw new Error(`Unsupported recall mode "${value}".`);
+  };
 }
-function parseEntryType(value) {
-  if (ENTRY_TYPES.includes(value)) {
-    return value;
+function emitRecallDebugArtifacts(services, ctx, query, result) {
+  if (!services.debugSink.enabled) {
+    return;
   }
-  throw new Error(`Unsupported entry type "${value}".`);
+  const sessionIdPayload = ctx.sessionId ? { sessionId: ctx.sessionId } : {};
+  const sessionKeyPayload = ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {};
+  void services.debugSink.emit({
+    type: "tool_result",
+    tool: "agenr_recall",
+    ...sessionIdPayload,
+    ...sessionKeyPayload,
+    summary: {
+      count: result.count,
+      routing: {
+        requested: result.routing.requested,
+        detectedIntent: result.routing.detectedIntent,
+        queried: [...result.routing.queried],
+        reason: result.routing.reason
+      },
+      selectedEntryIds: result.entries.map((entry) => entry.entry.id),
+      episodeIds: result.episodes.map((episode) => episode.episode.id),
+      selectedProcedureKey: result.procedure?.procedure_key ?? null,
+      notices: [...result.notices],
+      procedureNotices: [...result.procedureNotices]
+    }
+  });
+  void services.debugSink.emit({
+    type: "unified_recall",
+    ...sessionIdPayload,
+    ...sessionKeyPayload,
+    debug: buildLiveRecallDebugArtifact({
+      caseId: `live-${randomUUID()}`,
+      query,
+      result,
+      eventLevel: services.debugSink.eventLevel,
+      maxTopCandidates: services.debugSink.maxTopCandidates
+    })
+  });
 }
-function parseExpiry(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (EXPIRY_LEVELS.includes(value)) {
-    return value;
+async function emitRecallError(servicesPromise, ctx, error) {
+  try {
+    const services = await servicesPromise;
+    if (services.debugSink.enabled) {
+      void services.debugSink.emit({
+        type: "error",
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+        ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+        scope: "agenr_recall",
+        error: { message: error instanceof Error ? error.message : String(error) }
+      });
+    }
+  } catch {
   }
-  throw new Error(`Unsupported expiry "${value}".`);
 }
-function normalizeStringArray(values) {
-  if (!values) {
-    return [];
+
+// src/adapters/openclaw/tools/retire.ts
+import { failedTextResult as failedTextResult2, readStringParam as readStringParam2, textResult as textResult3 } from "openclaw/plugin-sdk/agent-runtime";
+var RETIRE_TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      description: "Entry id to retire. Provide exactly one of id or subject."
+    },
+    subject: {
+      type: "string",
+      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
+    },
+    reason: {
+      type: "string",
+      description: "Optional retirement reason so later trace output explains why this memory was removed."
+    }
   }
-  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
-}
-function buildSessionSourceFile(ctx) {
-  const target = ctx.sessionKey ?? ctx.sessionId ?? ctx.agentId ?? "unknown";
-  return `openclaw-session:${target}`;
-}
-function buildToolCallClaimSupport(ctx, toolName, observedAt) {
+};
+function createAgenrRetireTool(ctx, servicesPromise, logger) {
   return {
-    claim_support_source_kind: "tool_call",
-    claim_support_locator: `${buildSessionSourceFile(ctx)}#${toolName}`,
-    claim_support_observed_at: observedAt,
-    claim_support_mode: "explicit"
-  };
-}
-function logToolCall(logger, toolName, ctx, summary, sanitizedParams) {
-  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} ${summary}`);
-  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} params=${JSON.stringify(sanitizedParams)}`);
-}
-function logToolFailure(logger, toolName, ctx, error) {
-  logger.warn(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} failed: ${formatErrorMessage(error)}`);
-}
-function formatTargetSelector(id, subject, last) {
-  if (last === true) {
-    return "last";
-  }
-  if (id) {
-    return `id:${JSON.stringify(id)}`;
-  }
-  if (subject) {
-    return `subject:${JSON.stringify(subject)}`;
-  }
-  return "unknown";
-}
-function sanitizeStoreToolParams(params) {
-  return {
-    type: params.type,
-    subject: params.subject,
-    ...params.importance !== void 0 ? { importance: params.importance } : {},
-    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
-    ...params.tags.length > 0 ? { tags: params.tags } : {},
-    contentLength: params.content.length,
-    ...params.sourceContext !== void 0 ? { sourceContextLength: params.sourceContext.length } : {},
-    ...params.supersedes !== void 0 ? { hasSupersedes: true } : {},
-    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
-    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
-    ...params.validTo !== void 0 ? { hasValidTo: true } : {}
-  };
-}
-function formatRecallToolSummary(params) {
-  const parts = [`query=${JSON.stringify(truncate(params.query, 80))}`];
-  if (params.mode) {
-    parts.push(`mode=${params.mode}`);
-  }
-  if (params.limit !== void 0 && params.limit !== DEFAULT_RECALL_LIMIT) {
-    parts.push(`limit=${params.limit}`);
-  }
-  if (params.types.length > 0) {
-    parts.push(`types=${JSON.stringify(params.types)}`);
-  }
-  if (params.tags.length > 0) {
-    parts.push(`tags=${JSON.stringify(params.tags)}`);
-  }
-  if (params.asOf) {
-    parts.push(`as_of=${JSON.stringify(params.asOf)}`);
-  }
-  return parts.join(" ");
-}
-function sanitizeRecallToolParams(params) {
-  return {
-    query: params.query,
-    ...params.mode ? { mode: params.mode } : {},
-    ...params.limit !== void 0 ? { limit: params.limit } : {},
-    ...params.threshold !== void 0 ? { threshold: params.threshold } : {},
-    ...params.types.length > 0 ? { types: params.types } : {},
-    ...params.tags.length > 0 ? { tags: params.tags } : {},
-    ...params.asOf ? { asOf: params.asOf } : {}
-  };
-}
-function sanitizeRetireToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {},
-    ...params.reason !== void 0 ? { reasonLength: params.reason.length } : {}
-  };
-}
-function sanitizeUpdateToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {},
-    ...params.importance !== void 0 ? { importance: params.importance } : {},
-    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
-    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
-    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
-    ...params.validTo !== void 0 ? { hasValidTo: true } : {}
-  };
-}
-function sanitizeTraceToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {},
-    ...params.last !== void 0 ? { last: params.last } : {}
-  };
-}
-function formatUnifiedRecallResults(result) {
-  const lines = [
-    "Recall Route",
-    `requested=${result.routing.requested} detected=${result.routing.detectedIntent} queried=${result.routing.queried.join(", ") || "none"}`,
-    result.routing.reason,
-    ""
-  ];
-  if (result.timeWindow) {
-    lines.push("Resolved Time Window");
-    lines.push(`${result.timeWindow.start} -> ${result.timeWindow.end} (${result.timeWindow.timezone}) from ${JSON.stringify(result.timeWindow.resolvedFrom)}`);
-    lines.push("");
-  }
-  if (result.asOf) {
-    lines.push("As Of");
-    lines.push(result.asOf);
-    lines.push("");
-  }
-  if (result.routing.queried.includes("procedures") || result.procedure || result.procedureCandidates.length > 0 || result.procedureNotices.length > 0) {
-    appendProcedureMatches(lines, result);
-    lines.push("");
-  }
-  const renderEntriesFirst = result.routing.detectedIntent === "historical_state";
-  if (renderEntriesFirst) {
-    appendEntryMatches(lines, result);
-    lines.push("");
-    appendClaimTransitions(lines, result);
-    lines.push("");
-    appendEpisodeMatches(lines, result);
-  } else {
-    appendEpisodeMatches(lines, result);
-    lines.push("");
-    appendEntryMatches(lines, result);
-    lines.push("");
-    appendClaimTransitions(lines, result);
-  }
-  if (result.notices.length > 0) {
-    lines.push("");
-    lines.push("Notices");
-    for (const notice of result.notices) {
-      lines.push(`- ${notice}`);
-    }
-  }
-  return lines.join("\n");
-}
-function appendProcedureMatches(lines, result) {
-  lines.push("Procedure Matches");
-  if (!result.procedure && result.procedureCandidates.length === 0) {
-    lines.push("None.");
-  } else {
-    if (result.procedure) {
-      appendCanonicalProcedure(lines, result.procedure, result.procedureCandidates);
-    } else {
-      lines.push("Canonical procedure: none.");
-    }
-    const additionalCandidates = result.procedureCandidates.filter((candidate) => candidate.procedure.id !== result.procedure?.id);
-    if (additionalCandidates.length > 0) {
-      lines.push("Other Candidates");
-      for (const [index, candidate] of additionalCandidates.entries()) {
-        lines.push(
-          `${index + 1}. ${candidate.procedure.procedure_key} | ${candidate.procedure.title} | score ${candidate.score.toFixed(2)} | lexical=${candidate.scores.lexical.toFixed(2)} | vector=${candidate.scores.vector.toFixed(2)}`
-        );
-      }
-    }
-  }
-  if (result.procedureNotices.length > 0) {
-    lines.push("Procedure Notices");
-    for (const notice of result.procedureNotices) {
-      lines.push(`- ${notice}`);
-    }
-  }
-}
-function appendEntryMatches(lines, result) {
-  lines.push("Entry Matches");
-  if (result.projectedEntries.length === 0) {
-    lines.push("None.");
-    return;
-  }
-  for (const [familyIndex, family] of result.entryFamilies.entries()) {
-    lines.push(
-      family.claimKey ? `Family ${familyIndex + 1}. claim_key=${family.claimKey} | slot_policy=${family.slotPolicy} | primary=${family.primary.entryId} | subject=${family.subject}` : `Standalone ${familyIndex + 1}. ${family.primary.entryId} | subject=${family.subject}`
-    );
-    for (const [entryIndex, entry] of family.entries.entries()) {
-      lines.push(
-        `   ${entryIndex + 1}. ${entry.entryId} | ${entry.recall.entry.type} | ${entry.recall.entry.subject} | score ${entry.recall.score.toFixed(2)} | state=${entry.memoryState} | claim_status=${formatClaimStatus(entry.claimStatus)}`
-      );
-      lines.push(`      ${truncate(entry.recall.entry.content, 220)}`);
-      lines.push(`      freshness=${entry.freshness.label}`);
-      const provenance = formatProjectedEntryProvenance(entry);
-      if (provenance) {
-        lines.push(`      provenance=${provenance}`);
-      }
-      lines.push(`      why_surfaced=${entry.whySurfaced.summary}`);
-    }
-  }
-}
-function appendEpisodeMatches(lines, result) {
-  lines.push("Episode Matches");
-  if (result.episodes.length === 0) {
-    lines.push("None.");
-    return;
-  }
-  for (const [index, episode] of result.episodes.entries()) {
-    lines.push(
-      `${index + 1}. ${episode.episode.id} | ${episode.episode.source} | ${episode.episode.startedAt} -> ${episode.episode.endedAt ?? episode.episode.startedAt} | score ${episode.score.toFixed(2)}`
-    );
-    lines.push(`   ${index < 3 ? episode.episode.summary.trim() : truncate(episode.episode.summary.trim(), 220)}`);
-    lines.push(`   why_matched=${describeEpisodeMatch(episode)}`);
-  }
-}
-function appendCanonicalProcedure(lines, procedure, candidates) {
-  const leadCandidate = candidates.find((candidate) => candidate.procedure.id === procedure.id);
-  lines.push(
-    leadCandidate ? `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title} | score ${leadCandidate.score.toFixed(2)}` : `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title}`
-  );
-  lines.push(`   goal=${procedure.goal}`);
-  appendLabeledList(lines, "when_to_use", procedure.when_to_use);
-  appendLabeledList(lines, "when_not_to_use", procedure.when_not_to_use);
-  appendLabeledList(lines, "prerequisites", procedure.prerequisites);
-  lines.push("   steps");
-  for (const [index, step] of procedure.steps.entries()) {
-    lines.push(`   ${index + 1}. [${step.kind}] ${step.instruction}`);
-    const stepDetails = formatProcedureStepDetails(step);
-    if (stepDetails.length > 0) {
-      for (const detail of stepDetails) {
-        lines.push(`      ${detail}`);
-      }
-    }
-  }
-  appendLabeledList(lines, "verification", procedure.verification);
-  appendLabeledList(lines, "failure_modes", procedure.failure_modes);
-  lines.push("   sources");
-  for (const source of procedure.sources) {
-    lines.push(`   - ${formatProcedureSource(source)}`);
-  }
-}
-function appendClaimTransitions(lines, result) {
-  lines.push("Claim Transitions");
-  if (result.claimTransitions.length === 0) {
-    lines.push("None.");
-    return;
-  }
-  for (const [index, transition] of result.claimTransitions.entries()) {
-    lines.push(
-      `${index + 1}. family=${transition.claimKey ?? transition.familyKey} | slot_policy=${transition.slotPolicy}${transition.currentEntryId ? ` | current=${transition.currentEntryId}` : ""}${transition.priorEntryId ? ` | prior=${transition.priorEntryId}` : ""}`
-    );
-    lines.push(`   ${transition.summary}`);
-    if (transition.episodeContext) {
-      lines.push(
-        `   episode=${transition.episodeContext.episodeId} | ${transition.episodeContext.startedAt} -> ${transition.episodeContext.endedAt ?? transition.episodeContext.startedAt}`
-      );
-      lines.push(`   ${truncate(transition.episodeContext.summary.trim(), 220)}`);
-    }
-  }
-}
-function formatUnifiedRecallLogSummary(result) {
-  const procedureCount = result.procedureCandidates.length;
-  const procedureSummary = result.procedure ? ` [procedure: ${JSON.stringify(truncate(result.procedure.title, 80))}]` : "";
-  const entrySubjects = result.entries.map((entry) => entry.entry.subject.trim()).filter((subject) => subject.length > 0);
-  const displayed = entrySubjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
-  const remaining = entrySubjects.length - RESULT_SUBJECT_LOG_LIMIT;
-  const suffix = displayed.length === 0 ? "" : ` [entry subjects: ${displayed.join(", ")}${remaining > 0 ? `, ... and ${remaining} more` : ""}]`;
-  const entryEpisodeSummary = `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}`;
-  if (procedureCount === 0 && !result.procedure) {
-    return `${entryEpisodeSummary}${suffix}`;
-  }
-  return `${procedureCount} procedure candidate${procedureCount === 1 ? "" : "s"}, ${entryEpisodeSummary}${procedureSummary}${suffix}`;
-}
-function appendLabeledList(lines, label, values) {
-  lines.push(`   ${label}`);
-  if (values.length === 0) {
-    lines.push("   - none");
-    return;
-  }
-  for (const value of values) {
-    lines.push(`   - ${value}`);
-  }
-}
-function formatProcedureStepDetails(step) {
-  switch (step.kind) {
-    case "run_command":
-      return [`command=${step.command}`];
-    case "read_reference":
-      return [`ref=${formatProcedureSource(step.ref)}`];
-    case "inspect_state":
-      return [step.target ? `target=${step.target}` : void 0, step.query ? `query=${step.query}` : void 0].filter(
-        (value) => value !== void 0
-      );
-    case "edit_file":
-      return [`path=${step.path}`, `edit=${step.edit}`];
-    case "ask_user":
-      return [`prompt=${step.prompt}`];
-    case "invoke_tool":
-      return [step.tool ? `tool=${step.tool}` : void 0, step.arguments ? `arguments=${JSON.stringify(step.arguments)}` : void 0].filter(
-        (value) => value !== void 0
-      );
-    case "verify":
-      return step.checks.map((check) => `check=${check}`);
-    default:
-      return [];
-  }
-}
-function formatProcedureSource(source) {
-  const parts = [source.kind, source.label, source.path, source.locator].filter((value) => Boolean(value && value.length > 0));
-  return parts.join(" | ");
-}
-function formatTrace(entry, supersededBy, supersedes, claimFamily, recallEvents) {
-  const slotPolicy = entry.claim_key ? claimFamily ? {
-    policy: claimFamily.slotPolicy ?? resolveClaimSlotPolicy(claimFamily.claimKey).policy,
-    reason: claimFamily.slotPolicyReason ?? resolveClaimSlotPolicy(claimFamily.claimKey).reason
-  } : resolveClaimSlotPolicy(entry.claim_key) : void 0;
-  const lines = [
-    `Trace for ${entry.id} | ${entry.subject}`,
-    `type=${entry.type} expiry=${entry.expiry} importance=${entry.importance} retired=${entry.retired}`,
-    `content=${truncate(entry.content, 220)}`
-  ];
-  if (supersededBy) {
-    lines.push(`superseded_by=${supersededBy.id} | ${supersededBy.subject}`);
-  }
-  if (supersedes.length > 0) {
-    lines.push(`supersedes=${supersedes.map((item) => `${item.id} (${item.subject})`).join(", ")}`);
-  }
-  if (entry.claim_key) {
-    lines.push(`claim_key=${entry.claim_key}`);
-    if (slotPolicy) {
-      lines.push(`slot_policy=${slotPolicy.policy}`);
-      lines.push(`slot_policy_reason=${slotPolicy.reason}`);
-    }
-  }
-  if (claimFamily && claimFamily.entries.length > 0) {
-    lines.push(
-      `claim_family=${claimFamily.claimKey} | slot_policy=${slotPolicy?.policy ?? "exclusive"} | ${claimFamily.entries.map((item) => `${item.id}:${describeTraceEntryState(item)}:${formatClaimLifecycleLabel(item)}`).join(", ")}`
-    );
-    if (slotPolicy) {
-      lines.push(`claim_family_policy_reason=${slotPolicy.reason}`);
-    }
-    const transitionSummary = summarizeTraceClaimFamilyTransition(claimFamily.entries);
-    if (transitionSummary) {
-      lines.push(`transition=${transitionSummary}`);
-    }
-  }
-  if (entry.valid_from || entry.valid_to) {
-    lines.push(`validity=${entry.valid_from ?? "?"} -> ${entry.valid_to ?? "ongoing"}`);
-  }
-  if (entry.supersession_kind) {
-    lines.push(`supersession_kind=${entry.supersession_kind}${entry.supersession_reason ? ` reason=${truncate(entry.supersession_reason, 120)}` : ""}`);
-  }
-  if (recallEvents.length > 0) {
-    lines.push(
-      `recent_recalls=${recallEvents.map((event) => `${event.recalledAt}${event.query ? ` query=${event.query}` : ""}${event.sessionKey ? ` session=${event.sessionKey}` : ""}`).join(" ; ")}`
-    );
-  }
-  return lines.join("\n");
-}
-function truncate(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
-  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
-}
-function toolFailureResult(error) {
-  return failedTextResult(formatErrorMessage(error), {
-    status: "failed"
-  });
-}
-function formatErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function asRecord(value) {
-  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-    return value;
-  }
-  throw new Error("Tool parameters must be an object.");
-}
-function formatToolSessionContext(ctx) {
-  const normalizedSessionId = ctx.sessionId?.trim();
-  const normalizedSessionKey = ctx.sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-function describeEpisodeMatch(result) {
-  if (result.scores.semantic > 0 && result.scores.temporal > 0) {
-    return "Semantic match within the resolved time window.";
-  }
-  if (result.scores.semantic > 0) {
-    return "Semantic match to the episode summary.";
-  }
-  if (result.scores.temporal > 0) {
-    return "Session overlaps the resolved time window.";
-  }
-  return "Matched episodic recall ranking.";
-}
-function formatClaimStatus(status) {
-  return status === "no_key" ? "no-key" : status;
-}
-function formatProjectedEntryProvenance(entry) {
-  const parts = [
-    entry.provenance.supersededById ? `superseded_by=${entry.provenance.supersededById}` : void 0,
-    entry.provenance.supersessionKind ? `kind=${entry.provenance.supersessionKind}` : void 0,
-    entry.provenance.supersessionReason ? `reason=${truncate(entry.provenance.supersessionReason, 120)}` : void 0,
-    entry.provenance.supportSourceKind ? `support=${entry.provenance.supportSourceKind}` : void 0,
-    entry.provenance.supportMode ? `support_mode=${entry.provenance.supportMode}` : void 0,
-    entry.provenance.supportObservedAt ? `observed=${entry.provenance.supportObservedAt}` : void 0,
-    entry.provenance.supportLocator ? `locator=${truncate(entry.provenance.supportLocator, 120)}` : void 0
-  ].filter((value) => value !== void 0);
-  return parts.join(" | ");
-}
-function describeTraceEntryState(entry) {
-  if (entry.superseded_by) {
-    return "superseded";
-  }
-  if (entry.retired || entry.valid_to) {
-    return "historical";
-  }
-  return "current";
-}
-function formatClaimLifecycleLabel(entry) {
-  if (!entry.claim_key) {
-    return "no-key";
-  }
-  return entry.claim_key_status ?? "legacy";
-}
-function summarizeTraceClaimFamilyTransition(entries) {
-  const current = entries.find((entry) => !entry.retired && !entry.superseded_by);
-  const prior = [...entries].reverse().find((entry) => entry.id !== current?.id && (entry.superseded_by !== void 0 || entry.retired || entry.valid_to !== void 0));
-  if (current && prior) {
-    return `${prior.id} -> ${current.id}`;
-  }
-  if (prior) {
-    return `${prior.id} is historical with no current sibling in the traced family`;
-  }
-  if (current) {
-    return `${current.id} is the only current sibling in the traced family`;
-  }
-  return void 0;
-}
-
-// src/adapters/openclaw/tools/recall.ts
-var RECALL_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    query: {
-      type: "string",
-      description: "What you need to remember. Use a focused natural-language query rather than a broad 'everything' search. Phrase prior-state asks directly, for example 'what was the previous approach' or 'what changed from X to Y'. Phrase procedural asks directly, for example 'how do I rotate credentials' or 'what steps should I follow'."
-    },
-    mode: {
-      type: "string",
-      enum: [...RECALL_MODES],
-      description: "Recall mode: auto routes between exact entry recall, historical-state recall, procedural recall, and episodes; entries forces semantic recall; episodes forces temporal or semantic session recall; procedures forces procedural recall."
-    },
-    limit: {
-      type: "integer",
-      minimum: 1,
-      maximum: 10,
-      description: "Maximum results to return. Lower this when you want a tighter shortlist."
-    },
-    threshold: {
-      type: "number",
-      minimum: 0,
-      maximum: 1,
-      description: "Minimum final score from 0 to 1. Raise this when you want fewer, higher-confidence matches."
-    },
-    types: {
-      type: "array",
-      items: {
-        type: "string",
-        enum: [...ENTRY_TYPES]
-      },
-      description: "Optional knowledge types to filter by, such as decision, preference, lesson, fact, milestone, or relationship."
-    },
-    tags: {
-      type: "array",
-      items: { type: "string" },
-      description: "Optional tags to filter by once you already know the relevant entity, system, or theme."
-    },
-    asOf: {
-      type: "string",
-      description: "Optional reference time for current-vs-prior resolution. Supports ISO timestamps and the same natural-language date phrases used elsewhere in recall."
-    }
-  },
-  required: ["query"]
-};
-function createAgenrRecallTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_recall",
-    label: "Agenr Recall",
-    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y and procedural questions like how to do something or what steps to follow; use mode=entries for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions; use mode=procedures for canonical methods and checklists. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
-    parameters: RECALL_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = asRecord(rawParams);
-        const query = readStringParam2(params, "query", { required: true, label: "query" });
-        const mode = parseRecallMode(readStringParam2(params, "mode"));
-        const limit = readNumberParam(params, "limit", { integer: true, strict: true });
-        const threshold = readNumberParam(params, "threshold", { strict: true });
-        const services = await servicesPromise;
-        const types = parseEntryTypes(readStringArrayParam(params, "types"));
-        const tags = normalizeStringArray(readStringArrayParam(params, "tags"));
-        const asOf = readStringParam2(params, "asOf");
-        const request = {
-          text: query,
-          ...mode ? { mode } : {},
-          ...limit !== void 0 ? { limit } : {},
-          ...threshold !== void 0 ? { threshold } : {},
-          ...types.length > 0 ? { types } : {},
-          ...tags.length > 0 ? { tags } : {},
-          ...asOf ? { asOf } : {},
-          sessionKey: ctx.sessionKey
-        };
-        const sanitizedParams = sanitizeRecallToolParams({
-          query,
-          mode,
-          limit,
-          threshold,
-          types,
-          tags,
-          ...asOf ? { asOf } : {}
-        });
-        logToolCall(
-          logger,
-          "agenr_recall",
-          ctx,
-          formatRecallToolSummary({
-            query,
-            mode,
-            limit,
-            types,
-            tags,
-            ...asOf ? { asOf } : {}
-          }),
-          sanitizedParams
-        );
-        void services.debugSink.emit({
-          type: "tool_call",
-          tool: "agenr_recall",
-          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
-          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
-          params: sanitizedParams
-        });
-        const result = await runUnifiedRecall(request, {
-          database: services.episodes,
-          procedures: services.procedures,
-          recall: services.recall,
-          embeddingAvailable: services.embeddingStatus.available,
-          embeddingError: services.embeddingStatus.error,
-          claimSlotPolicyConfig: services.pluginConfig.memoryPolicy?.slotPolicies,
-          debugLog: (message) => {
-            logger.debug?.(message);
-          },
-          embedQuery: services.embeddingStatus.available ? async (text) => {
-            const vectors = await services.embedding.embed([text]);
-            return vectors[0] ?? [];
-          } : void 0,
-          recallOptions: {
-            slotPolicyConfig: services.pluginConfig.memoryPolicy?.slotPolicies
-          }
-        });
-        logger.info(
-          `[agenr] tool=agenr_recall session=${ctx.sessionId ?? "unknown"} key=${ctx.sessionKey ?? "unknown"} result: ${formatUnifiedRecallLogSummary(result)}`
-        );
-        if (services.debugSink.enabled) {
-          const sessionIdPayload = ctx.sessionId ? { sessionId: ctx.sessionId } : {};
-          const sessionKeyPayload = ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {};
-          void services.debugSink.emit({
-            type: "tool_result",
-            tool: "agenr_recall",
-            ...sessionIdPayload,
-            ...sessionKeyPayload,
-            summary: {
-              count: result.count,
-              routing: {
-                requested: result.routing.requested,
-                detectedIntent: result.routing.detectedIntent,
-                queried: [...result.routing.queried],
-                reason: result.routing.reason
-              },
-              selectedEntryIds: result.entries.map((entry) => entry.entry.id),
-              episodeIds: result.episodes.map((episode) => episode.episode.id),
-              selectedProcedureKey: result.procedure?.procedure_key ?? null,
-              notices: [...result.notices],
-              procedureNotices: [...result.procedureNotices]
-            }
-          });
-          void services.debugSink.emit({
-            type: "unified_recall",
-            ...sessionIdPayload,
-            ...sessionKeyPayload,
-            debug: buildLiveRecallDebugArtifact({
-              caseId: `live-${randomUUID()}`,
-              query,
-              result,
-              eventLevel: services.debugSink.eventLevel,
-              maxTopCandidates: services.debugSink.maxTopCandidates
-            })
-          });
-        }
-        return textResult(formatUnifiedRecallResults(result), {
-          status: "ok",
-          count: result.count,
-          routing: {
-            requested: result.routing.requested,
-            detectedIntent: result.routing.detectedIntent,
-            queried: result.routing.queried,
-            reason: result.routing.reason
-          },
-          ...result.asOf ? { asOf: result.asOf } : {},
-          ...result.timeWindow ? { timeWindow: result.timeWindow } : {},
-          ...result.procedure ? {
-            procedure: {
-              id: result.procedure.id,
-              procedureKey: result.procedure.procedure_key,
-              title: result.procedure.title,
-              goal: result.procedure.goal
-            }
-          } : {},
-          procedures: result.procedureCandidates.map((candidate) => ({
-            id: candidate.procedure.id,
-            procedureKey: candidate.procedure.procedure_key,
-            title: candidate.procedure.title,
-            goal: candidate.procedure.goal,
-            score: candidate.score,
-            lexicalScore: candidate.scores.lexical,
-            vectorScore: candidate.scores.vector
-          })),
-          procedureNotices: result.procedureNotices,
-          episodes: result.episodes.map((episode) => ({
-            id: episode.episode.id,
-            source: episode.episode.source,
-            sourceId: episode.episode.sourceId,
-            startedAt: episode.episode.startedAt,
-            endedAt: episode.episode.endedAt,
-            tags: episode.episode.tags,
-            score: episode.score,
-            activityLevel: episode.episode.activityLevel,
-            summary: episode.episode.summary,
-            whyMatched: episode.scores.semantic > 0 && episode.scores.temporal > 0 ? "Semantic match within the resolved time window." : episode.scores.semantic > 0 ? "Semantic match to the episode summary." : episode.scores.temporal > 0 ? "Session overlaps the resolved time window." : "Matched episodic recall ranking."
-          })),
-          entries: result.entries.map((entry) => ({
-            id: entry.entry.id,
-            subject: entry.entry.subject,
-            type: entry.entry.type,
-            expiry: entry.entry.expiry,
-            importance: entry.entry.importance,
-            score: entry.score,
-            tags: entry.entry.tags,
-            content: entry.entry.content
-          })),
-          projectedEntries: result.projectedEntries.map((entry) => ({
-            id: entry.entryId,
-            familyKey: entry.familyKey,
-            claimKey: entry.claimKey,
-            slotPolicy: entry.slotPolicy,
-            memoryState: entry.memoryState,
-            claimStatus: entry.claimStatus,
-            freshness: entry.freshness,
-            provenance: entry.provenance,
-            whySurfaced: entry.whySurfaced
-          })),
-          entryFamilies: result.entryFamilies.map((family) => ({
-            familyKey: family.familyKey,
-            claimKey: family.claimKey,
-            slotPolicy: family.slotPolicy,
-            subject: family.subject,
-            primaryEntryId: family.primary.entryId,
-            entries: family.entries.map((entry) => ({
-              id: entry.entryId,
-              memoryState: entry.memoryState,
-              claimStatus: entry.claimStatus
-            }))
-          })),
-          claimTransitions: result.claimTransitions,
-          notices: result.notices
-        });
-      } catch (error) {
-        logToolFailure(logger, "agenr_recall", ctx, error);
-        try {
-          const services = await servicesPromise;
-          if (services.debugSink.enabled) {
-            void services.debugSink.emit({
-              type: "error",
-              ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
-              ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
-              scope: "agenr_recall",
-              error: { message: error instanceof Error ? error.message : String(error) }
-            });
-          }
-        } catch {
-        }
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/retire.ts
-import { failedTextResult as failedTextResult2, readStringParam as readStringParam3, textResult as textResult2 } from "openclaw/plugin-sdk/agent-runtime";
-var RETIRE_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    id: {
-      type: "string",
-      description: "Entry id to retire. Provide exactly one of id or subject."
-    },
-    subject: {
-      type: "string",
-      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
-    },
-    reason: {
-      type: "string",
-      description: "Optional retirement reason so later trace output explains why this memory was removed."
-    }
-  }
-};
-function createAgenrRetireTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_retire",
-    label: "Agenr Retire",
-    description: "Mark a memory entry as retired (soft delete). Retired entries are excluded from all recall.",
-    parameters: RETIRE_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = asRecord(rawParams);
-        const id = readStringParam3(params, "id");
-        const subject = readStringParam3(params, "subject");
-        const reason = readStringParam3(params, "reason");
-        logToolCall(logger, "agenr_retire", ctx, `target=${formatTargetSelector(id, subject)}`, sanitizeRetireToolParams({ id, subject, reason }));
-        const services = await servicesPromise;
-        const entry = await resolveTargetEntry(services, params);
-        const retired = await services.entries.retireEntry(entry.id, reason);
-        if (!retired) {
-          return failedTextResult2(`Entry ${entry.id} is not active, so it could not be retired.`, {
-            status: "failed",
-            entryId: entry.id
-          });
-        }
-        return textResult2(`Retired "${entry.subject}".`, {
-          status: "retired",
-          entryId: entry.id,
-          subject: entry.subject,
-          sessionKey: ctx.sessionKey
-        });
-      } catch (error) {
-        logToolFailure(logger, "agenr_retire", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
+    name: "agenr_retire",
+    label: "Agenr Retire",
+    description: "Mark a memory entry as retired (soft delete). Retired entries are excluded from all recall.",
+    parameters: RETIRE_TOOL_PARAMETERS,
+    async execute(_toolCallId, rawParams) {
+      try {
+        const params = asRecord(rawParams);
+        const id = readStringParam2(params, "id");
+        const subject = readStringParam2(params, "subject");
+        const reason = readStringParam2(params, "reason");
+        logToolCall(logger, "agenr_retire", ctx, `target=${formatTargetSelector(id, subject)}`, sanitizeRetireToolParams({ id, subject, reason }));
+        const services = await servicesPromise;
+        const entry = await resolveTargetEntry2(services, params);
+        const retired = await services.entries.retireEntry(entry.id, reason);
+        if (!retired) {
+          return failedTextResult2(`Entry ${entry.id} is not active, so it could not be retired.`, {
+            status: "failed",
+            entryId: entry.id
+          });
+        }
+        return textResult3(`Retired "${entry.subject}".`, {
+          status: "retired",
+          entryId: entry.id,
+          subject: entry.subject,
+          sessionKey: ctx.sessionKey
+        });
+      } catch (error) {
+        logToolFailure(logger, "agenr_retire", ctx, error);
+        return toolFailureResult(error);
+      }
+    }
   };
 }
 
 // src/adapters/openclaw/tools/store.ts
-import { failedTextResult as failedTextResult3, readNumberParam as readNumberParam2, readStringArrayParam as readStringArrayParam2, readStringParam as readStringParam4, textResult as textResult3 } from "openclaw/plugin-sdk/agent-runtime";
-var STORE_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    type: {
-      type: "string",
-      enum: [...ENTRY_TYPES],
-      description: ENTRY_TYPE_DESCRIPTION
-    },
-    subject: {
-      type: "string",
-      description: "Short subject line future recall can match. Name the durable takeaway, person, system, rule, relationship, or milestone directly."
-    },
-    content: {
-      type: "string",
-      description: "What a fresh session should remember. Store the durable takeaway, not the activity log, canonical record, or transient progress snapshot."
-    },
-    importance: {
-      type: "integer",
-      minimum: 1,
-      maximum: 10,
-      description: "Importance from 1 to 10. Use 7 for normal durable memory, 9 for critical constraints, and 10 only rarely."
-    },
-    expiry: {
-      type: "string",
-      enum: ["core", "permanent", "temporary"],
-      description: EXPIRY_DESCRIPTION
-    },
-    tags: {
-      type: "array",
-      items: { type: "string" },
-      description: "Optional tags for entities, systems, teams, or themes that should improve later recall."
-    },
-    sourceContext: {
-      type: "string",
-      description: "Optional provenance note explaining why this memory was stored or what situation produced it."
-    },
-    supersedes: {
-      type: "string",
-      description: "ID of an entry this replaces. The old entry will be marked as superseded."
-    },
-    claimKey: {
-      type: "string",
-      description: 'Slot key identifying the specific knowledge slot (entity/attribute format, e.g., "project_name/deploy_strategy" or "postgres/max_connections"). Entries with the same claim key are candidates for supersession.'
-    },
-    validFrom: {
-      type: "string",
-      description: "ISO 8601 timestamp for when this fact became true in the world."
-    },
-    validTo: {
-      type: "string",
-      description: "ISO 8601 timestamp for when this fact stopped being true."
-    }
-  },
-  required: ["type", "subject", "content"]
-};
 function createAgenrStoreTool(ctx, servicesPromise, logger) {
   return {
     name: "agenr_store",
@@ -1185,95 +624,17 @@ function createAgenrStoreTool(ctx, servicesPromise, logger) {
     parameters: STORE_TOOL_PARAMETERS,
     async execute(_toolCallId, rawParams) {
       try {
-        const params = asRecord(rawParams);
-        const type = parseEntryType(readStringParam4(params, "type", { required: true, label: "type" }));
-        const subject = readStringParam4(params, "subject", { required: true, label: "subject" });
-        const content = readStringParam4(params, "content", { required: true, label: "content" });
-        const importance = readNumberParam2(params, "importance", { integer: true, strict: true });
-        const expiry = parseExpiry(readStringParam4(params, "expiry"));
-        const tags = normalizeStringArray(readStringArrayParam2(params, "tags"));
-        const sourceContext = readStringParam4(params, "sourceContext");
-        const supersedes = readStringParam4(params, "supersedes");
-        const claimKey = readStringParam4(params, "claimKey", { trim: false });
-        const validFrom = readStringParam4(params, "validFrom");
-        const validTo = readStringParam4(params, "validTo");
-        const claimSupportObservedAt = (/* @__PURE__ */ new Date()).toISOString();
-        logToolCall(
-          logger,
-          "agenr_store",
-          ctx,
-          `store 1 entry subject=${JSON.stringify(subject)} type=${type}`,
-          sanitizeStoreToolParams({
-            type,
-            subject,
-            content,
-            importance,
-            expiry,
-            tags,
-            sourceContext,
-            supersedes,
-            claimKey,
-            validFrom,
-            validTo
-          })
-        );
+        const params = parseStoreToolParams(rawParams, OPENCLAW_PARAM_READER);
+        logToolCall(logger, "agenr_store", ctx, `store 1 entry subject=${JSON.stringify(params.subject)} type=${params.type}`, sanitizeStoreToolParams(params));
         const services = await servicesPromise;
-        const result = await storeEntriesDetailed(
-          [
-            {
-              type,
-              subject,
-              content,
-              ...importance !== void 0 ? { importance } : {},
-              ...expiry !== void 0 ? { expiry } : {},
-              ...tags.length > 0 ? { tags } : {},
-              ...supersedes ? { supersedes } : {},
-              ...claimKey ? {
-                claim_key: claimKey,
-                claim_key_raw: claimKey,
-                ...buildToolCallClaimSupport(ctx, "agenr_store", claimSupportObservedAt)
-              } : {},
-              ...validFrom ? { valid_from: validFrom } : {},
-              ...validTo ? { valid_to: validTo } : {},
-              source_file: buildSessionSourceFile(ctx),
-              source_context: sourceContext ?? "Stored via agenr_store from OpenClaw."
-            }
-          ],
-          services.entries,
-          services.embedding,
-          {
-            ...services.claimExtraction ? {
-              claimExtraction: {
-                llm: services.claimExtraction.llm,
-                db: services.entries,
-                config: services.claimExtraction.config
-              }
-            } : {},
+        return toOpenClawToolResult(
+          await runStoreMemoryTool(params, services, {
+            session: ctx,
+            sourcePrefix: "openclaw-session",
+            defaultSourceContext: "Stored via agenr_store from OpenClaw.",
             onWarning: (warning) => logger.warn(`[agenr] tool=agenr_store session=${ctx.sessionId ?? "unknown"} warning: ${warning}`)
-          }
+          })
         );
-        const storedEntry = await services.memory.findEntryBySubject(subject);
-        if (result.stored > 0) {
-          return textResult3(`Stored "${subject}".`, {
-            status: "stored",
-            subject,
-            entryId: storedEntry?.id,
-            result
-          });
-        }
-        if (result.skipped > 0) {
-          return textResult3(`Skipped "${subject}" because an active duplicate already exists.`, {
-            status: "skipped",
-            subject,
-            entryId: storedEntry?.id,
-            result
-          });
-        }
-        return failedTextResult3(`Rejected "${subject}". Check the supplied type, content, and metadata.`, {
-          status: "failed",
-          subject,
-          result
-        });
       } catch (error) {
         logToolFailure(logger, "agenr_store", ctx, error);
         return toolFailureResult(error);
@@ -1283,7 +644,7 @@ function createAgenrStoreTool(ctx, servicesPromise, logger) {
 }
 
 // src/adapters/openclaw/tools/trace.ts
-import { failedTextResult as failedTextResult4, readStringParam as readStringParam5, textResult as textResult4 } from "openclaw/plugin-sdk/agent-runtime";
+import { failedTextResult as failedTextResult3, readStringParam as readStringParam3, textResult as textResult4 } from "openclaw/plugin-sdk/agent-runtime";
 var TRACE_TOOL_PARAMETERS = {
   type: "object",
   additionalProperties: false,
@@ -1311,74 +672,39 @@ function createAgenrTraceTool(ctx, servicesPromise, logger) {
     async execute(_toolCallId, rawParams) {
       try {
         const params = asRecord(rawParams);
-        const id = readStringParam5(params, "id");
-        const subject = readStringParam5(params, "subject");
+        const id = readStringParam3(params, "id");
+        const subject = readStringParam3(params, "subject");
         const last = readBooleanParam(params, "last");
         logToolCall(logger, "agenr_trace", ctx, `target=${formatTargetSelector(id, subject, last)}`, sanitizeTraceToolParams({ id, subject, last }));
         const services = await servicesPromise;
-        const entry = await resolveTargetEntry(services, params, { allowLast: true });
+        const entry = await resolveTargetEntry2(services, params, { allowLast: true });
         const trace = await services.memory.getEntryTrace(entry.id);
         if (!trace) {
-          return failedTextResult4(`Entry ${entry.id} was not found for tracing.`, {
+          return failedTextResult3(`Entry ${entry.id} was not found for tracing.`, {
             status: "failed",
             entryId: entry.id
           });
         }
         return textResult4(formatTrace(trace.entry, trace.supersededBy, trace.supersedes, trace.claimFamily, trace.recallEvents), {
           status: "ok",
-          sessionKey: ctx.sessionKey,
-          trace: {
-            entry: trace.entry,
-            supersededBy: trace.supersededBy,
-            supersedes: trace.supersedes,
-            claimFamily: trace.claimFamily,
-            recallEvents: trace.recallEvents
-          }
-        });
-      } catch (error) {
-        logToolFailure(logger, "agenr_trace", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/update.ts
-import { failedTextResult as failedTextResult5, readNumberParam as readNumberParam3, readStringParam as readStringParam6, textResult as textResult5 } from "openclaw/plugin-sdk/agent-runtime";
-var UPDATE_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    id: {
-      type: "string",
-      description: "Entry id to update. Provide exactly one of id or subject."
-    },
-    subject: {
-      type: "string",
-      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
-    },
-    importance: {
-      type: "integer",
-      description: "New importance from 1 to 10. Use 7 for normal durable memory and reserve 9 to 10 for rare critical entries."
-    },
-    expiry: {
-      type: "string",
-      description: UPDATE_EXPIRY_DESCRIPTION
-    },
-    claimKey: {
-      type: "string",
-      description: 'Slot key identifying the specific knowledge slot (entity/attribute format, e.g., "project_name/deploy_strategy" or "postgres/max_connections"). Entries with the same claim key are candidates for supersession.'
-    },
-    validFrom: {
-      type: "string",
-      description: "ISO 8601 timestamp for when this fact became true."
-    },
-    validTo: {
-      type: "string",
-      description: "ISO 8601 timestamp for when this fact stopped being true."
+          sessionKey: ctx.sessionKey,
+          trace: {
+            entry: trace.entry,
+            supersededBy: trace.supersededBy,
+            supersedes: trace.supersedes,
+            claimFamily: trace.claimFamily,
+            recallEvents: trace.recallEvents
+          }
+        });
+      } catch (error) {
+        logToolFailure(logger, "agenr_trace", ctx, error);
+        return toolFailureResult(error);
+      }
     }
-  }
-};
+  };
+}
+
+// src/adapters/openclaw/tools/update.ts
 function createAgenrUpdateTool(ctx, servicesPromise, logger) {
   return {
     name: "agenr_update",
@@ -1387,72 +713,30 @@ function createAgenrUpdateTool(ctx, servicesPromise, logger) {
     parameters: UPDATE_TOOL_PARAMETERS,
     async execute(_toolCallId, rawParams) {
       try {
-        const params = asRecord(rawParams);
-        const id = readStringParam6(params, "id");
-        const subject = readStringParam6(params, "subject");
-        const importance = readNumberParam3(params, "importance", { integer: true, strict: true });
-        const expiry = parseExpiry(readStringParam6(params, "expiry"));
-        const claimKeyInput = readStringParam6(params, "claimKey", { trim: false });
-        const validFrom = readStringParam6(params, "validFrom");
-        const validTo = readStringParam6(params, "validTo");
-        const claimSupportObservedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const claimSupport = claimKeyInput === void 0 ? void 0 : buildToolCallClaimSupport(ctx, "agenr_update", claimSupportObservedAt);
-        const normalizedClaimKeyUpdate = claimKeyInput === void 0 ? void 0 : (() => {
-          try {
-            return normalizeManualClaimKeyUpdate({
-              claimKey: claimKeyInput,
-              rawClaimKey: claimKeyInput,
-              supportSourceKind: claimSupport?.claim_support_source_kind,
-              supportLocator: claimSupport?.claim_support_locator,
-              supportObservedAt: claimSupport?.claim_support_observed_at,
-              supportMode: claimSupport?.claim_support_mode
-            });
-          } catch {
-            throw new Error("claimKey must use canonical entity/attribute format.");
-          }
-        })();
+        const params = parseUpdateToolParams(rawParams, OPENCLAW_PARAM_READER);
         logToolCall(
           logger,
           "agenr_update",
           ctx,
-          `target=${formatTargetSelector(id, subject)}${importance !== void 0 ? ` importance=${importance}` : ""}${expiry !== void 0 ? ` expiry=${expiry}` : ""}`,
-          sanitizeUpdateToolParams({ id, subject, importance, expiry, claimKey: normalizedClaimKeyUpdate?.claimKey, validFrom, validTo })
+          `target=${formatTargetSelector(params.id, params.subject)}${params.importance !== void 0 ? ` importance=${params.importance}` : ""}${params.expiry !== void 0 ? ` expiry=${params.expiry}` : ""}`,
+          sanitizeUpdateToolParams({
+            id: params.id,
+            subject: params.subject,
+            importance: params.importance,
+            expiry: params.expiry,
+            claimKey: params.claimKeyInput,
+            validFrom: params.validFrom,
+            validTo: params.validTo
+          })
         );
         const services = await servicesPromise;
-        const entry = await resolveTargetEntry(services, params);
-        if (importance === void 0 && expiry === void 0 && normalizedClaimKeyUpdate === void 0 && validFrom === void 0 && validTo === void 0) {
-          throw new Error("Provide at least one update field: importance, expiry, claimKey, validFrom, or validTo.");
-        }
-        const mergedValidity = validateTemporalValidityRange(validFrom ?? entry.valid_from, validTo ?? entry.valid_to);
-        if (!mergedValidity.ok) {
-          throw new Error(mergedValidity.message);
-        }
-        const normalizedValidFrom = validFrom !== void 0 ? mergedValidity.value.validFrom : void 0;
-        const normalizedValidTo = validTo !== void 0 ? mergedValidity.value.validTo : void 0;
-        const updated = await services.entries.updateEntry(entry.id, {
-          ...importance !== void 0 ? { importance } : {},
-          ...expiry !== void 0 ? { expiry } : {},
-          ...normalizedClaimKeyUpdate?.updateFields ?? {},
-          ...validFrom !== void 0 ? { valid_from: normalizedValidFrom } : {},
-          ...validTo !== void 0 ? { valid_to: normalizedValidTo } : {}
-        });
-        if (!updated) {
-          return failedTextResult5(`Entry ${entry.id} is not active, so it could not be updated.`, {
-            status: "failed",
-            entryId: entry.id
-          });
-        }
-        return textResult5(`Updated "${entry.subject}".`, {
-          status: "updated",
-          entryId: entry.id,
-          subject: entry.subject,
-          sessionKey: ctx.sessionKey,
-          ...importance !== void 0 ? { importance } : {},
-          ...expiry !== void 0 ? { expiry } : {},
-          ...normalizedClaimKeyUpdate !== void 0 ? { claimKey: normalizedClaimKeyUpdate.claimKey } : {},
-          ...validFrom !== void 0 ? { validFrom: normalizedValidFrom } : {},
-          ...validTo !== void 0 ? { validTo: normalizedValidTo } : {}
-        });
+        return toOpenClawToolResult(
+          await runUpdateMemoryTool(params, services, {
+            session: ctx,
+            sourcePrefix: "openclaw-session",
+            successDetails: { sessionKey: ctx.sessionKey }
+          })
+        );
       } catch (error) {
         logToolFailure(logger, "agenr_update", ctx, error);
         return toolFailureResult(error);
@@ -1465,6 +749,7 @@ function createAgenrUpdateTool(ctx, servicesPromise, logger) {
 function registerAgenrOpenClawTools(api, servicesPromise, logger) {
   api.registerTool((ctx) => createAgenrStoreTool(ctx, servicesPromise, logger), { names: ["agenr_store"] });
   api.registerTool((ctx) => createAgenrRecallTool(ctx, servicesPromise, logger), { names: ["agenr_recall"] });
+  api.registerTool((ctx) => createAgenrFetchTool(ctx, servicesPromise, logger), { names: ["agenr_fetch"] });
   api.registerTool((ctx) => createAgenrRetireTool(ctx, servicesPromise, logger), { names: ["agenr_retire"] });
   api.registerTool((ctx) => createAgenrUpdateTool(ctx, servicesPromise, logger), { names: ["agenr_update"] });
   api.registerTool((ctx) => createAgenrTraceTool(ctx, servicesPromise, logger), { names: ["agenr_trace"] });
@@ -1474,11 +759,11 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "2.1.0",
+  version: "3.1.0",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {
-    tools: ["agenr_store", "agenr_recall", "agenr_retire", "agenr_update", "agenr_trace"]
+    tools: ["agenr_store", "agenr_recall", "agenr_fetch", "agenr_retire", "agenr_update", "agenr_trace"]
   },
   uiHints: {
     dbPath: {
@@ -1603,6 +888,14 @@ var openclaw_plugin_default = {
             additionalProperties: false,
             description: "Optional session-start overrides for prompt-time memory injection behavior.",
             properties: {
+              enabled: {
+                type: "boolean",
+                description: "Enable or disable all session-start memory injection. Defaults to true."
+              },
+              coreMemory: {
+                type: "boolean",
+                description: "Enable or disable always-on Core Memory injection at session start. Defaults to true."
+              },
               relevantDurableMemory: {
                 type: "boolean",
                 description: "Enable or disable artifact-grounded Relevant Durable Memory injection at session start. Defaults to true."
@@ -1722,7 +1015,7 @@ function normalizeAgenrOpenClawPluginConfig(value) {
   if (!storeNudgeResult.ok) {
     errors.push(...storeNudgeResult.errors);
   }
-  const memoryPolicyResult = normalizeMemoryPolicyConfig(value.memoryPolicy);
+  const memoryPolicyResult = normalizePluginInjectionMemoryPolicyConfig(value.memoryPolicy);
   if (!memoryPolicyResult.ok) {
     errors.push(...memoryPolicyResult.errors);
   }
@@ -1882,193 +1175,11 @@ function normalizeStoreNudgeConfig(value) {
     value: Object.keys(normalizedValue).length > 0 ? resolveStoreNudgeConfig(normalizedValue) : void 0
   };
 }
-function normalizeMemoryPolicyConfig(value) {
-  if (value === void 0) {
-    return { ok: true, value: void 0 };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["memoryPolicy must be an object when provided"] };
-  }
-  const errors = [];
-  const slotPoliciesResult = normalizeClaimSlotPolicyConfig(value.slotPolicies);
-  if (!slotPoliciesResult.ok) {
-    errors.push(...slotPoliciesResult.errors);
-  }
-  const sessionStartResult = normalizeSessionStartMemoryPolicyConfig(value.sessionStart);
-  if (!sessionStartResult.ok) {
-    errors.push(...sessionStartResult.errors);
-  }
-  const beforeTurnResult = normalizeBeforeTurnMemoryPolicyConfig(value.beforeTurn);
-  if (!beforeTurnResult.ok) {
-    errors.push(...beforeTurnResult.errors);
-  }
-  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies", "sessionStart", "beforeTurn"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.${key}`);
-    }
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-  return {
-    ok: true,
-    value: slotPoliciesResult.ok && slotPoliciesResult.value || sessionStartResult.ok && sessionStartResult.value || beforeTurnResult.ok && beforeTurnResult.value ? {
-      ...slotPoliciesResult.ok && slotPoliciesResult.value ? { slotPolicies: slotPoliciesResult.value } : {},
-      ...sessionStartResult.ok && sessionStartResult.value ? { sessionStart: sessionStartResult.value } : {},
-      ...beforeTurnResult.ok && beforeTurnResult.value ? { beforeTurn: beforeTurnResult.value } : {}
-    } : void 0
-  };
-}
-function normalizeSessionStartMemoryPolicyConfig(value) {
-  if (value === void 0) {
-    return { ok: true, value: void 0 };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["memoryPolicy.sessionStart must be an object when provided"] };
-  }
-  const errors = [];
-  const relevantDurableMemory = normalizeOptionalBoolean(value.relevantDurableMemory, "memoryPolicy.sessionStart.relevantDurableMemory", errors);
-  const allowedKeys = /* @__PURE__ */ new Set(["relevantDurableMemory"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.sessionStart.${key}`);
-    }
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-  return {
-    ok: true,
-    value: relevantDurableMemory !== void 0 ? { relevantDurableMemory } : void 0
-  };
-}
-function normalizeBeforeTurnMemoryPolicyConfig(value) {
-  if (value === void 0) {
-    return { ok: true, value: void 0 };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["memoryPolicy.beforeTurn must be an object when provided"] };
-  }
-  const errors = [];
-  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.beforeTurn.enabled", errors);
-  const procedureSuggestion = normalizeOptionalBoolean(value.procedureSuggestion, "memoryPolicy.beforeTurn.procedureSuggestion", errors);
-  const maxDurableEntries = normalizeOptionalPositiveInteger(value.maxDurableEntries, "memoryPolicy.beforeTurn.maxDurableEntries", errors);
-  const recallThreshold = normalizeOptionalUnitInterval(value.recallThreshold, "memoryPolicy.beforeTurn.recallThreshold", errors);
-  const highConfidenceRecallThreshold = normalizeOptionalUnitInterval(
-    value.highConfidenceRecallThreshold,
-    "memoryPolicy.beforeTurn.highConfidenceRecallThreshold",
-    errors
-  );
-  const procedureThreshold = normalizeOptionalUnitInterval(value.procedureThreshold, "memoryPolicy.beforeTurn.procedureThreshold", errors);
-  const allowedKeys = /* @__PURE__ */ new Set([
-    "enabled",
-    "procedureSuggestion",
-    "maxDurableEntries",
-    "recallThreshold",
-    "highConfidenceRecallThreshold",
-    "procedureThreshold"
-  ]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.beforeTurn.${key}`);
-    }
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-  return {
-    ok: true,
-    value: enabled !== void 0 || procedureSuggestion !== void 0 || maxDurableEntries !== void 0 || recallThreshold !== void 0 || highConfidenceRecallThreshold !== void 0 || procedureThreshold !== void 0 ? {
-      ...enabled !== void 0 ? { enabled } : {},
-      ...procedureSuggestion !== void 0 ? { procedureSuggestion } : {},
-      ...maxDurableEntries !== void 0 ? { maxDurableEntries } : {},
-      ...recallThreshold !== void 0 ? { recallThreshold } : {},
-      ...highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold } : {},
-      ...procedureThreshold !== void 0 ? { procedureThreshold } : {}
-    } : void 0
-  };
-}
-function normalizeClaimSlotPolicyConfig(value) {
-  if (value === void 0) {
-    return { ok: true, value: void 0 };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["memoryPolicy.slotPolicies must be an object when provided"] };
-  }
-  const errors = [];
-  const attributeHeads = normalizeClaimSlotPolicyAttributeHeads(value.attributeHeads, errors);
-  const allowedKeys = /* @__PURE__ */ new Set(["attributeHeads"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.slotPolicies.${key}`);
-    }
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-  return {
-    ok: true,
-    value: attributeHeads ? { attributeHeads } : void 0
-  };
-}
-function normalizeClaimSlotPolicyAttributeHeads(value, errors) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (!isRecord(value)) {
-    errors.push("memoryPolicy.slotPolicies.attributeHeads must be an object when provided");
-    return void 0;
-  }
-  const normalized = {};
-  for (const [rawKey, rawPolicy] of Object.entries(value)) {
-    const attributeHead = rawKey.trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9_-]*$/.test(attributeHead)) {
-      errors.push(`memoryPolicy.slotPolicies.attributeHeads.${rawKey} must use a canonical attribute-head label`);
-      continue;
-    }
-    if (rawPolicy !== "exclusive" && rawPolicy !== "multivalued") {
-      errors.push(`memoryPolicy.slotPolicies.attributeHeads.${attributeHead} must be "exclusive" or "multivalued"`);
-      continue;
-    }
-    normalized[attributeHead] = rawPolicy;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function normalizeOptionalBoolean(value, label, errors) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "boolean") {
-    errors.push(`${label} must be a boolean when provided`);
-    return void 0;
-  }
-  return value;
-}
-function normalizeOptionalPositiveInteger(value, label, errors) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
-    errors.push(`${label} must be a positive integer when provided`);
-    return void 0;
-  }
-  return value;
-}
-function normalizeOptionalUnitInterval(value, label, errors) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
-    errors.push(`${label} must be a number between 0 and 1 when provided`);
-    return void 0;
-  }
-  return value;
-}
 
 // src/adapters/openclaw/format/prompt-section.ts
 var MEMORY_TOOL_NAMES = {
   recall: "agenr_recall",
+  fetch: "agenr_fetch",
   store: "agenr_store",
   update: "agenr_update",
   retire: "agenr_retire",
@@ -2090,6 +1201,7 @@ function buildAgenrMemoryPromptSection({
     "## Memory Recall",
     "Before answering anything about prior work, decisions, preferences, people, dates, unfinished work, or past sessions, call agenr_recall first. Session-start recall is automatic, and conservative before-turn recall may also appear as injected background context; use agenr_recall mid-session when you need context you do not already have.",
     "agenr_recall supports exact fact recall plus historical and episodic recall behind one tool: use mode=entries for exact facts, decisions, thresholds, and versions; use mode=auto for prior-state questions like what was the previous approach, what did we use before, or what changed from X to Y; use mode=episodes when you explicitly want session narrative recall.",
+    "agenr_recall returns truncated entry previews with ids, scores, and preview_truncated flags.",
     "For temporal narrative questions, put the time phrase in the query itself: examples include yesterday, last week, this month, 2 weeks ago, or in March.",
     "One focused agenr_recall call with the right scope beats several broad ones.",
     "When Agenr injects memory automatically, treat it as non-user background context and use it silently when relevant rather than forcing it into the reply.",
@@ -2128,6 +1240,9 @@ function buildAgenrMemoryPromptSection({
   if (availableTools.has(MEMORY_TOOL_NAMES.update) || availableTools.has(MEMORY_TOOL_NAMES.retire)) {
     lines.push("When memory is contradicted by live evidence, fix it with agenr_update or agenr_retire instead of silently working around it.");
   }
+  if (availableTools.has(MEMORY_TOOL_NAMES.fetch)) {
+    lines.push("Call agenr_fetch with id when preview_truncated=true or exact stored wording is required.");
+  }
   if (availableTools.has(MEMORY_TOOL_NAMES.trace)) {
     lines.push("Use agenr_trace when provenance, recall history, or supersession matters.");
   }
@@ -2163,59 +1278,7 @@ function formatErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/adapters/openclaw/session/identity.ts
-function resolveSessionIdentityKey(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  if (normalizedSessionId) {
-    return `session:${normalizedSessionId}`;
-  }
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionKey) {
-    return `key:${normalizedSessionKey}`;
-  }
-  return void 0;
-}
-
 // src/adapters/openclaw/session/state.ts
-function createSessionStartTracker() {
-  const seenSessionIdentities = /* @__PURE__ */ new Set();
-  const resumedFromBySessionId = /* @__PURE__ */ new Map();
-  return {
-    consume(sessionId, sessionKey) {
-      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
-      if (!identityKey) {
-        return {
-          isFirst: true,
-          activeCount: seenSessionIdentities.size
-        };
-      }
-      if (seenSessionIdentities.has(identityKey)) {
-        return {
-          isFirst: false,
-          activeCount: seenSessionIdentities.size
-        };
-      }
-      seenSessionIdentities.add(identityKey);
-      return {
-        isFirst: true,
-        activeCount: seenSessionIdentities.size
-      };
-    },
-    rememberSessionStart(sessionId, _sessionKey, resumedFrom) {
-      const normalizedSessionId = sessionId?.trim();
-      const normalizedResumedFrom = resumedFrom?.trim();
-      if (!normalizedSessionId || !normalizedResumedFrom) {
-        return;
-      }
-      resumedFromBySessionId.set(normalizedSessionId, normalizedResumedFrom);
-    },
-    getResumedFrom(sessionId) {
-      const normalizedSessionId = sessionId?.trim();
-      return normalizedSessionId ? resumedFromBySessionId.get(normalizedSessionId) : void 0;
-    }
-  };
-}
-var MAX_STORED_SUBJECTS = 5;
 function createMidSessionTracker() {
   const states = /* @__PURE__ */ new Map();
   return {
@@ -2278,6 +1341,7 @@ function createMidSessionState() {
     storedSubjects: []
   };
 }
+var MAX_STORED_SUBJECTS = 5;
 
 // src/adapters/openclaw/hooks/after-tool-call.ts
 var STORE_TOOL_NAME = "agenr_store";
@@ -2356,270 +1420,13 @@ function hasNonEmptyString(value) {
 
 // src/adapters/openclaw/hooks/before-prompt-build.ts
 import { randomUUID as randomUUID2 } from "crypto";
-
-// src/app/session-start/service.ts
-var DEFAULT_MAX_CORE_ENTRIES = 4;
-var DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES = 3;
-var DEFAULT_MAX_DURABLE_ENTRIES = 5;
-var DEFAULT_MAX_ARTIFACT_CHARS = 1200;
-async function runSessionStart(input, deps) {
-  const policy = normalizePolicy(input.policy);
-  const contextSections = buildContextSections(input);
-  const coreEntries = await deps.repository.listCoreEntries(policy.maxCoreEntries);
-  const coreItems = coreEntries.map((entry) => buildCorePatchItem(entry));
-  const diagnostics = {
-    coreCandidateCount: coreEntries.length,
-    artifactRecallCandidateCount: 0,
-    artifactRecallUsed: false,
-    notices: []
-  };
-  const artifactRecallQuery = policy.enableArtifactRecall ? buildArtifactRecallQuery(contextSections, policy.maxArtifactChars) : void 0;
-  if (!policy.enableArtifactRecall) {
-    diagnostics.notices.push("Artifact-grounded durable recall disabled by session-start policy.");
-  }
-  const artifactRecallItems = artifactRecallQuery ? await runArtifactRecallSelection(artifactRecallQuery, input.sessionKey, policy, deps, diagnostics) : [];
-  const durableMemory = assignRanks(mergeDurableMemory(coreItems, artifactRecallItems, policy.maxDurableEntries));
-  return {
-    contextSections,
-    durableMemory,
-    diagnostics
-  };
-}
-function buildContextSections(input) {
-  const sections = [];
-  const continuitySummaryText = normalizeOptionalString(input.continuitySummaryText);
-  if (continuitySummaryText) {
-    sections.push({
-      kind: "continuity_summary",
-      title: "Previous session summary",
-      content: continuitySummaryText
-    });
-  }
-  const recentSessionText = normalizeOptionalString(input.recentSessionText);
-  if (recentSessionText) {
-    sections.push({
-      kind: "recent_session",
-      title: "Recent session",
-      content: recentSessionText
-    });
-  }
-  return sections;
-}
-async function runArtifactRecallSelection(query, sessionKey, policy, deps, diagnostics) {
-  diagnostics.artifactRecallUsed = true;
-  diagnostics.artifactRecallQuery = query;
-  let artifactRecallTrace;
-  try {
-    const recalled = await recall(
-      {
-        text: query,
-        limit: policy.maxArtifactRecallEntries,
-        threshold: policy.recallThreshold,
-        sessionKey
-      },
-      deps.recall,
-      {
-        trace: {
-          reportSummary(summary) {
-            artifactRecallTrace = summary;
-          }
-        },
-        slotPolicyConfig: deps.slotPolicyConfig
-      }
-    );
-    diagnostics.artifactRecallTrace = artifactRecallTrace;
-    diagnostics.artifactRecallCandidateCount = recalled.length;
-    if (artifactRecallTrace?.degraded.notices.length) {
-      diagnostics.notices.push(...artifactRecallTrace.degraded.notices);
-    }
-    return recalled.map((item) => buildArtifactRecallPatchItem(item, deps));
-  } catch (error) {
-    diagnostics.artifactRecallTrace = artifactRecallTrace;
-    diagnostics.notices.push(`Artifact-grounded durable recall failed: ${formatErrorMessage3(error)}`);
-    return [];
-  }
-}
-function buildCorePatchItem(entry) {
-  return {
-    rank: 0,
-    entry,
-    sourceKind: "core",
-    whySurfaced: {
-      summary: `always-on core memory; importance ${entry.importance}`,
-      reasons: ["always-on core memory", `importance ${entry.importance}`, `expiry ${entry.expiry}`]
-    },
-    memoryState: resolveMemoryState(entry),
-    claimStatus: resolveClaimStatus(entry),
-    freshnessLabel: buildFreshnessLabel(entry),
-    ...buildProvenanceSummary(entry) ? { provenanceSummary: buildProvenanceSummary(entry) } : {}
-  };
-}
-function buildArtifactRecallPatchItem(recalled, deps) {
-  const projected = projectClaimCentricRecallEntry(recalled, {
-    slotPolicyConfig: deps.slotPolicyConfig
-  });
-  return {
-    rank: 0,
-    entry: recalled.entry,
-    sourceKind: "artifact_recall",
-    score: recalled.score,
-    whySurfaced: projected.whySurfaced,
-    memoryState: projected.memoryState,
-    claimStatus: projected.claimStatus,
-    freshnessLabel: projected.freshness.label,
-    ...formatProjectedProvenance(projected.provenance) ? { provenanceSummary: formatProjectedProvenance(projected.provenance) } : {}
-  };
-}
-function buildArtifactRecallQuery(sections, maxChars) {
-  if (sections.length === 0 || maxChars <= 0) {
-    return void 0;
-  }
-  let remaining = maxChars;
-  const parts = [];
-  for (const section of sections) {
-    if (remaining <= 0) {
-      break;
-    }
-    const normalizedContent = normalizeWhitespace(section.content);
-    if (normalizedContent.length === 0) {
-      continue;
-    }
-    const labeled = `${section.title}: ${normalizedContent}`;
-    const truncated = truncate2(labeled, remaining);
-    if (truncated.length === 0) {
-      continue;
-    }
-    parts.push(truncated);
-    remaining -= truncated.length;
-  }
-  const query = normalizeWhitespace(parts.join("\n"));
-  return query.length > 0 ? query : void 0;
-}
-function mergeDurableMemory(coreItems, artifactRecallItems, maxDurableEntries) {
-  const merged = [];
-  const seenEntryIds = /* @__PURE__ */ new Set();
-  for (const item of [...coreItems, ...artifactRecallItems]) {
-    if (seenEntryIds.has(item.entry.id)) {
-      continue;
-    }
-    seenEntryIds.add(item.entry.id);
-    merged.push(item);
-    if (merged.length >= maxDurableEntries) {
-      break;
-    }
-  }
-  return merged;
-}
-function assignRanks(items) {
-  return items.map((item, index) => ({
-    ...item,
-    rank: index + 1
-  }));
-}
-function normalizePolicy(policy) {
-  const maxCoreEntries = normalizeCount(policy?.maxCoreEntries, DEFAULT_MAX_CORE_ENTRIES);
-  const maxArtifactRecallEntries = normalizeCount(policy?.maxArtifactRecallEntries, DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES);
-  const maxDurableEntries = Math.max(maxCoreEntries, normalizeCount(policy?.maxDurableEntries, DEFAULT_MAX_DURABLE_ENTRIES));
-  return {
-    maxCoreEntries,
-    enableArtifactRecall: policy?.enableArtifactRecall !== false,
-    maxArtifactRecallEntries,
-    maxDurableEntries,
-    maxArtifactChars: normalizeCount(policy?.maxArtifactChars, DEFAULT_MAX_ARTIFACT_CHARS),
-    recallThreshold: normalizeThreshold(policy?.recallThreshold)
-  };
-}
-function normalizeCount(value, fallback) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return fallback;
-  }
-  return Math.max(0, Math.trunc(value));
-}
-function normalizeThreshold(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return 0;
-  }
-  return Math.min(1, Math.max(0, value));
-}
-function resolveMemoryState(entry) {
-  if (entry.superseded_by) {
-    return "superseded";
-  }
-  if (entry.retired || entry.valid_to) {
-    return "historical";
-  }
-  return "current";
-}
-function resolveClaimStatus(entry) {
-  if (!normalizeOptionalString(entry.claim_key)) {
-    return "no_key";
-  }
-  return entry.claim_key_status ?? "legacy";
-}
-function buildFreshnessLabel(entry) {
-  const parts = [`created ${entry.created_at}`];
-  const validFrom = normalizeOptionalString(entry.valid_from);
-  const validTo = normalizeOptionalString(entry.valid_to);
-  if (validFrom || validTo) {
-    parts.push(`valid ${validFrom ?? "?"} -> ${validTo ?? "ongoing"}`);
-  }
-  return parts.join(" | ");
-}
-function buildProvenanceSummary(entry) {
-  const parts = [
-    entry.superseded_by ? `superseded_by=${entry.superseded_by}` : void 0,
-    entry.supersession_kind ? `kind=${entry.supersession_kind}` : void 0,
-    entry.supersession_reason ? `reason=${entry.supersession_reason}` : void 0,
-    entry.claim_support_source_kind ? `support=${entry.claim_support_source_kind}` : void 0,
-    entry.claim_support_mode ? `support_mode=${entry.claim_support_mode}` : void 0,
-    entry.claim_support_observed_at ? `observed=${entry.claim_support_observed_at}` : void 0,
-    entry.claim_support_locator ? `locator=${entry.claim_support_locator}` : void 0
-  ].filter((value) => value !== void 0);
-  return parts.length > 0 ? parts.join(" | ") : void 0;
-}
-function formatProjectedProvenance(provenance) {
-  const parts = [
-    provenance.supersededById ? `superseded_by=${provenance.supersededById}` : void 0,
-    provenance.supersessionKind ? `kind=${provenance.supersessionKind}` : void 0,
-    provenance.supersessionReason ? `reason=${provenance.supersessionReason}` : void 0,
-    provenance.supportSourceKind ? `support=${provenance.supportSourceKind}` : void 0,
-    provenance.supportMode ? `support_mode=${provenance.supportMode}` : void 0,
-    provenance.supportObservedAt ? `observed=${provenance.supportObservedAt}` : void 0,
-    provenance.supportLocator ? `locator=${provenance.supportLocator}` : void 0
-  ].filter((value) => value !== void 0);
-  return parts.length > 0 ? parts.join(" | ") : void 0;
-}
-function normalizeOptionalString(value) {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-function normalizeWhitespace(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function truncate2(value, maxChars) {
-  if (maxChars <= 0) {
-    return "";
-  }
-  if (value.length <= maxChars) {
-    return value;
-  }
-  return `${value.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
-}
-function formatErrorMessage3(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-
-// src/adapters/openclaw/hooks/before-prompt-build.ts
 import path5 from "path";
 
 // src/adapters/openclaw/episode/episode-writer.ts
 import { resolveAgentEffectiveModelPrimary as resolveAgentEffectiveModelPrimary2, resolveDefaultAgentId as resolveDefaultAgentId2 } from "openclaw/plugin-sdk/agent-runtime";
 
 // src/adapters/openclaw/llm/openclaw-llm-client.ts
-import { completeSimple, getModel } from "@mariozechner/pi-ai";
+import { completeSimple, getModel } from "@earendil-works/pi-ai";
 
 // src/adapters/openclaw/embedded-agent/task-runner.ts
 import * as fs from "fs/promises";
@@ -2667,7 +1474,7 @@ async function createOpenClawLlmClient(openClaw, modelRef, label = "model overri
     provider: execution.provider,
     cfg: openClaw.config
   });
-  const apiKey = normalizeOptionalString2(auth.apiKey);
+  const apiKey = normalizeOptionalString(auth.apiKey);
   if (!apiKey) {
     throw new Error(`OpenClaw auth did not resolve an API-key-compatible credential for ${execution.provider} (source=${auth.source}, mode=${auth.mode}).`);
   }
@@ -2712,7 +1519,7 @@ function stripCodeFence(text) {
   const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/iu.exec(trimmed);
   return match?.[1]?.trim() ?? trimmed;
 }
-function normalizeOptionalString2(value) {
+function normalizeOptionalString(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
@@ -2721,19 +1528,6 @@ function normalizeOptionalString2(value) {
 var OPENCLAW_EPISODE_GENERATOR_VERSION = "openclaw-episodic-summary-v1";
 
 // src/adapters/openclaw/episode/episode-writer.ts
-var EPISODE_SUMMARY_TIMEOUT_MS = 45e3;
-var EPISODE_SUMMARY_TIMEOUT_ERROR_MESSAGE = "Episode summary generation timed out.";
-var EPISODE_EMBEDDING_TIMEOUT = /* @__PURE__ */ Symbol("episode-embedding-timeout");
-var EPISODE_EMBEDDING_MIN_HEADROOM_MS = 5e3;
-var OpenClawEpisodeSummaryTimeoutError = class extends Error {
-  /**
-   * Creates a timeout error with a stable name for caller-side handling.
-   */
-  constructor() {
-    super(EPISODE_SUMMARY_TIMEOUT_ERROR_MESSAGE);
-    this.name = "OpenClawEpisodeSummaryTimeoutError";
-  }
-};
 async function writeOpenClawPredecessorEpisode(params) {
   const sessionContext = formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey);
   const writeStartedAtMs = Date.now();
@@ -2743,78 +1537,70 @@ async function writeOpenClawPredecessorEpisode(params) {
   }
   const predecessor = params.predecessor;
   params.logger.info(`[agenr] session-start predecessor episode write triggered for ${sessionContext} predecessor=${predecessor.sessionFile}`);
-  try {
-    const episodeModelRef = resolveOpenClawEpisodeModelRef(params.services.openClaw, params.ctx.agentId, params.services.pluginConfig.episodeModel);
-    const episodeModel = episodeModelRef ?? "default";
-    const summaryDeadlineMs = writeStartedAtMs + EPISODE_SUMMARY_TIMEOUT_MS;
-    const ingestResult = await Promise.race([
-      (async () => {
-        const summaryLlm = await createOpenClawEpisodeSummaryLlm({
-          modelRef: episodeModel,
-          openClaw: params.services.openClaw,
-          resolvedModelRef: episodeModelRef,
-          deadlineMs: summaryDeadlineMs
-        });
-        return ingestEpisodeTranscript(
-          predecessor.sessionFile,
-          {
-            files: createSingleTranscriptDiscoveryPort(predecessor.sessionFile),
-            transcript: openClawTranscriptParser,
-            episodes: params.services.episodes,
-            createSummaryLlm: () => summaryLlm,
-            embedSummary: createPredecessorEpisodeEmbeddingStrategy({
-              embedding: params.services.embedding,
-              embeddingAvailable: params.services.embeddingStatus.available,
-              logger: params.logger,
-              sessionContext,
-              predecessorFile: predecessor.sessionFile,
-              deadlineMs: summaryDeadlineMs
-            })
-          },
-          {
-            genVersion: OPENCLAW_EPISODE_GENERATOR_VERSION,
-            skipActiveSessionCheck: true,
-            candidateOverrides: {
-              sessionId: predecessor.sessionId,
-              agentId: trimOptionalString(params.ctx.agentId) ?? null,
-              surface: resolveSessionSurface(params.ctx) ?? null,
-              metadataSource: "registry"
-            }
-          }
-        );
-      })(),
-      new Promise((_, reject) => {
-        setTimeout(() => reject(new OpenClawEpisodeSummaryTimeoutError()), EPISODE_SUMMARY_TIMEOUT_MS);
+  const episodeModelRef = resolveOpenClawEpisodeModelRef(params.services.openClaw, params.ctx.agentId, params.services.pluginConfig.episodeModel);
+  const episodeModel = episodeModelRef ?? "default";
+  const summaryDeadlineMs = writeStartedAtMs + EPISODE_SUMMARY_TIMEOUT_MS;
+  const llm = await createOpenClawLlmClient(params.services.openClaw, episodeModelRef, "episode model override");
+  const summaryLlm = createDeadlineAwareEpisodeSummaryLlm(
+    {
+      complete: llm.complete.bind(llm),
+      completeJson: llm.completeJson.bind(llm),
+      metadata: {
+        modelRef: episodeModel,
+        pricing: {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheWrite: 0
+        },
+        usage: {
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0
+        }
+      }
+    },
+    summaryDeadlineMs
+  );
+  await writeBoundedSingleTranscriptEpisode({
+    filePath: predecessor.sessionFile,
+    context: sessionContext,
+    actionLabel: "session-start predecessor episode write",
+    logger: params.logger,
+    summaryDeadlineMs,
+    fileField: "predecessor",
+    shortCountField: "cleanedMessages",
+    failureModelRef: episodeModel,
+    unexpectedFailureLevel: "info",
+    ports: {
+      files: createSingleTranscriptDiscoveryPort(predecessor.sessionFile),
+      transcript: openClawTranscriptParser,
+      episodes: params.services.episodes,
+      createSummaryLlm: () => summaryLlm,
+      embedSummary: (summary) => embedEpisodeSummaryWithinBudget({
+        summary,
+        embedding: params.services.embedding,
+        embeddingAvailable: params.services.embeddingStatus.available,
+        deadlineMs: summaryDeadlineMs,
+        logger: params.logger,
+        logContext: `[agenr] session-start predecessor episode embedding skipped for ${sessionContext} predecessor=${predecessor.sessionFile}`
       })
-    ]);
-    if (ingestResult.kind === "skipped") {
-      logSkippedEpisodeIngest(sessionContext, predecessor.sessionFile, ingestResult.skipped, params.logger);
-      return;
-    }
-    if (ingestResult.kind === "invalid") {
-      params.logger.info(
-        `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${predecessor.sessionFile} reason=invalid_transcript cleanedMessages=${ingestResult.invalid.messageCount}`
-      );
-      return;
-    }
-    if (ingestResult.session.action === "failed") {
-      logFailedEpisodeIngest(sessionContext, predecessor.sessionFile, ingestResult.session.error, episodeModel, params.logger);
-      return;
-    }
-    params.logger.info(
-      `[agenr] session-start predecessor episode write ${ingestResult.session.action} for ${sessionContext} predecessor=${predecessor.sessionFile} episode=${ingestResult.session.episodeId}`
-    );
-  } catch (error) {
-    if (error instanceof OpenClawEpisodeSummaryTimeoutError) {
-      params.logger.info(
-        `[agenr] session-start predecessor episode write timed_out for ${sessionContext} predecessor=${predecessor.sessionFile} timeoutMs=${EPISODE_SUMMARY_TIMEOUT_MS}`
-      );
-      return;
+    },
+    ingestOptions: {
+      genVersion: OPENCLAW_EPISODE_GENERATOR_VERSION,
+      skipActiveSessionCheck: true,
+      candidateOverrides: {
+        sessionId: predecessor.sessionId,
+        agentId: trimOptionalString(params.ctx.agentId) ?? null,
+        surface: resolveSessionSurface(params.ctx) ?? null,
+        metadataSource: "registry"
+      }
     }
-    params.logger.info(
-      `[agenr] session-start predecessor episode write failed for ${sessionContext} predecessor=${predecessor.sessionFile} reason=${formatErrorMessage2(error)}`
-    );
-  }
+  });
 }
 function resolveSessionSurface(ctx) {
   const sessionKey = ctx.sessionKey?.trim() ?? "";
@@ -2827,152 +1613,6 @@ function resolveSessionSurface(ctx) {
   }
   return void 0;
 }
-function createSingleTranscriptDiscoveryPort(filePath) {
-  return {
-    async discoverFiles(_targetPath) {
-      return [filePath];
-    }
-  };
-}
-async function createOpenClawEpisodeSummaryLlm(params) {
-  const llm = await createOpenClawLlmClient(params.openClaw, params.resolvedModelRef, "episode model override");
-  const usage = createEmptyUsageStats();
-  const completeWithTimeout = async (task) => {
-    usage.calls += 1;
-    const remainingMs = Math.max(0, params.deadlineMs - Date.now());
-    return Promise.race([
-      task,
-      new Promise((_, reject) => {
-        setTimeout(() => reject(new OpenClawEpisodeSummaryTimeoutError()), remainingMs);
-      })
-    ]);
-  };
-  return {
-    complete: async (systemPrompt, userMessage) => completeWithTimeout(llm.complete(systemPrompt, userMessage)),
-    completeJson: async (systemPrompt, userMessage) => {
-      return completeWithTimeout(llm.completeJson(systemPrompt, userMessage));
-    },
-    metadata: {
-      modelRef: params.modelRef,
-      pricing: {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0
-      },
-      usage
-    }
-  };
-}
-function createPredecessorEpisodeEmbeddingStrategy(params) {
-  return async (summary) => maybeEmbedEpisodeSummary({
-    summary,
-    embedding: params.embedding,
-    embeddingAvailable: params.embeddingAvailable,
-    logger: params.logger,
-    sessionContext: params.sessionContext,
-    predecessorFile: params.predecessorFile,
-    deadlineMs: params.deadlineMs
-  });
-}
-function logSkippedEpisodeIngest(sessionContext, predecessorFile, skipped, logger) {
-  if (skipped.reason === "skipped_exists") {
-    logger.info(
-      `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${predecessorFile} reason=already_exists episode=${skipped.existingEpisode?.id}`
-    );
-    return;
-  }
-  if (skipped.reason === "skipped_short") {
-    logger.info(
-      `[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${predecessorFile} reason=too_short cleanedMessages=${skipped.messageCount}`
-    );
-    return;
-  }
-  logger.info(`[agenr] session-start predecessor episode write skipped for ${sessionContext} predecessor=${predecessorFile} reason=${skipped.reason}`);
-}
-function logFailedEpisodeIngest(sessionContext, predecessorFile, error, episodeModel, logger) {
-  if (error === EPISODE_SUMMARY_TIMEOUT_ERROR_MESSAGE) {
-    logger.info(
-      `[agenr] session-start predecessor episode write timed_out for ${sessionContext} predecessor=${predecessorFile} timeoutMs=${EPISODE_SUMMARY_TIMEOUT_MS}`
-    );
-    return;
-  }
-  if (error === "invalid_response") {
-    logger.info(
-      `[agenr] session-start predecessor episode write failed for ${sessionContext} predecessor=${predecessorFile} reason=invalid_response model=${episodeModel}`
-    );
-    return;
-  }
-  logger.info(`[agenr] session-start predecessor episode write failed for ${sessionContext} predecessor=${predecessorFile} reason=${error ?? "unknown"}`);
-}
-async function maybeEmbedEpisodeSummary(params) {
-  if (!params.embeddingAvailable) {
-    params.logger.info(
-      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=embedding_unavailable`
-    );
-    return void 0;
-  }
-  const remainingBudgetMs = params.deadlineMs - Date.now();
-  if (remainingBudgetMs < EPISODE_EMBEDDING_MIN_HEADROOM_MS) {
-    params.logger.info(
-      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=budget_tight remainingMs=${Math.max(
-        0,
-        remainingBudgetMs
-      )}`
-    );
-    return void 0;
-  }
-  try {
-    const result = await awaitEmbeddingWithTimeout(params.embedding.embed([params.summary]), remainingBudgetMs);
-    if (result === EPISODE_EMBEDDING_TIMEOUT) {
-      params.logger.info(
-        `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=embedding_timeout budgetMs=${remainingBudgetMs}`
-      );
-      return void 0;
-    }
-    const vector = result[0]?.map((value) => Number.isFinite(value) ? value : 0);
-    if (!vector || vector.length === 0) {
-      params.logger.info(
-        `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=empty_embedding`
-      );
-      return void 0;
-    }
-    return vector;
-  } catch (error) {
-    params.logger.info(
-      `[agenr] session-start predecessor episode embedding skipped for ${params.sessionContext} predecessor=${params.predecessorFile} reason=${formatErrorMessage2(error)}`
-    );
-    return void 0;
-  }
-}
-async function awaitEmbeddingWithTimeout(promise, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      resolve(EPISODE_EMBEDDING_TIMEOUT);
-    }, timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timeout);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      }
-    );
-  });
-}
-function createEmptyUsageStats() {
-  return {
-    calls: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    totalTokens: 0,
-    totalCost: 0
-  };
-}
 function trimOptionalString(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : void 0;
@@ -3030,80 +1670,6 @@ function truncateSubject(subject) {
   return `${trimmedSubject.slice(0, MAX_SUBJECT_LENGTH - 3).trimEnd()}...`;
 }
 
-// src/adapters/openclaw/format/recall-format.ts
-var MAX_CONTENT_CHARS = 220;
-function formatAgenrSessionStartRecall(patch) {
-  if (patch.contextSections.length === 0 && patch.durableMemory.length === 0) {
-    return "";
-  }
-  const lines = [];
-  for (const section of patch.contextSections) {
-    lines.push(`## ${section.title}`);
-    lines.push(section.content);
-    lines.push("");
-  }
-  const durableSections = buildSections(patch);
-  if (durableSections.length > 0) {
-    const recallLines = [
-      "## Agenr Session Recall",
-      "Use this as prior context. Confirm anything important if the current conversation conflicts with it.",
-      ""
-    ];
-    for (const section of durableSections) {
-      recallLines.push(`### ${section.title}`);
-      for (const item of section.entries) {
-        recallLines.push(formatEntryHeader(item));
-        recallLines.push(...formatEntryBodyLines(item));
-      }
-      recallLines.push("");
-    }
-    lines.push(wrapAgenrMemoryContext(recallLines.join("\n").trim()));
-  }
-  return lines.join("\n").trim();
-}
-function buildSections(patch) {
-  const sections = [];
-  const coreEntries = patch.durableMemory.filter((item) => item.sourceKind === "core");
-  if (coreEntries.length > 0) {
-    sections.push({ title: "Core Memory", entries: coreEntries });
-  }
-  const artifactRecallEntries = patch.durableMemory.filter((item) => item.sourceKind === "artifact_recall");
-  if (artifactRecallEntries.length > 0) {
-    sections.push({ title: "Relevant Durable Memory", entries: artifactRecallEntries });
-  }
-  return sections;
-}
-function formatEntryHeader(item) {
-  const metadata = [
-    `rank ${item.rank}`,
-    item.entry.id,
-    item.entry.type,
-    item.entry.expiry,
-    `importance ${item.entry.importance}`,
-    item.score !== void 0 ? `score ${item.score.toFixed(2)}` : void 0
-  ].filter((value) => value !== void 0);
-  return `- [${metadata.join(" | ")}] ${item.entry.subject}`;
-}
-function formatEntryBodyLines(item) {
-  const lines = [`  ${truncate3(item.entry.content.trim(), MAX_CONTENT_CHARS)}`];
-  lines.push(`  why: ${item.whySurfaced.summary}`);
-  const metadata = [
-    item.entry.tags.length > 0 ? `tags: ${item.entry.tags.join(", ")}` : void 0,
-    item.freshnessLabel ? `freshness: ${item.freshnessLabel}` : void 0,
-    item.provenanceSummary ? `provenance: ${truncate3(item.provenanceSummary, MAX_CONTENT_CHARS)}` : void 0
-  ].filter((value) => value !== void 0);
-  if (metadata.length > 0) {
-    lines.push(`  ${metadata.join(" | ")}`);
-  }
-  return lines;
-}
-function truncate3(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
-  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
-}
-
 // src/adapters/openclaw/session/continuity/continuity-summary-generator.ts
 import * as fs3 from "fs/promises";
 import { resolveAgentEffectiveModelPrimary as resolveAgentEffectiveModelPrimary3, resolveDefaultAgentId as resolveDefaultAgentId3 } from "openclaw/plugin-sdk/agent-runtime";
@@ -3311,10 +1877,10 @@ async function generateAndWriteOpenClawContinuitySummary(params) {
         durationMs
       };
     }
-    debugLog2(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage4(error)}`);
+    debugLog2(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage3(error)}`);
     return {
       status: "failed",
-      reason: formatErrorMessage4(error),
+      reason: formatErrorMessage3(error),
       continuitySummaryPath,
       messageCount: cleanedMessages.length,
       transcriptChars: normalizedTranscript.length,
@@ -3333,7 +1899,7 @@ function normalizeContinuitySummary(value) {
   const trimmed = value.trim();
   return trimmed.replace(/^# .+\n+/u, "").trim();
 }
-function formatErrorMessage4(error) {
+function formatErrorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function resolveOpenClawSummaryModelRef(openClaw, agentId, modelOverride) {
@@ -3847,11 +2413,11 @@ async function renderRecentSessionSection(sessionFile, logger) {
     logger.debug?.(`[agenr] before_prompt_build: recent session tail for file=${sessionFile}: messages=${tail.length} chars=${body.length}`);
     return body;
   } catch (error) {
-    logger.debug?.(`[agenr] before_prompt_build: failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage5(error)}`);
+    logger.debug?.(`[agenr] before_prompt_build: failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage4(error)}`);
     return "";
   }
 }
-function formatErrorMessage5(error) {
+function formatErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function capRecentSession(value, maxChars) {
@@ -4039,22 +2605,6 @@ async function awaitWithTimeout(promise, timeoutMs) {
 }
 
 // src/adapters/openclaw/hooks/before-prompt-build.ts
-var DEFAULT_SESSION_START_POLICY = {
-  maxCoreEntries: 4,
-  maxArtifactRecallEntries: 3,
-  maxDurableEntries: 5,
-  maxArtifactChars: 1200
-};
-var DEFAULT_BEFORE_TURN_POLICY = {
-  maxDurableEntries: 1,
-  maxHighConfidenceDurableEntries: 2,
-  maxRecentTurns: 2,
-  maxQueryChars: 450,
-  maxProcedureCandidates: 3,
-  recallThreshold: 0.6,
-  highConfidenceRecallThreshold: 0.85,
-  procedureThreshold: 0.72
-};
 var NON_USER_TRIGGER_SET = /* @__PURE__ */ new Set(["heartbeat", "cron", "memory"]);
 var DEFAULT_STORE_NUDGE_CONFIG = resolveStoreNudgeConfig(void 0);
 var INLINE_METADATA_SENTINELS2 = [
@@ -4079,6 +2629,10 @@ async function handleAgenrBeforePromptBuild(event, ctx, params) {
   params.logger.info(`[agenr] session-start recall for ${sessionContext}`);
   try {
     const services = await params.servicesPromise;
+    if (services.pluginConfig.memoryPolicy?.sessionStart?.enabled === false) {
+      params.logger.info(`[agenr] session-start recall disabled by memoryPolicy for ${sessionContext}`);
+      return await resolveNonFirstTurnResult(event, ctx, sessionContext, params);
+    }
     const continuity = await resolvePredecessorContinuity(ctx, params.tracker, services, params.logger);
     emitContinuityEvent(services.debugSink, ctx, continuity);
     void writeOpenClawPredecessorEpisode({
@@ -4092,7 +2646,7 @@ async function handleAgenrBeforePromptBuild(event, ctx, params) {
         sessionKey: ctx.sessionKey,
         continuitySummaryText: continuity.continuitySummaryContent,
         recentSessionText: continuity.recentSessionContent,
-        policy: resolveSessionStartPolicy(services)
+        policy: resolveSessionStartPolicy(services.pluginConfig.memoryPolicy)
       },
       services.sessionStart
     );
@@ -4186,7 +2740,12 @@ async function resolveBeforeTurnResult(event, ctx, sessionContext, params) {
     params.logger.debug?.(`[agenr] before_prompt_build: before-turn skipped for ${sessionContext} reason=disabled`);
     return void 0;
   }
-  const currentTurnText = normalizePromptText(event.prompt);
+  const currentTurnText = normalizePromptText(event.prompt, {
+    stripInlineMetadata: true,
+    inlineMetadataSentinels: INLINE_METADATA_SENTINELS2,
+    stripTimestampPrefix: true,
+    stripUserPrefix: true
+  });
   if (!currentTurnText) {
     params.logger.debug?.(`[agenr] before_prompt_build: before-turn skipped for ${sessionContext} reason=empty_prompt`);
     return void 0;
@@ -4196,9 +2755,12 @@ async function resolveBeforeTurnResult(event, ctx, sessionContext, params) {
       {
         sessionKey: ctx.sessionKey,
         currentTurnText,
-        recentTurns: extractRecentTurns(event.messages),
+        recentTurns: extractRecentTurnsFromMessages(
+          event.messages.filter((message) => Boolean(message) && typeof message === "object"),
+          { stripMemoryCheck: true }
+        ),
         trigger: ctx.trigger,
-        policy: resolveBeforeTurnPolicy(services)
+        policy: resolveBeforeTurnPolicy(services.pluginConfig.memoryPolicy)
       },
       services.beforeTurn
     );
@@ -4356,124 +2918,6 @@ function truncateForLog(value, maxChars) {
   }
   return normalized.length <= maxChars ? normalized : `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
 }
-function resolveSessionStartPolicy(services) {
-  return {
-    ...DEFAULT_SESSION_START_POLICY,
-    enableArtifactRecall: services.pluginConfig.memoryPolicy?.sessionStart?.relevantDurableMemory !== false
-  };
-}
-function resolveBeforeTurnPolicy(services) {
-  return {
-    ...DEFAULT_BEFORE_TURN_POLICY,
-    enableProcedureSuggestion: services.pluginConfig.memoryPolicy?.beforeTurn?.procedureSuggestion !== false,
-    ...services.pluginConfig.memoryPolicy?.beforeTurn?.maxDurableEntries !== void 0 ? { maxDurableEntries: services.pluginConfig.memoryPolicy.beforeTurn.maxDurableEntries } : {},
-    ...services.pluginConfig.memoryPolicy?.beforeTurn?.recallThreshold !== void 0 ? { recallThreshold: services.pluginConfig.memoryPolicy.beforeTurn.recallThreshold } : {},
-    ...services.pluginConfig.memoryPolicy?.beforeTurn?.highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold: services.pluginConfig.memoryPolicy.beforeTurn.highConfidenceRecallThreshold } : {},
-    ...services.pluginConfig.memoryPolicy?.beforeTurn?.procedureThreshold !== void 0 ? { procedureThreshold: services.pluginConfig.memoryPolicy.beforeTurn.procedureThreshold } : {}
-  };
-}
-function extractRecentTurns(messages) {
-  const turns = [];
-  for (const message of messages) {
-    if (!message || typeof message !== "object") {
-      continue;
-    }
-    const typed = message;
-    const role = typed.role === "user" || typed.role === "assistant" ? typed.role : void 0;
-    if (!role) {
-      continue;
-    }
-    const text = sanitizeRecentTurnText(extractMessageText(typed.content), role);
-    if (!text) {
-      continue;
-    }
-    turns.push({ role, text });
-  }
-  return turns;
-}
-function extractMessageText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  const blocks = [];
-  for (const block of content) {
-    if (typeof block === "string") {
-      blocks.push(block);
-      continue;
-    }
-    if (!block || typeof block !== "object") {
-      continue;
-    }
-    const typed = block;
-    if (typeof typed.text === "string") {
-      blocks.push(typed.text);
-      continue;
-    }
-    const type = typeof typed.type === "string" ? typed.type.trim().toLowerCase() : "";
-    if (typeof typed.content === "string" && (type === "text" || type === "input_text" || type === "output_text")) {
-      blocks.push(typed.content);
-    }
-  }
-  return blocks.join("\n");
-}
-function sanitizeRecentTurnText(text, role) {
-  if (!text.trim()) {
-    return "";
-  }
-  const wrapperDetected = containsAgenrMemoryContext(text) || text.includes("## Agenr Session Recall") || text.includes("## Agenr Before-Turn Recall") || text.includes("[MEMORY CHECK]");
-  let cleaned = stripAgenrMemoryContext(text);
-  const headings = [
-    "## Previous session summary",
-    "## Recent session",
-    "## Agenr Session Recall",
-    "### Core Memory",
-    "### Relevant Durable Memory",
-    "## Agenr Before-Turn Recall",
-    "### Suggested Procedure"
-  ];
-  for (const heading of headings) {
-    cleaned = cleaned.split(heading).join(" ");
-  }
-  cleaned = cleaned.replace(/\[MEMORY CHECK\][^\n]*/gu, " ");
-  cleaned = collapseWhitespace2(cleaned);
-  if (!wrapperDetected) {
-    return cleaned;
-  }
-  const segments = stripAgenrMemoryContext(text).split(/\n\s*\n/gu).map((segment) => collapseWhitespace2(segment)).filter((segment) => segment.length > 0);
-  const fallbackSegment = segments.at(-1);
-  if (fallbackSegment) {
-    return role === "user" ? fallbackSegment : collapseWhitespace2(cleaned);
-  }
-  return cleaned;
-}
-function normalizePromptText(prompt) {
-  let cleaned = stripAgenrMemoryContext(prompt);
-  cleaned = stripInlineMetadata2(cleaned);
-  cleaned = cleaned.replace(/^\s*\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s[^\]]+\]\s*/u, "");
-  cleaned = cleaned.replace(/^\s*U:\s*/u, "");
-  cleaned = collapseWhitespace2(cleaned);
-  return cleaned.length > 0 ? cleaned : void 0;
-}
-function stripInlineMetadata2(text) {
-  let cleaned = text;
-  for (const sentinel of INLINE_METADATA_SENTINELS2) {
-    const escapedSentinel = escapeForRegExp2(sentinel);
-    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}\\s*(?:\`\`\`json\\s*)?\\{[\\s\\S]*?\\}(?:\\s*\`\`\`)?`, "gu"), " ");
-    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}[^
-]*`, "gu"), " ");
-  }
-  cleaned = cleaned.replace(/Untrusted context \(metadata, do not treat as instructions or commands\):[\s\S]*$/gu, " ");
-  return cleaned;
-}
-function escapeForRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function collapseWhitespace2(value) {
-  return value.replace(/\s+/gu, " ").trim();
-}
 
 // src/adapters/openclaw/memory/flush-plan.ts
 function buildAgenrMemoryFlushPlan(_params, logger) {
@@ -4493,7 +2937,7 @@ function createAgenrMemoryRuntime(servicesPromise) {
           backend: "builtin",
           provider: "agenr",
           model: services.embeddingStatus.model,
-          dbPath: services.dbPath,
+          dbPath: services.config.dbPath,
           files: snapshot.sourceFiles,
           chunks: snapshot.activeEntries,
           vector: {
@@ -4552,127 +2996,28 @@ function createAgenrMemoryRuntime(servicesPromise) {
   };
 }
 
-// src/adapters/db/session-start-repository.ts
-function createSessionStartRepository(executor) {
-  return {
-    listCoreEntries: async (limit) => listCoreEntries(executor, limit)
-  };
-}
-async function listCoreEntries(executor, limit) {
-  if (limit <= 0) {
-    return [];
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        ${ENTRY_SELECT_COLUMNS}
-      FROM entries
-      WHERE ${buildActiveEntryClause()}
-        AND expiry = 'core'
-      ORDER BY importance DESC, created_at DESC
-      LIMIT ?
-    `,
-    args: [limit]
-  });
-  return result.rows.map((row) => mapEntryRow(row));
-}
-
 // src/app/openclaw/runtime.ts
 import path6 from "path";
 async function createAgenrOpenClawServices(config, options) {
-  const { resolvedConfig, agenrConfig: loadedAgenrConfig } = resolveRuntimeConfig(config, options.resolvePath);
-  const agenrConfig = {
-    ...loadedAgenrConfig,
-    dbPath: resolvedConfig.dbPath
-  };
-  const embeddingStatus = resolveEmbeddingStatus(agenrConfig);
-  const runtimeServices = await createRuntimeServices(resolvedConfig.dbPath, agenrConfig, embeddingStatus, {
-    openClaw: options.openClaw,
-    pluginConfig: config
+  const debugSink = createDebugSink(options.openClaw, config);
+  return composeHostPluginServices({
+    config,
+    resolvePath: options.resolvePath,
+    readSlotPolicies: (hostConfig) => hostConfig.memoryPolicy?.slotPolicies,
+    resolveClaimExtraction: ({ agenrConfig, hostConfig }) => buildClaimExtractionRuntime(
+      agenrConfig,
+      () => createOpenClawLlmClient(options.openClaw, hostConfig.claimExtractionModel, "claim extraction model override")
+    ),
+    onBeforeClose: () => debugSink.close(),
+    extend: ({ resolvedConfig, agenrConfig, runtimeServices }) => ({
+      ...runtimeServices,
+      openClaw: options.openClaw,
+      config: resolvedConfig,
+      pluginConfig: config,
+      agenrConfig,
+      debugSink
+    })
   });
-  return {
-    openClaw: options.openClaw,
-    config: resolvedConfig,
-    pluginConfig: config,
-    agenrConfig,
-    dbPath: resolvedConfig.dbPath,
-    entries: runtimeServices.entries,
-    episodes: runtimeServices.episodes,
-    procedures: runtimeServices.procedures,
-    memory: runtimeServices.memory,
-    sessionStart: runtimeServices.sessionStart,
-    beforeTurn: runtimeServices.beforeTurn,
-    embedding: runtimeServices.embedding,
-    recall: runtimeServices.recall,
-    claimExtraction: runtimeServices.claimExtraction,
-    embeddingStatus: toPublicEmbeddingStatus(embeddingStatus),
-    debugSink: runtimeServices.debugSink,
-    close: runtimeServices.close
-  };
-}
-function resolveEmbeddingStatus(config) {
-  const model = resolveEmbeddingModel(config);
-  try {
-    return {
-      available: true,
-      provider: "openai",
-      requestedProvider: "openai",
-      model,
-      apiKey: resolveEmbeddingApiKey(config)
-    };
-  } catch (error) {
-    return {
-      available: false,
-      provider: "unconfigured",
-      requestedProvider: "openai",
-      model,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function createRuntimeServices(dbPath, config, embeddingStatus, openClawContext) {
-  const database = await createDatabase(dbPath);
-  const embedding = embeddingStatus.available ? createEmbeddingClient(requireApiKey(embeddingStatus), embeddingStatus.model) : createUnavailableEmbeddingPort(embeddingStatus.error ?? "Embeddings are unavailable.");
-  const baseRecall = createRecallAdapter(database, embedding);
-  const crossEncoder = resolveCrossEncoder(config);
-  const recall2 = attachCrossEncoderPort(baseRecall, crossEncoder);
-  const claimExtraction = await createClaimExtractionRuntime(config, openClawContext.openClaw, openClawContext.pluginConfig);
-  const debugSink = createDebugSink(openClawContext.openClaw, openClawContext.pluginConfig);
-  let closed = false;
-  return {
-    entries: database,
-    episodes: database,
-    procedures: database,
-    memory: createOpenClawRepository(database, {
-      claimSlotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
-    }),
-    sessionStart: {
-      repository: createSessionStartRepository(database),
-      recall: recall2,
-      slotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
-    },
-    beforeTurn: {
-      recall: recall2,
-      procedures: database,
-      embedQuery: embeddingStatus.available ? async (text) => {
-        const vectors = await embedding.embed([text]);
-        return vectors[0] ?? [];
-      } : void 0,
-      slotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
-    },
-    embedding,
-    recall: recall2,
-    claimExtraction,
-    debugSink,
-    async close() {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      await debugSink.close();
-      await database.close();
-    }
-  };
 }
 function createDebugSink(openClaw, pluginConfig) {
   const resolved = resolveDebugConfig(pluginConfig.debug);
@@ -4696,78 +3041,6 @@ function ensureDebugLogPath(resolved, openClaw) {
     return { ...resolved, enabled: false };
   }
 }
-function toPublicEmbeddingStatus(status) {
-  return {
-    available: status.available,
-    provider: status.provider,
-    requestedProvider: status.requestedProvider,
-    model: status.model,
-    ...status.error ? { error: status.error } : {}
-  };
-}
-function createUnavailableEmbeddingPort(errorMessage) {
-  return {
-    async embed() {
-      throw new Error(errorMessage);
-    }
-  };
-}
-function resolveRuntimeConfig(config, resolvePath) {
-  const dbPathOverride = resolveOptionalPath(config.dbPath, resolvePath);
-  const configPathOverride = resolveOptionalPath(config.configPath, resolvePath);
-  const configPath = resolveConfigPath({
-    configPath: configPathOverride,
-    dbPath: dbPathOverride
-  });
-  const agenrConfig = readConfig({
-    configPath,
-    dbPath: dbPathOverride
-  });
-  const dbPath = dbPathOverride ?? resolveDbPath(agenrConfig);
-  return {
-    resolvedConfig: {
-      dbPath,
-      configPath
-    },
-    agenrConfig
-  };
-}
-function resolveOptionalPath(value, resolvePath) {
-  const normalized = value?.trim();
-  if (!normalized) {
-    return void 0;
-  }
-  return resolvePath ? resolvePath(normalized) : normalized;
-}
-function requireApiKey(status) {
-  if (!status.apiKey) {
-    throw new Error("Embedding API key is unavailable.");
-  }
-  return status.apiKey;
-}
-function resolveCrossEncoder(config) {
-  try {
-    const apiKey = resolveCrossEncoderApiKey(config);
-    const { modelId } = resolveModel(config, "cross_encoder");
-    return createOpenAICrossEncoder({ apiKey, model: modelId });
-  } catch {
-    return void 0;
-  }
-}
-async function createClaimExtractionRuntime(config, openClaw, pluginConfig) {
-  const claimExtractionConfig = resolveClaimExtractionConfig(config);
-  if (!claimExtractionConfig.enabled) {
-    return void 0;
-  }
-  try {
-    return {
-      llm: await createOpenClawLlmClient(openClaw, pluginConfig.claimExtractionModel, "claim extraction model override"),
-      config: claimExtractionConfig
-    };
-  } catch {
-    return void 0;
-  }
-}
 
 // src/adapters/openclaw/index.ts
 var openclaw_default = definePluginEntry({