agenr 2.0.1 → 3.0.0

package/dist/adapters/openclaw/index.js

@@ -1,195 +1,335 @@
 import {
   OpenClawTranscriptParser,
-  createOpenClawRepository,
   deriveOpenClawSessionIdFromFilePath,
-  ingestEpisodeTranscript,
   openClawTranscriptParser,
   parseTuiSessionKey,
-  readOpenClawSessionsStore,
-  storeEntriesDetailed
-} from "../../chunk-XD3446YW.js";
+  readOpenClawSessionsStore
+} from "../../chunk-TBFAARM5.js";
 import {
-  EMBEDDING_DIMENSIONS,
-  ENTRY_TYPES,
-  EXPIRY_LEVELS,
-  createDatabase,
-  createEmbeddingClient,
-  createRecallAdapter,
-  normalizeManualClaimKeyUpdate,
-  readConfig,
-  resolveClaimExtractionConfig,
-  resolveConfigPath,
-  resolveDbPath,
-  resolveEmbeddingApiKey,
-  resolveEmbeddingModel,
-  runUnifiedRecall,
-  validateTemporalValidityRange
-} from "../../chunk-Y2BC7RCE.js";
+  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
+} from "../../chunk-GELCEVFA.js";
+import {
+  EPISODE_SUMMARY_TIMEOUT_MS,
+  RECALL_TOOL_PARAMETERS,
+  STORE_TOOL_PARAMETERS,
+  UPDATE_TOOL_PARAMETERS,
+  asRecord,
+  buildClaimExtractionRuntime,
+  buildRecallToolServices,
+  composeHostPluginServices,
+  createDeadlineAwareEpisodeSummaryLlm,
+  createSessionStartTracker,
+  embedEpisodeSummaryWithinBudget,
+  extractRecentTurnsFromMessages,
+  formatAgenrSessionStartRecall,
+  formatErrorMessage,
+  formatTargetSelector,
+  formatUnifiedRecallResults,
+  normalizeOptionalBoolean,
+  normalizeOptionalPositiveInteger,
+  normalizePluginInjectionMemoryPolicyConfig,
+  normalizePromptText,
+  parseRecallToolParams,
+  parseStoreToolParams,
+  parseUpdateToolParams,
+  readBooleanParam,
+  resolveBeforeTurnPolicy,
+  resolveSessionIdentityKey,
+  resolveSessionStartPolicy,
+  resolveTargetEntry,
+  runRecallMemoryTool,
+  runSessionStart,
+  runStoreMemoryTool,
+  runUpdateMemoryTool,
+  sanitizeUpdateToolParams,
+  writeBoundedSingleTranscriptEpisode
+} from "../../chunk-MYZ2CWY6.js";
+import {
+  createSingleTranscriptDiscoveryPort
+} from "../../chunk-LAXNNWHM.js";
+import {
+  buildRecallToolDetails,
+  containsAgenrMemoryContext,
+  formatAgenrBeforeTurnRecall,
+  formatRecallToolSummary,
+  formatUnifiedRecallLogSummary,
+  runBeforeTurn,
+  sanitizeRecallToolParams,
+  sanitizeStoreToolParams,
+  stripAgenrMemoryContext,
+  truncate
+} from "../../chunk-575MUIW5.js";
+import {
+  EMBEDDING_DIMENSIONS
+} from "../../chunk-ELR2HSVC.js";
 import {
   resolveClaimSlotPolicy
-} from "../../chunk-MEHOGUZE.js";
+} from "../../chunk-5LADPJ4C.js";
 
 // src/adapters/openclaw/index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 
 // src/adapters/openclaw/tools/recall.ts
-import { readNumberParam, readStringArrayParam, readStringParam as readStringParam2, textResult } from "openclaw/plugin-sdk/agent-runtime";
+import { textResult as textResult2 } from "openclaw/plugin-sdk/agent-runtime";
+import { randomUUID } from "crypto";
 
-// 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}.`);
-    }
-    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;
+// src/adapters/openclaw/debug/sink.ts
+import { appendFile, mkdir } from "fs/promises";
+import path from "path";
+var NOOP_SINK = {
+  enabled: false,
+  eventLevel: "basic",
+  maxTopCandidates: 0,
+  async emit() {
+    return;
+  },
+  async close() {
+    return;
   }
-  throw new Error(`${key} must be a boolean.`);
+};
+function createNoopAgenrDebugSink() {
+  return NOOP_SINK;
+}
+function createAgenrDebugSink(config) {
+  if (!config.enabled || !config.logPath) {
+    return NOOP_SINK;
+  }
+  const basePath = config.logPath;
+  const perSessionFiles = config.perSessionFiles;
+  const eventLevel = config.eventLevel;
+  const maxTopCandidates = config.maxTopCandidates;
+  const directoriesEnsured = /* @__PURE__ */ new Set();
+  let writeChain = Promise.resolve();
+  let closed = false;
+  const ensureDirectoryOnce = async (filePath) => {
+    const directory = path.dirname(filePath);
+    if (directoriesEnsured.has(directory)) {
+      return;
+    }
+    await mkdir(directory, { recursive: true });
+    directoriesEnsured.add(directory);
+  };
+  const resolveFilePath = (event) => {
+    if (!perSessionFiles) {
+      return basePath;
+    }
+    const sessionSuffix = sanitizeSessionSuffix(event.sessionId) ?? sanitizeSessionSuffix(event.sessionKey);
+    if (!sessionSuffix) {
+      return basePath;
+    }
+    const directory = path.dirname(basePath);
+    const extension = path.extname(basePath);
+    const baseName = path.basename(basePath, extension);
+    const suffixed = `${baseName}.${sessionSuffix}${extension || ".jsonl"}`;
+    return path.join(directory, suffixed);
+  };
+  const writeLine = async (filePath, line) => {
+    await ensureDirectoryOnce(filePath);
+    await appendFile(filePath, `${line}
+`, "utf8");
+  };
+  return {
+    enabled: true,
+    eventLevel,
+    maxTopCandidates,
+    logPath: basePath,
+    async emit(event) {
+      if (closed) {
+        return;
+      }
+      const filePath = resolveFilePath(event);
+      const line = formatEventLine(event);
+      writeChain = writeChain.then(async () => {
+        try {
+          await writeLine(filePath, line);
+        } catch {
+        }
+      });
+      await writeChain;
+    },
+    async close() {
+      closed = true;
+      await writeChain;
+    }
+  };
 }
-function parseEntryTypes(values) {
-  return normalizeStringArray(values).map((value) => parseEntryType(value));
+function formatEventLine(event) {
+  const line = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...event
+  };
+  return JSON.stringify(line);
 }
-function parseRecallMode(value) {
-  if (value === void 0) {
+function sanitizeSessionSuffix(value) {
+  if (typeof value !== "string") {
     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;
-  }
-  throw new Error(`Unsupported entry type "${value}".`);
-}
-function parseExpiry(value) {
-  if (value === void 0) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
     return void 0;
   }
-  if (EXPIRY_LEVELS.includes(value)) {
-    return value;
-  }
-  throw new Error(`Unsupported expiry "${value}".`);
-}
-function normalizeStringArray(values) {
-  if (!values) {
-    return [];
+  const sanitized = trimmed.replace(/[^A-Za-z0-9._-]+/gu, "_");
+  if (sanitized.length === 0) {
+    return void 0;
   }
-  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}`;
+  return sanitized.slice(0, 120);
 }
-function buildToolCallClaimSupport(ctx, toolName, observedAt) {
+
+// src/adapters/openclaw/debug/build-before-turn-artifact.ts
+function buildLiveBeforeTurnDebugArtifact(params) {
+  const { caseId, patch, currentTurnText, trigger, eventLevel, maxTopCandidates } = params;
+  const diagnostics = patch.diagnostics;
+  const includeCandidateBreakdown = eventLevel === "detailed";
+  const topK = includeCandidateBreakdown ? clampTopK(maxTopCandidates) : 0;
+  const durableTopCandidates = includeCandidateBreakdown ? buildDurableCandidates(patch, topK) : [];
+  const procedureTopCandidates = includeCandidateBreakdown ? buildProcedureCandidates(patch, topK) : [];
+  const normalizedTrigger = trigger?.trim() || "unspecified";
   return {
-    claim_support_source_kind: "tool_call",
-    claim_support_locator: `${buildSessionSourceFile(ctx)}#${toolName}`,
-    claim_support_observed_at: observedAt,
-    claim_support_mode: "explicit"
+    schemaVersion: "before-turn-debug-artifact.v1",
+    caseId,
+    input: {
+      trigger: normalizedTrigger,
+      currentTurnText
+    },
+    ...diagnostics.queryPolicy ? { queryPolicy: diagnostics.queryPolicy } : {},
+    ...diagnostics.queryVariants.length > 0 ? { queryVariants: [...diagnostics.queryVariants] } : {},
+    ...diagnostics.abstentionReasons.length > 0 ? { abstentionReasons: [...diagnostics.abstentionReasons] } : {},
+    selectedEntryIds: patch.durableMemory.map((item) => item.entry.id),
+    selectedProcedureKey: patch.procedure?.procedure.procedure_key ?? null,
+    ...durableTopCandidates.length > 0 ? { durableRecallTopCandidates: durableTopCandidates } : {},
+    ...procedureTopCandidates.length > 0 ? { procedureTopCandidates } : {}
   };
 }
-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";
+function clampTopK(requested) {
+  if (!Number.isFinite(requested) || !Number.isInteger(requested)) {
+    return BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K;
+  }
+  if (requested < 1) {
+    return 0;
   }
-  if (id) {
-    return `id:${JSON.stringify(id)}`;
+  if (requested > BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K) {
+    return BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K;
+  }
+  return requested;
+}
+function buildDurableCandidates(patch, topK) {
+  if (topK < 1) {
+    return [];
   }
-  if (subject) {
-    return `subject:${JSON.stringify(subject)}`;
+  return patch.durableMemory.slice(0, topK).map((item) => {
+    const reasons = item.whySurfaced.reasons.length > 0 ? [...item.whySurfaced.reasons] : void 0;
+    return {
+      id: item.entry.id,
+      score: item.score,
+      ...reasons ? { reasons } : {}
+    };
+  });
+}
+function buildProcedureCandidates(patch, topK) {
+  if (!patch.procedure || topK < 1) {
+    return [];
   }
-  return "unknown";
+  const reasons = patch.procedure.whySurfaced.reasons.length > 0 ? [...patch.procedure.whySurfaced.reasons] : void 0;
+  return [
+    {
+      procedureKey: patch.procedure.procedure.procedure_key,
+      score: patch.procedure.score,
+      ...reasons ? { reasons } : {}
+    }
+  ];
 }
-function sanitizeStoreToolParams(params) {
+
+// src/adapters/openclaw/debug/build-recall-artifact.ts
+function buildLiveRecallDebugArtifact(params) {
+  const { caseId, query, result, eventLevel, maxTopCandidates } = params;
+  const selectedEntryIds = result.entries.map((entry) => entry.entry.id);
+  const includeCandidateBreakdown = eventLevel === "detailed";
+  const topK = includeCandidateBreakdown ? clampTopK2(maxTopCandidates) : 0;
+  const reasonsByEntryId = /* @__PURE__ */ new Map();
+  for (const projected of result.projectedEntries) {
+    if (projected.whySurfaced.reasons.length > 0) {
+      reasonsByEntryId.set(projected.entryId, [...projected.whySurfaced.reasons]);
+    }
+  }
+  const topCandidates = includeCandidateBreakdown ? buildTopCandidates(result, reasonsByEntryId, topK) : [];
   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 } : {}
+    schemaVersion: "recall-debug-artifact.v1",
+    caseId,
+    request: {
+      recallPath: "unified",
+      query
+    },
+    routing: result.routing,
+    selectedEntryIds,
+    ...topCandidates.length > 0 ? { topCandidates } : {}
   };
 }
-function formatRecallToolSummary(params) {
-  const parts = [`query=${JSON.stringify(truncate(params.query, 80))}`];
-  if (params.mode) {
-    parts.push(`mode=${params.mode}`);
+function clampTopK2(requested) {
+  if (!Number.isFinite(requested) || !Number.isInteger(requested)) {
+    return RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K;
   }
-  if (params.limit !== void 0 && params.limit !== DEFAULT_RECALL_LIMIT) {
-    parts.push(`limit=${params.limit}`);
+  if (requested < 1) {
+    return 0;
   }
-  if (params.types.length > 0) {
-    parts.push(`types=${JSON.stringify(params.types)}`);
+  if (requested > RECALL_DEBUG_ARTIFACT_MAX_TOP_K) {
+    return RECALL_DEBUG_ARTIFACT_MAX_TOP_K;
   }
-  if (params.tags.length > 0) {
-    parts.push(`tags=${JSON.stringify(params.tags)}`);
+  return requested;
+}
+function buildTopCandidates(result, reasonsByEntryId, topK) {
+  if (topK < 1) {
+    return [];
   }
-  if (params.asOf) {
-    parts.push(`as_of=${JSON.stringify(params.asOf)}`);
+  return result.entries.slice(0, topK).map((entry) => {
+    const reasons = reasonsByEntryId.get(entry.entry.id);
+    return {
+      id: entry.entry.id,
+      score: entry.score,
+      lexicalScore: entry.scores.lexical,
+      vectorScore: entry.scores.vector,
+      recencyScore: entry.scores.recency,
+      importanceScore: entry.scores.importance,
+      ...reasons && reasons.length > 0 ? { reasons } : {}
+    };
+  });
+}
+
+// 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 parts.join(" ");
+  return textResult(outcome.text, outcome.details);
 }
-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 } : {}
-  };
+async function resolveTargetEntry2(services, params, options = {}) {
+  return resolveTargetEntry(
+    {
+      getEntryById: async (id) => await services.entries.getEntry(id) ?? (await services.memory.getEntryTrace(id))?.entry ?? null,
+      findEntryBySubject: async (subject) => services.memory.findEntryBySubject(subject),
+      findMostRecentEntry: async () => services.memory.findMostRecentEntry()
+    },
+    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 {
@@ -198,17 +338,6 @@ function sanitizeRetireToolParams(params) {
     ...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 } : {},
@@ -216,211 +345,6 @@ function sanitizeTraceToolParams(params) {
     ...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,
@@ -469,29 +393,11 @@ function formatTrace(entry, supersededBy, supersedes, claimFamily, recallEvents)
   }
   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();
@@ -506,33 +412,6 @@ function formatToolSessionContext(ctx) {
   }
   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";
@@ -564,51 +443,6 @@ function summarizeTraceClaimFamilyTransition(entries) {
 }
 
 // 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",
@@ -617,155 +451,94 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
     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 params = parseRecallToolParams(rawParams, OPENCLAW_PARAM_READER);
+        const sanitizedParams = sanitizeRecallToolParams(params);
+        logToolCall(logger, "agenr_recall", ctx, formatRecallToolSummary(params), sanitizedParams);
         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
-        };
-        logToolCall(
-          logger,
-          "agenr_recall",
-          ctx,
-          formatRecallToolSummary({
-            query,
-            mode,
-            limit,
-            types,
-            tags,
-            ...asOf ? { asOf } : {}
-          }),
-          sanitizeRecallToolParams({
-            query,
-            mode,
-            limit,
-            threshold,
-            types,
-            tags,
-            ...asOf ? { asOf } : {}
-          })
-        );
-        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,
+        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);
-          },
-          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)}`
         );
-        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
-        });
+        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);
       }
     }
   };
 }
+function emitRecallDebugArtifacts(services, ctx, query, result) {
+  if (!services.debugSink.enabled) {
+    return;
+  }
+  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
+    })
+  });
+}
+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 {
+  }
+}
 
 // src/adapters/openclaw/tools/retire.ts
-import { failedTextResult as failedTextResult2, readStringParam as readStringParam3, textResult as textResult2 } from "openclaw/plugin-sdk/agent-runtime";
+import { failedTextResult as failedTextResult2, readStringParam as readStringParam2, textResult as textResult3 } from "openclaw/plugin-sdk/agent-runtime";
 var RETIRE_TOOL_PARAMETERS = {
   type: "object",
   additionalProperties: false,
@@ -793,12 +566,12 @@ function createAgenrRetireTool(ctx, servicesPromise, logger) {
     async execute(_toolCallId, rawParams) {
       try {
         const params = asRecord(rawParams);
-        const id = readStringParam3(params, "id");
-        const subject = readStringParam3(params, "subject");
-        const reason = readStringParam3(params, "reason");
+        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 resolveTargetEntry(services, params);
+        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.`, {
@@ -806,7 +579,7 @@ function createAgenrRetireTool(ctx, servicesPromise, logger) {
             entryId: entry.id
           });
         }
-        return textResult2(`Retired "${entry.subject}".`, {
+        return textResult3(`Retired "${entry.subject}".`, {
           status: "retired",
           entryId: entry.id,
           subject: entry.subject,
@@ -821,63 +594,6 @@ function createAgenrRetireTool(ctx, servicesPromise, logger) {
 }
 
 // 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",
@@ -886,95 +602,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);
@@ -984,7 +622,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,
@@ -1012,15 +650,15 @@ 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
           });
@@ -1045,41 +683,6 @@ function createAgenrTraceTool(ctx, servicesPromise, logger) {
 }
 
 // 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."
-    }
-  }
-};
 function createAgenrUpdateTool(ctx, servicesPromise, logger) {
   return {
     name: "agenr_update",
@@ -1088,72 +691,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);
@@ -1175,7 +736,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "2.0.1",
+  version: "3.0.0",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {
@@ -1208,7 +769,11 @@ var openclaw_plugin_default = {
     },
     memoryPolicy: {
       label: "Memory policy",
-      help: "Optional runtime overrides for claim-aware read behavior such as slot-policy classes."
+      help: "Optional runtime overrides for claim-aware read behavior, session-start memory injection, and proactive before-turn surfacing."
+    },
+    debug: {
+      label: "Debug log",
+      help: "Optional opt-in JSONL debug sink that records recall, session-start, and before-turn decisions into a dedicated agenr log file separate from OpenClaw host logs."
     }
   },
   configSchema: {
@@ -1259,11 +824,99 @@ var openclaw_plugin_default = {
           }
         }
       },
+      debug: {
+        type: "object",
+        additionalProperties: false,
+        description: "Optional opt-in JSONL debug sink for live OpenClaw runs. Writes agenr-only events to a dedicated log file rather than the shared host log.",
+        properties: {
+          enabled: {
+            type: "boolean",
+            description: "Enable or disable the agenr JSONL debug sink. Defaults to false."
+          },
+          logPath: {
+            type: "string",
+            minLength: 1,
+            description: "Optional explicit log-file path. Defaults to agenr-debug.jsonl inside the OpenClaw state directory."
+          },
+          eventLevel: {
+            type: "string",
+            enum: ["basic", "detailed"],
+            description: "Event detail level. Detailed enables bounded top-K candidate breakdowns for recall and before-turn events. Defaults to basic."
+          },
+          perSessionFiles: {
+            type: "boolean",
+            description: "Split one JSONL file per OpenClaw session id. Defaults to false."
+          },
+          maxTopCandidates: {
+            type: "integer",
+            minimum: 1,
+            maximum: 25,
+            description: "Cap for top-K candidate breakdowns included in detailed events. Defaults to 10."
+          }
+        }
+      },
       memoryPolicy: {
         type: "object",
         additionalProperties: false,
         description: "Optional runtime overrides for claim-aware read behavior exposed by the OpenClaw adapter.",
         properties: {
+          sessionStart: {
+            type: "object",
+            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."
+              }
+            }
+          },
+          beforeTurn: {
+            type: "object",
+            additionalProperties: false,
+            description: "Optional before-turn overrides for proactive prompt-time memory injection behavior.",
+            properties: {
+              enabled: {
+                type: "boolean",
+                description: "Enable or disable the proactive before-turn memory patch. Defaults to true."
+              },
+              procedureSuggestion: {
+                type: "boolean",
+                description: "Enable or disable proactive high-confidence procedure suggestion inside the before-turn patch. Defaults to true."
+              },
+              maxDurableEntries: {
+                type: "integer",
+                minimum: 1,
+                description: "Normal durable-item cap for before-turn recall. Defaults to 1 and only expands when all surfaced items are very high confidence."
+              },
+              recallThreshold: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                description: "Durable-recall score threshold required before an entry can surface during before-turn recall. Defaults to 0.6."
+              },
+              highConfidenceRecallThreshold: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                description: "Durable-recall score threshold required before before-turn recall can expand beyond the normal durable-item cap. Defaults to 0.85."
+              },
+              procedureThreshold: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                description: "Procedure-recall score threshold required before a proactive procedure can surface. Defaults to 0.72."
+              }
+            }
+          },
           slotPolicies: {
             type: "object",
             additionalProperties: false,
@@ -1292,6 +945,10 @@ var openclaw_plugin_default = {
 var manifest = openclaw_plugin_default;
 var DEFAULT_STORE_NUDGE_THRESHOLD = 8;
 var DEFAULT_STORE_NUDGE_MAX_PER_SESSION = 5;
+var DEFAULT_DEBUG_EVENT_LEVEL = "basic";
+var DEFAULT_DEBUG_PER_SESSION_FILES = false;
+var DEFAULT_DEBUG_MAX_TOP_CANDIDATES = 10;
+var MAX_DEBUG_MAX_TOP_CANDIDATES = 25;
 function normalizeAgenrOpenClawPluginConfig(value) {
   if (value === void 0) {
     return { ok: true, value: {} };
@@ -1335,11 +992,15 @@ 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);
   }
-  const allowedKeys = /* @__PURE__ */ new Set(["dbPath", "configPath", "continuityModel", "episodeModel", "claimExtractionModel", "storeNudge", "memoryPolicy"]);
+  const debugResult = normalizeDebugConfig(value.debug);
+  if (!debugResult.ok) {
+    errors.push(...debugResult.errors);
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["dbPath", "configPath", "continuityModel", "episodeModel", "claimExtractionModel", "storeNudge", "memoryPolicy", "debug"]);
   for (const key of Object.keys(value)) {
     if (!allowedKeys.has(key)) {
       errors.push(`unknown config field: ${key}`);
@@ -1357,7 +1018,8 @@ function normalizeAgenrOpenClawPluginConfig(value) {
       ...episodeModel ? { episodeModel } : {},
       ...claimExtractionModel ? { claimExtractionModel } : {},
       ...storeNudgeResult.ok && storeNudgeResult.value ? { storeNudge: storeNudgeResult.value } : {},
-      ...memoryPolicyResult.ok && memoryPolicyResult.value ? { memoryPolicy: memoryPolicyResult.value } : {}
+      ...memoryPolicyResult.ok && memoryPolicyResult.value ? { memoryPolicy: memoryPolicyResult.value } : {},
+      ...debugResult.ok && debugResult.value ? { debug: debugResult.value } : {}
     }
   };
 }
@@ -1381,137 +1043,115 @@ function createAgenrOpenClawPluginConfigSchema() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function resolveStoreNudgeConfig(value) {
+function resolveDebugConfig(value) {
+  const logPath = value?.logPath?.trim();
   return {
-    enabled: value?.enabled ?? true,
-    threshold: value?.threshold ?? DEFAULT_STORE_NUDGE_THRESHOLD,
-    maxPerSession: value?.maxPerSession ?? DEFAULT_STORE_NUDGE_MAX_PER_SESSION
+    enabled: value?.enabled ?? false,
+    ...logPath ? { logPath } : {},
+    eventLevel: value?.eventLevel ?? DEFAULT_DEBUG_EVENT_LEVEL,
+    perSessionFiles: value?.perSessionFiles ?? DEFAULT_DEBUG_PER_SESSION_FILES,
+    maxTopCandidates: value?.maxTopCandidates ?? DEFAULT_DEBUG_MAX_TOP_CANDIDATES
   };
 }
-function normalizeStoreNudgeConfig(value) {
+function normalizeDebugConfig(value) {
   if (value === void 0) {
     return { ok: true, value: void 0 };
   }
   if (!isRecord(value)) {
-    return { ok: false, errors: ["storeNudge must be an object when provided"] };
+    return { ok: false, errors: ["debug must be an object when provided"] };
   }
   const errors = [];
-  const enabled = normalizeOptionalBoolean(value.enabled, "storeNudge.enabled", errors);
-  const threshold = normalizeOptionalPositiveInteger(value.threshold, "storeNudge.threshold", errors);
-  const maxPerSession = normalizeOptionalPositiveInteger(value.maxPerSession, "storeNudge.maxPerSession", errors);
-  const allowedKeys = /* @__PURE__ */ new Set(["enabled", "threshold", "maxPerSession"]);
+  const enabled = normalizeOptionalBoolean(value.enabled, "debug.enabled", errors);
+  const logPathRaw = value.logPath;
+  let logPath;
+  if (logPathRaw !== void 0) {
+    if (typeof logPathRaw !== "string" || logPathRaw.trim().length === 0) {
+      errors.push("debug.logPath must be a non-empty string when provided");
+    } else {
+      logPath = logPathRaw.trim();
+    }
+  }
+  const eventLevel = normalizeOptionalDebugEventLevel(value.eventLevel, errors);
+  const perSessionFiles = normalizeOptionalBoolean(value.perSessionFiles, "debug.perSessionFiles", errors);
+  const maxTopCandidates = normalizeOptionalTopCandidateCap(value.maxTopCandidates, errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["enabled", "logPath", "eventLevel", "perSessionFiles", "maxTopCandidates"]);
   for (const key of Object.keys(value)) {
     if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: storeNudge.${key}`);
+      errors.push(`unknown config field: debug.${key}`);
     }
   }
   if (errors.length > 0) {
     return { ok: false, errors };
   }
-  const normalizedValue = {
+  const normalized = {
     ...enabled !== void 0 ? { enabled } : {},
-    ...threshold !== void 0 ? { threshold } : {},
-    ...maxPerSession !== void 0 ? { maxPerSession } : {}
+    ...logPath !== void 0 ? { logPath } : {},
+    ...eventLevel !== void 0 ? { eventLevel } : {},
+    ...perSessionFiles !== void 0 ? { perSessionFiles } : {},
+    ...maxTopCandidates !== void 0 ? { maxTopCandidates } : {}
   };
   return {
     ok: true,
-    value: Object.keys(normalizedValue).length > 0 ? resolveStoreNudgeConfig(normalizedValue) : void 0
+    value: Object.keys(normalized).length > 0 ? normalized : void 0
   };
 }
-function normalizeMemoryPolicyConfig(value) {
+function normalizeOptionalDebugEventLevel(value, errors) {
   if (value === void 0) {
-    return { ok: true, value: void 0 };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["memoryPolicy must be an object when provided"] };
+    return void 0;
   }
-  const errors = [];
-  const slotPoliciesResult = normalizeClaimSlotPolicyConfig(value.slotPolicies);
-  if (!slotPoliciesResult.ok) {
-    errors.push(...slotPoliciesResult.errors);
+  if (value === "basic" || value === "detailed") {
+    return value;
   }
-  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.${key}`);
-    }
+  errors.push('debug.eventLevel must be "basic" or "detailed" when provided');
+  return void 0;
+}
+function normalizeOptionalTopCandidateCap(value, errors) {
+  if (value === void 0) {
+    return void 0;
   }
-  if (errors.length > 0) {
-    return { ok: false, errors };
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0 || value > MAX_DEBUG_MAX_TOP_CANDIDATES) {
+    errors.push(`debug.maxTopCandidates must be an integer between 1 and ${MAX_DEBUG_MAX_TOP_CANDIDATES} when provided`);
+    return void 0;
   }
+  return value;
+}
+function resolveStoreNudgeConfig(value) {
   return {
-    ok: true,
-    value: slotPoliciesResult.ok && slotPoliciesResult.value ? {
-      slotPolicies: slotPoliciesResult.value
-    } : void 0
+    enabled: value?.enabled ?? true,
+    threshold: value?.threshold ?? DEFAULT_STORE_NUDGE_THRESHOLD,
+    maxPerSession: value?.maxPerSession ?? DEFAULT_STORE_NUDGE_MAX_PER_SESSION
   };
 }
-function normalizeClaimSlotPolicyConfig(value) {
+function normalizeStoreNudgeConfig(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"] };
+    return { ok: false, errors: ["storeNudge must be an object when provided"] };
   }
   const errors = [];
-  const attributeHeads = normalizeClaimSlotPolicyAttributeHeads(value.attributeHeads, errors);
-  const allowedKeys = /* @__PURE__ */ new Set(["attributeHeads"]);
+  const enabled = normalizeOptionalBoolean(value.enabled, "storeNudge.enabled", errors);
+  const threshold = normalizeOptionalPositiveInteger(value.threshold, "storeNudge.threshold", errors);
+  const maxPerSession = normalizeOptionalPositiveInteger(value.maxPerSession, "storeNudge.maxPerSession", errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["enabled", "threshold", "maxPerSession"]);
   for (const key of Object.keys(value)) {
     if (!allowedKeys.has(key)) {
-      errors.push(`unknown config field: memoryPolicy.slotPolicies.${key}`);
+      errors.push(`unknown config field: storeNudge.${key}`);
     }
   }
   if (errors.length > 0) {
     return { ok: false, errors };
   }
+  const normalizedValue = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...threshold !== void 0 ? { threshold } : {},
+    ...maxPerSession !== void 0 ? { maxPerSession } : {}
+  };
   return {
     ok: true,
-    value: attributeHeads ? { attributeHeads } : void 0
+    value: Object.keys(normalizedValue).length > 0 ? resolveStoreNudgeConfig(normalizedValue) : 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;
-}
 
 // src/adapters/openclaw/format/prompt-section.ts
 var MEMORY_TOOL_NAMES = {
@@ -1535,10 +1175,11 @@ function buildAgenrMemoryPromptSection({
   );
   const lines = [
     "## 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; use agenr_recall mid-session when you need context you do not already have.",
+    "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.",
     "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.",
     "Memory authority, strongest to weakest:",
     "- Durable entries are the canonical record for verified facts, decisions, preferences, and lessons unless live evidence contradicts them.",
     "- Episode recall explains what happened in completed sessions, but it is a narrative summary, not an exact log.",
@@ -1606,62 +1247,10 @@ function formatSessionContext(sessionId, sessionKey) {
   return "session=unknown";
 }
 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;
-    }
-  };
+  return error instanceof Error ? error.message : String(error);
 }
-var MAX_STORED_SUBJECTS = 5;
+
+// src/adapters/openclaw/session/state.ts
 function createMidSessionTracker() {
   const states = /* @__PURE__ */ new Map();
   return {
@@ -1724,6 +1313,7 @@ function createMidSessionState() {
     storedSubjects: []
   };
 }
+var MAX_STORED_SUBJECTS = 5;
 
 // src/adapters/openclaw/hooks/after-tool-call.ts
 var STORE_TOOL_NAME = "agenr_store";
@@ -1800,16 +1390,20 @@ function hasNonEmptyString(value) {
   return readString(value) !== void 0;
 }
 
+// src/adapters/openclaw/hooks/before-prompt-build.ts
+import { randomUUID as randomUUID2 } from "crypto";
+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";
 import os from "os";
-import path from "path";
+import path2 from "path";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER, parseModelRef, resolveAgentEffectiveModelPrimary, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 function resolveOpenClawEmbeddedAgentExecution(params) {
   const agentId = params.requestedAgentId?.trim() || resolveDefaultAgentId(params.openClaw.config);
@@ -1906,19 +1500,6 @@ function normalizeOptionalString(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();
@@ -1928,78 +1509,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() ?? "";
@@ -2012,152 +1585,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;
@@ -2215,74 +1642,20 @@ function truncateSubject(subject) {
   return `${trimmedSubject.slice(0, MAX_SUBJECT_LENGTH - 3).trimEnd()}...`;
 }
 
-// src/adapters/openclaw/format/recall-format.ts
-var MAX_CONTENT_CHARS = 280;
-function formatAgenrSessionStartRecall(recall) {
-  const sections = buildSections(recall);
-  if (sections.length === 0) {
-    return "";
-  }
-  const lines = ["## Agenr Session Recall", "Use this as prior context. Confirm anything important if the current conversation conflicts with it.", ""];
-  for (const section of sections) {
-    lines.push(`### ${section.title}`);
-    for (const item of section.entries) {
-      lines.push(formatEntryHeader(item));
-      lines.push(formatEntryBody(item.entry));
-    }
-    lines.push("");
-  }
-  return lines.join("\n").trim();
-}
-function buildSections(recall) {
-  const sections = [];
-  const coreEntries = recall.core.map((entry) => ({ entry }));
-  if (coreEntries.length > 0) {
-    sections.push({ title: "Core Memory", entries: coreEntries });
-  }
-  return sections;
-}
-function formatEntryHeader(item) {
-  const metadata = [
-    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 formatEntryBody(entry) {
-  const content = truncate2(entry.content.trim(), MAX_CONTENT_CHARS);
-  const extra = [
-    entry.tags.length > 0 ? `tags: ${entry.tags.join(", ")}` : void 0,
-    entry.created_at ? `created: ${entry.created_at.slice(0, 10)}` : void 0
-  ].filter((value) => value !== void 0);
-  if (extra.length === 0) {
-    return `  ${content}`;
-  }
-  return `  ${content} (${extra.join(" | ")})`;
-}
-function truncate2(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";
 
 // src/adapters/openclaw/session/continuity/continuity-summary-reader.ts
 import * as fs2 from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 function resolveOpenClawContinuitySummaryPath(sessionFile, logger) {
   const normalizedSessionFile = sessionFile.trim();
   const sessionId = deriveOpenClawSessionIdFromFilePath(normalizedSessionFile, logger);
   if (!sessionId) {
     return void 0;
   }
-  const continuitySummaryPath = path2.join(path2.dirname(normalizedSessionFile), `${sessionId}.continuity-summary.md`);
+  const continuitySummaryPath = path3.join(path3.dirname(normalizedSessionFile), `${sessionId}.continuity-summary.md`);
   debugLog(logger, "continuity-summary-reader", `resolved continuity summary path for session=${sessionId}: ${continuitySummaryPath}`);
   return continuitySummaryPath;
 }
@@ -2538,7 +1911,7 @@ function trimToBoundary(value, fromStart) {
 
 // src/adapters/openclaw/session/continuity/predecessor-resolver.ts
 import * as fs4 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 
 // src/adapters/openclaw/session/session-key-parser.ts
 var AGENT_SESSION_KEY_PATTERN = /^agent:([^:]+):(.+)$/i;
@@ -2761,15 +2134,15 @@ async function findResumedFromTranscriptCandidates(sessionsDir, sessionId, logge
       }
       const fileName = entry.name.trim();
       if (fileName === prefix) {
-        liveMatches.push(path3.join(sessionsDir, fileName));
+        liveMatches.push(path4.join(sessionsDir, fileName));
         continue;
       }
       if (fileName.startsWith(`${prefix}.reset.`)) {
-        resetMatches.push(path3.join(sessionsDir, fileName));
+        resetMatches.push(path4.join(sessionsDir, fileName));
         continue;
       }
       if (fileName.startsWith(`${prefix}.deleted.`)) {
-        deletedMatches.push(path3.join(sessionsDir, fileName));
+        deletedMatches.push(path4.join(sessionsDir, fileName));
       }
     }
     const ordered = [
@@ -2945,7 +2318,7 @@ function resolveOpenClawSessionsDirectory(ctx, parsedAgentId, resolveStateDir) {
   if (!agentId) {
     return void 0;
   }
-  return path3.join(resolveStateDir(process.env), "agents", agentId, "sessions");
+  return path4.join(resolveStateDir(process.env), "agents", agentId, "sessions");
 }
 function isSameTuiLane(currentStableLane, candidateStableLane) {
   if (!currentStableLane || !candidateStableLane) {
@@ -2957,7 +2330,7 @@ function isSameTuiLane(currentStableLane, candidateStableLane) {
   return currentStableLane === candidateStableLane;
 }
 function compareArchivePathsDescending(left, right) {
-  return path3.basename(right).localeCompare(path3.basename(left));
+  return path4.basename(right).localeCompare(path4.basename(left));
 }
 function debugLog3(logger, subsystem, message) {
   logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
@@ -2983,11 +2356,32 @@ function formatSessionContext2(sessionId, sessionKey) {
 // src/adapters/openclaw/session/continuity/recent-session.ts
 var RECENT_SESSION_MESSAGE_LIMIT = 6;
 var RECENT_SESSION_MAX_CHARS = 1800;
+var SESSION_START_SECTION_HEADINGS = [
+  "## Previous session summary",
+  "## Recent session",
+  "## Agenr Session Recall",
+  "### Core Memory",
+  "### Relevant Durable Memory",
+  "## Agenr Before-Turn Recall",
+  "### Suggested Procedure"
+];
+var INLINE_METADATA_SENTINELS = [
+  "Sender (untrusted metadata):",
+  "Conversation info (untrusted metadata):",
+  "Thread starter (untrusted, for context):",
+  "Replied message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):"
+];
 async function renderRecentSessionSection(sessionFile, logger) {
   try {
     const transcript = await openClawTranscriptParser.parseFile(sessionFile);
-    const tail = transcript.messages.slice(-RECENT_SESSION_MESSAGE_LIMIT);
-    const body = capRecentSession(tail.map((message) => `${message.role === "user" ? "U" : "A"}: ${message.text}`).join("\n"), RECENT_SESSION_MAX_CHARS);
+    const sanitizedMessages = transcript.messages.map((message) => ({
+      prefix: message.role === "user" ? "U" : "A",
+      text: sanitizeRecentSessionMessage(message.text, message.role)
+    })).filter((message) => message.text.length > 0);
+    const tail = sanitizedMessages.slice(-RECENT_SESSION_MESSAGE_LIMIT);
+    const body = capRecentSession(tail.map((message) => `${message.prefix}: ${message.text}`).join("\n"), RECENT_SESSION_MAX_CHARS);
     logger.debug?.(`[agenr] before_prompt_build: recent session tail for file=${sessionFile}: messages=${tail.length} chars=${body.length}`);
     return body;
   } catch (error) {
@@ -3005,6 +2399,53 @@ function capRecentSession(value, maxChars) {
   const marker = "[...truncated earlier recent session...]\n";
   return `${marker}${value.slice(-(maxChars - marker.length)).trimStart()}`;
 }
+function sanitizeRecentSessionMessage(text, role) {
+  const wrapperDetected = containsAgenrMemoryContext(text) || SESSION_START_SECTION_HEADINGS.some((heading) => text.includes(heading));
+  let cleaned = stripAgenrMemoryContext(text);
+  for (const heading of SESSION_START_SECTION_HEADINGS) {
+    cleaned = cleaned.split(heading).join(" ");
+  }
+  cleaned = stripInlineMetadata(cleaned);
+  cleaned = collapseWhitespace(cleaned);
+  if (wrapperDetected) {
+    cleaned = unwrapEmbeddedTranscriptTurn(cleaned, role);
+  }
+  return collapseWhitespace(cleaned);
+}
+function stripInlineMetadata(text) {
+  let cleaned = text;
+  for (const sentinel of INLINE_METADATA_SENTINELS) {
+    const escapedSentinel = escapeForRegExp(sentinel);
+    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}\\s*(?:json\\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 unwrapEmbeddedTranscriptTurn(text, role) {
+  if (role === "user") {
+    const timestampMatches = [...text.matchAll(/\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s[^\]]+\]/gu)];
+    if (timestampMatches.length > 1) {
+      const lastTimestamp = timestampMatches.at(-1);
+      if (lastTimestamp?.index !== void 0) {
+        return text.slice(lastTimestamp.index).trim();
+      }
+    }
+  }
+  const marker = role === "user" ? "U:" : "A:";
+  const lastMarkerIndex = text.lastIndexOf(marker);
+  if (lastMarkerIndex < 0) {
+    return text;
+  }
+  return text.slice(lastMarkerIndex + marker.length).trim();
+}
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
 
 // src/adapters/openclaw/session/continuity/index.ts
 var READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS = 35e3;
@@ -3136,9 +2577,16 @@ async function awaitWithTimeout(promise, timeoutMs) {
 }
 
 // src/adapters/openclaw/hooks/before-prompt-build.ts
-var CORE_ENTRY_LIMIT = 4;
 var NON_USER_TRIGGER_SET = /* @__PURE__ */ new Set(["heartbeat", "cron", "memory"]);
 var DEFAULT_STORE_NUDGE_CONFIG = resolveStoreNudgeConfig(void 0);
+var INLINE_METADATA_SENTINELS2 = [
+  "Sender (untrusted metadata):",
+  "Conversation info (untrusted metadata):",
+  "Thread starter (untrusted, for context):",
+  "Replied message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):"
+];
 async function handleAgenrBeforePromptBuild(event, ctx, params) {
   const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
   const trackerState = params.tracker.consume(ctx.sessionId, ctx.sessionKey);
@@ -3146,32 +2594,64 @@ async function handleAgenrBeforePromptBuild(event, ctx, params) {
     params.logger.debug?.(`[agenr] before_prompt_build: session tracker duplicate blocked for ${sessionContext}`);
     params.logger.debug?.(`[agenr] before_prompt_build: session tracker active count=${trackerState.activeCount}`);
     params.logger.info(`[agenr] session-start recall skipped (already ran) for ${sessionContext}`);
-    return resolveStoreNudgeResult(event, ctx, sessionContext, params);
+    return await resolveNonFirstTurnResult(event, ctx, sessionContext, params);
   }
   params.logger.debug?.(`[agenr] before_prompt_build: session tracker first start for ${sessionContext}`);
   params.logger.debug?.(`[agenr] before_prompt_build: session tracker active count=${trackerState.activeCount}`);
   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({
       ctx,
       predecessor: continuity.predecessor,
       services,
       logger: params.logger
     });
-    const sessionStartRecall = await runAgenrSessionStartRecall(services);
-    const memoryContext = formatAgenrSessionStartRecall(sessionStartRecall);
-    const sections = [
-      continuity.continuitySummaryContent && `## Previous session summary
-${continuity.continuitySummaryContent}`,
-      continuity.recentSessionContent && `## Recent session
-${continuity.recentSessionContent}`,
-      memoryContext
-    ].filter((value) => Boolean(value && value.trim().length > 0));
-    const prependContext = sections.join("\n\n");
-    params.logger.info(`[agenr] session-start recall: ${sessionStartRecall.core.length} core entries for ${sessionContext}`);
-    params.logger.debug?.(`[agenr] before_prompt_build: session-start core entries for ${sessionContext}: ${formatEntryRefs(sessionStartRecall.core)}`);
+    const sessionStartPatch = await runSessionStart(
+      {
+        sessionKey: ctx.sessionKey,
+        continuitySummaryText: continuity.continuitySummaryContent,
+        recentSessionText: continuity.recentSessionContent,
+        policy: resolveSessionStartPolicy(services.pluginConfig.memoryPolicy)
+      },
+      services.sessionStart
+    );
+    const prependContext = formatAgenrSessionStartRecall(sessionStartPatch);
+    if (services.debugSink.enabled) {
+      void services.debugSink.emit({
+        type: "session_start_recall",
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+        ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+        debug: {
+          durableMemoryCount: sessionStartPatch.durableMemory.length,
+          selectedEntryIds: sessionStartPatch.durableMemory.map((item) => item.entry.id),
+          coreCandidateCount: sessionStartPatch.diagnostics.coreCandidateCount,
+          artifactRecallCandidateCount: sessionStartPatch.diagnostics.artifactRecallCandidateCount,
+          artifactRecallUsed: sessionStartPatch.diagnostics.artifactRecallUsed,
+          notices: [...sessionStartPatch.diagnostics.notices]
+        }
+      });
+    }
+    params.logger.info(
+      `[agenr] session-start recall: ${sessionStartPatch.durableMemory.length} durable entries for ${sessionContext} (core_candidates=${sessionStartPatch.diagnostics.coreCandidateCount} artifact_candidates=${sessionStartPatch.diagnostics.artifactRecallCandidateCount})`
+    );
+    if (sessionStartPatch.diagnostics.artifactRecallUsed) {
+      params.logger.debug?.(
+        `[agenr] before_prompt_build: session-start artifact recall for ${sessionContext} query_length=${sessionStartPatch.diagnostics.artifactRecallQuery?.length ?? 0} notices=${sessionStartPatch.diagnostics.notices.length}`
+      );
+    }
+    if (sessionStartPatch.diagnostics.notices.length > 0) {
+      params.logger.info(`[agenr] session-start recall notices for ${sessionContext}: ${sessionStartPatch.diagnostics.notices.join(" | ")}`);
+    }
+    params.logger.debug?.(
+      `[agenr] before_prompt_build: session-start durable entries for ${sessionContext}: ${formatEntryRefs(sessionStartPatch.durableMemory.map((item) => item.entry))}`
+    );
     params.logger.debug?.(`[agenr] before_prompt_build: session-start prependContext length for ${sessionContext}: ${prependContext.length} chars`);
     if (prependContext.length === 0) {
       params.logger.info(`[agenr] session-start recall: nothing to inject for ${sessionContext}`);
@@ -3180,6 +2660,139 @@ ${continuity.recentSessionContent}`,
     return { prependContext };
   } catch (error) {
     params.logger.warn(`[agenr] session-start recall failed for ${sessionContext}: ${formatErrorMessage2(error)}`);
+    try {
+      const services = await params.servicesPromise;
+      if (services.debugSink.enabled) {
+        void services.debugSink.emit({
+          type: "error",
+          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+          scope: "session_start_recall",
+          error: { message: error instanceof Error ? error.message : String(error) }
+        });
+      }
+    } catch {
+    }
+    return void 0;
+  }
+}
+function emitContinuityEvent(sink, ctx, continuity) {
+  if (!sink.enabled) {
+    return;
+  }
+  void sink.emit({
+    type: "continuity_resolution",
+    ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+    ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+    summary: {
+      predecessorFound: Boolean(continuity.predecessor),
+      ...continuity.predecessor ? { predecessorFileBasename: path5.basename(continuity.predecessor.sessionFile) } : {},
+      hasContinuitySummary: continuity.continuitySummaryContent.length > 0,
+      hasRecentSession: continuity.recentSessionContent.length > 0,
+      continuitySummaryChars: continuity.continuitySummaryContent.length,
+      recentSessionChars: continuity.recentSessionContent.length
+    }
+  });
+}
+async function resolveNonFirstTurnResult(event, ctx, sessionContext, params) {
+  const beforeTurnResult = await resolveBeforeTurnResult(event, ctx, sessionContext, params);
+  if (beforeTurnResult) {
+    return beforeTurnResult;
+  }
+  return resolveStoreNudgeResult(event, ctx, sessionContext, params);
+}
+async function resolveBeforeTurnResult(event, ctx, sessionContext, params) {
+  const normalizedTrigger = ctx.trigger?.trim().toLowerCase();
+  if (normalizedTrigger && NON_USER_TRIGGER_SET.has(normalizedTrigger)) {
+    params.logger.debug?.(`[agenr] before_prompt_build: before-turn skipped for ${sessionContext} reason=non_user_trigger trigger=${normalizedTrigger}`);
+    return void 0;
+  }
+  const services = await params.servicesPromise;
+  if (services.pluginConfig.memoryPolicy?.beforeTurn?.enabled === false) {
+    params.logger.debug?.(`[agenr] before_prompt_build: before-turn skipped for ${sessionContext} reason=disabled`);
+    return void 0;
+  }
+  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;
+  }
+  try {
+    const beforeTurnPatch = await runBeforeTurn(
+      {
+        sessionKey: ctx.sessionKey,
+        currentTurnText,
+        recentTurns: extractRecentTurnsFromMessages(
+          event.messages.filter((message) => Boolean(message) && typeof message === "object"),
+          { stripMemoryCheck: true }
+        ),
+        trigger: ctx.trigger,
+        policy: resolveBeforeTurnPolicy(services.pluginConfig.memoryPolicy)
+      },
+      services.beforeTurn
+    );
+    const prependContext = formatAgenrBeforeTurnRecall(beforeTurnPatch);
+    if (services.debugSink.enabled) {
+      void services.debugSink.emit({
+        type: "before_turn_decision",
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+        ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+        debug: buildLiveBeforeTurnDebugArtifact({
+          caseId: `live-${randomUUID2()}`,
+          patch: beforeTurnPatch,
+          currentTurnText,
+          trigger: ctx.trigger,
+          eventLevel: services.debugSink.eventLevel,
+          maxTopCandidates: services.debugSink.maxTopCandidates
+        })
+      });
+    }
+    params.logger.info(
+      `[agenr] before-turn recall: ${beforeTurnPatch.durableMemory.length} durable entries for ${sessionContext} (durable_candidates=${beforeTurnPatch.diagnostics.durableRecallCandidateCount} procedure_candidates=${beforeTurnPatch.diagnostics.procedureCandidateCount})`
+    );
+    if (beforeTurnPatch.procedure) {
+      params.logger.info(
+        `[agenr] before-turn procedure suggestion for ${sessionContext}: ${beforeTurnPatch.procedure.procedure.procedure_key} score=${beforeTurnPatch.procedure.score.toFixed(2)}`
+      );
+    }
+    if (beforeTurnPatch.diagnostics.notices.length > 0) {
+      params.logger.info(`[agenr] before-turn recall notices for ${sessionContext}: ${beforeTurnPatch.diagnostics.notices.join(" | ")}`);
+    }
+    if (beforeTurnPatch.diagnostics.abstained) {
+      params.logger.debug?.(
+        `[agenr] before_prompt_build: before-turn abstained for ${sessionContext}: category=${beforeTurnPatch.diagnostics.suppressedTurnCategory ?? "none"} signals=${beforeTurnPatch.diagnostics.turnSignalLabels.join(",") || "none"} reasons=${beforeTurnPatch.diagnostics.abstentionReasons.join(" | ") || "none"}`
+      );
+    }
+    params.logger.debug?.(`[agenr] before_prompt_build: before-turn diagnostics for ${sessionContext}: ${formatBeforeTurnDiagnosticsForLog(beforeTurnPatch)}`);
+    params.logger.debug?.(
+      `[agenr] before_prompt_build: before-turn durable entries for ${sessionContext}: ${formatEntryRefs(
+        beforeTurnPatch.durableMemory.map((item) => item.entry)
+      )}`
+    );
+    params.logger.debug?.(`[agenr] before_prompt_build: before-turn prependContext length for ${sessionContext}: ${prependContext.length} chars`);
+    if (prependContext.length === 0) {
+      return void 0;
+    }
+    return { prependContext };
+  } catch (error) {
+    params.logger.warn(`[agenr] before-turn recall failed for ${sessionContext}: ${formatErrorMessage2(error)}`);
+    try {
+      if (services.debugSink.enabled) {
+        void services.debugSink.emit({
+          type: "error",
+          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+          scope: "before_turn_decision",
+          error: { message: error instanceof Error ? error.message : String(error) }
+        });
+      }
+    } catch {
+    }
     return void 0;
   }
 }
@@ -3219,12 +2832,64 @@ function resolveStoreNudgeResult(_event, ctx, sessionContext, params) {
   params.logger.info(`[agenr] store nudge injected for ${sessionContext} ordinal=${state.nudgeCount} turn=${state.turnCount} gap=${gapSinceSuccessfulStore}`);
   return { prependContext };
 }
-async function runAgenrSessionStartRecall(services) {
-  return { core: await services.memory.listCoreEntries(CORE_ENTRY_LIMIT) };
-}
 function formatEntryRefs(entries) {
   return entries.length === 0 ? "none" : entries.map((entry) => `${entry.subject} [${entry.id}]`).join(", ");
 }
+function formatBeforeTurnDiagnosticsForLog(patch) {
+  return JSON.stringify({
+    query: truncateForLog(patch.diagnostics.query, 160),
+    queryPolicy: patch.diagnostics.queryPolicy,
+    queryVariants: patch.diagnostics.queryVariants.map((variant) => ({
+      kind: variant.kind,
+      query: truncateForLog(variant.query, 120),
+      candidateCount: variant.candidateCount,
+      selected: variant.selected
+    })),
+    turnSignalLabels: patch.diagnostics.turnSignalLabels,
+    suppressedTurnCategory: patch.diagnostics.suppressedTurnCategory,
+    durableRecallCandidateCount: patch.diagnostics.durableRecallCandidateCount,
+    procedureCandidateCount: patch.diagnostics.procedureCandidateCount,
+    directness: patch.diagnostics.directness ? {
+      queryKind: patch.diagnostics.directness.queryKind,
+      entity: patch.diagnostics.directness.entity,
+      decision: patch.diagnostics.directness.decision,
+      winnerEntryId: patch.diagnostics.directness.winnerEntryId,
+      runnerUpEntryId: patch.diagnostics.directness.runnerUpEntryId,
+      winnerGap: patch.diagnostics.directness.winnerGap,
+      reason: truncateForLog(patch.diagnostics.directness.reason, 180),
+      candidates: patch.diagnostics.directness.candidates.map((candidate) => ({
+        entryId: candidate.entryId,
+        baseRank: candidate.baseRank,
+        baseScore: candidate.baseScore,
+        directnessDelta: candidate.directnessDelta,
+        adjustedScore: candidate.adjustedScore,
+        signals: candidate.signals
+      }))
+    } : void 0,
+    abstained: patch.diagnostics.abstained,
+    abstentionReasons: patch.diagnostics.abstentionReasons.map((reason) => truncateForLog(reason, 180)),
+    notices: patch.diagnostics.notices.map((notice) => truncateForLog(notice, 180)),
+    selectedEntries: patch.durableMemory.map((item) => ({
+      id: item.entry.id,
+      subject: truncateForLog(item.entry.subject, 80),
+      score: Number(item.score.toFixed(3))
+    })),
+    procedure: patch.procedure ? {
+      procedureKey: patch.procedure.procedure.procedure_key,
+      score: Number(patch.procedure.score.toFixed(3))
+    } : void 0
+  });
+}
+function truncateForLog(value, maxChars) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  return normalized.length <= maxChars ? normalized : `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
 
 // src/adapters/openclaw/memory/flush-plan.ts
 function buildAgenrMemoryFlushPlan(_params, logger) {
@@ -3244,7 +2909,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: {
@@ -3304,139 +2969,48 @@ function createAgenrMemoryRuntime(servicesPromise) {
 }
 
 // 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
-  });
-  return {
-    openClaw: options.openClaw,
-    config: resolvedConfig,
-    pluginConfig: config,
-    agenrConfig,
-    dbPath: resolvedConfig.dbPath,
-    entries: runtimeServices.entries,
-    episodes: runtimeServices.episodes,
-    procedures: runtimeServices.procedures,
-    memory: runtimeServices.memory,
-    embedding: runtimeServices.embedding,
-    recall: runtimeServices.recall,
-    claimExtraction: runtimeServices.claimExtraction,
-    embeddingStatus: toPublicEmbeddingStatus(embeddingStatus),
-    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 claimExtraction = await createClaimExtractionRuntime(config, openClawContext.openClaw, openClawContext.pluginConfig);
-  let closed = false;
-  return {
-    entries: database,
-    episodes: database,
-    procedures: database,
-    memory: createOpenClawRepository(database, {
-      claimSlotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
-    }),
-    embedding,
-    recall: createRecallAdapter(database, embedding),
-    claimExtraction,
-    async close() {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      await database.close();
-    }
-  };
-}
-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 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
+    })
   });
-  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.");
+function createDebugSink(openClaw, pluginConfig) {
+  const resolved = resolveDebugConfig(pluginConfig.debug);
+  if (!resolved.enabled) {
+    return createNoopAgenrDebugSink();
   }
-  return status.apiKey;
+  const withLogPath = ensureDebugLogPath(resolved, openClaw);
+  return createAgenrDebugSink(withLogPath);
 }
-async function createClaimExtractionRuntime(config, openClaw, pluginConfig) {
-  const claimExtractionConfig = resolveClaimExtractionConfig(config);
-  if (!claimExtractionConfig.enabled) {
-    return void 0;
+function ensureDebugLogPath(resolved, openClaw) {
+  if (resolved.logPath) {
+    return resolved;
   }
   try {
+    const stateDir = openClaw.runtime.state.resolveStateDir(process.env);
     return {
-      llm: await createOpenClawLlmClient(openClaw, pluginConfig.claimExtractionModel, "claim extraction model override"),
-      config: claimExtractionConfig
+      ...resolved,
+      logPath: path6.join(stateDir, "agenr", "logs", "debug.jsonl")
     };
   } catch {
-    return void 0;
+    return { ...resolved, enabled: false };
   }
 }