@agenr/agenr-plugin 2.0.0 → 2.1.0

package/dist/index.js

@@ -7,34 +7,276 @@ import {
   parseTuiSessionKey,
   readOpenClawSessionsStore,
   storeEntriesDetailed
-} from "./chunk-XD3446YW.js";
+} from "./chunk-DGV6D6Q3.js";
+import {
+  BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K,
+  BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K,
+  RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K,
+  RECALL_DEBUG_ARTIFACT_MAX_TOP_K,
+  containsAgenrMemoryContext,
+  formatAgenrBeforeTurnRecall,
+  runBeforeTurn,
+  stripAgenrMemoryContext,
+  wrapAgenrMemoryContext
+} from "./chunk-IMQIJPIP.js";
 import {
   EMBEDDING_DIMENSIONS,
+  ENTRY_SELECT_COLUMNS,
   ENTRY_TYPES,
   EXPIRY_LEVELS,
+  attachCrossEncoderPort,
+  buildActiveEntryClause,
   createDatabase,
   createEmbeddingClient,
+  createOpenAICrossEncoder,
   createRecallAdapter,
+  mapEntryRow,
   normalizeManualClaimKeyUpdate,
+  projectClaimCentricRecallEntry,
   readConfig,
   resolveClaimExtractionConfig,
   resolveConfigPath,
+  resolveCrossEncoderApiKey,
   resolveDbPath,
   resolveEmbeddingApiKey,
   resolveEmbeddingModel,
+  resolveModel,
   runUnifiedRecall,
   validateTemporalValidityRange
-} from "./chunk-Y2BC7RCE.js";
+} from "./chunk-7TDALVPY.js";
 import {
+  recall,
   resolveClaimSlotPolicy
-} from "./chunk-MEHOGUZE.js";
+} from "./chunk-6T5RXGIR.js";
 
 // src/adapters/openclaw/index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 
 // src/adapters/openclaw/tools/recall.ts
+import { randomUUID } from "crypto";
 import { readNumberParam, readStringArrayParam, readStringParam as readStringParam2, textResult } from "openclaw/plugin-sdk/agent-runtime";
 
+// src/adapters/openclaw/debug/sink.ts
+import { appendFile, mkdir } from "fs/promises";
+import path from "path";
+var NOOP_SINK = {
+  enabled: false,
+  eventLevel: "basic",
+  maxTopCandidates: 0,
+  async emit() {
+    return;
+  },
+  async close() {
+    return;
+  }
+};
+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 formatEventLine(event) {
+  const line = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...event
+  };
+  return JSON.stringify(line);
+}
+function sanitizeSessionSuffix(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const sanitized = trimmed.replace(/[^A-Za-z0-9._-]+/gu, "_");
+  if (sanitized.length === 0) {
+    return void 0;
+  }
+  return sanitized.slice(0, 120);
+}
+
+// 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 {
+    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 clampTopK(requested) {
+  if (!Number.isFinite(requested) || !Number.isInteger(requested)) {
+    return BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K;
+  }
+  if (requested < 1) {
+    return 0;
+  }
+  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 [];
+  }
+  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 [];
+  }
+  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 } : {}
+    }
+  ];
+}
+
+// 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 {
+    schemaVersion: "recall-debug-artifact.v1",
+    caseId,
+    request: {
+      recallPath: "unified",
+      query
+    },
+    routing: result.routing,
+    selectedEntryIds,
+    ...topCandidates.length > 0 ? { topCandidates } : {}
+  };
+}
+function clampTopK2(requested) {
+  if (!Number.isFinite(requested) || !Number.isInteger(requested)) {
+    return RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K;
+  }
+  if (requested < 1) {
+    return 0;
+  }
+  if (requested > RECALL_DEBUG_ARTIFACT_MAX_TOP_K) {
+    return RECALL_DEBUG_ARTIFACT_MAX_TOP_K;
+  }
+  return requested;
+}
+function buildTopCandidates(result, reasonsByEntryId, topK) {
+  if (topK < 1) {
+    return [];
+  }
+  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, 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.";
@@ -636,6 +878,15 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
           ...asOf ? { asOf } : {},
           sessionKey: ctx.sessionKey
         };
+        const sanitizedParams = sanitizeRecallToolParams({
+          query,
+          mode,
+          limit,
+          threshold,
+          types,
+          tags,
+          ...asOf ? { asOf } : {}
+        });
         logToolCall(
           logger,
           "agenr_recall",
@@ -648,16 +899,15 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
             tags,
             ...asOf ? { asOf } : {}
           }),
-          sanitizeRecallToolParams({
-            query,
-            mode,
-            limit,
-            threshold,
-            types,
-            tags,
-            ...asOf ? { asOf } : {}
-          })
+          sanitizedParams
         );
+        void services.debugSink.emit({
+          type: "tool_call",
+          tool: "agenr_recall",
+          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+          params: sanitizedParams
+        });
         const result = await runUnifiedRecall(request, {
           database: services.episodes,
           procedures: services.procedures,
@@ -679,6 +929,42 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
         logger.info(
           `[agenr] tool=agenr_recall session=${ctx.sessionId ?? "unknown"} key=${ctx.sessionKey ?? "unknown"} result: ${formatUnifiedRecallLogSummary(result)}`
         );
+        if (services.debugSink.enabled) {
+          const sessionIdPayload = ctx.sessionId ? { sessionId: ctx.sessionId } : {};
+          const sessionKeyPayload = ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {};
+          void services.debugSink.emit({
+            type: "tool_result",
+            tool: "agenr_recall",
+            ...sessionIdPayload,
+            ...sessionKeyPayload,
+            summary: {
+              count: result.count,
+              routing: {
+                requested: result.routing.requested,
+                detectedIntent: result.routing.detectedIntent,
+                queried: [...result.routing.queried],
+                reason: result.routing.reason
+              },
+              selectedEntryIds: result.entries.map((entry) => entry.entry.id),
+              episodeIds: result.episodes.map((episode) => episode.episode.id),
+              selectedProcedureKey: result.procedure?.procedure_key ?? null,
+              notices: [...result.notices],
+              procedureNotices: [...result.procedureNotices]
+            }
+          });
+          void services.debugSink.emit({
+            type: "unified_recall",
+            ...sessionIdPayload,
+            ...sessionKeyPayload,
+            debug: buildLiveRecallDebugArtifact({
+              caseId: `live-${randomUUID()}`,
+              query,
+              result,
+              eventLevel: services.debugSink.eventLevel,
+              maxTopCandidates: services.debugSink.maxTopCandidates
+            })
+          });
+        }
         return textResult(formatUnifiedRecallResults(result), {
           status: "ok",
           count: result.count,
@@ -758,6 +1044,19 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
         });
       } catch (error) {
         logToolFailure(logger, "agenr_recall", ctx, error);
+        try {
+          const services = await servicesPromise;
+          if (services.debugSink.enabled) {
+            void services.debugSink.emit({
+              type: "error",
+              ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+              ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+              scope: "agenr_recall",
+              error: { message: error instanceof Error ? error.message : String(error) }
+            });
+          }
+        } catch {
+        }
         return toolFailureResult(error);
       }
     }
@@ -1175,7 +1474,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "2.0.0",
+  version: "2.1.0",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {
@@ -1208,7 +1507,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 +1562,91 @@ 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: {
+              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 +1675,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: {} };
@@ -1339,7 +1726,11 @@ function normalizeAgenrOpenClawPluginConfig(value) {
   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 +1748,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,6 +1773,78 @@ function createAgenrOpenClawPluginConfigSchema() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function resolveDebugConfig(value) {
+  const logPath = value?.logPath?.trim();
+  return {
+    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 normalizeDebugConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["debug must be an object when provided"] };
+  }
+  const errors = [];
+  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: debug.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  const normalized = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...logPath !== void 0 ? { logPath } : {},
+    ...eventLevel !== void 0 ? { eventLevel } : {},
+    ...perSessionFiles !== void 0 ? { perSessionFiles } : {},
+    ...maxTopCandidates !== void 0 ? { maxTopCandidates } : {}
+  };
+  return {
+    ok: true,
+    value: Object.keys(normalized).length > 0 ? normalized : void 0
+  };
+}
+function normalizeOptionalDebugEventLevel(value, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "basic" || value === "detailed") {
+    return value;
+  }
+  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 (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 {
     enabled: value?.enabled ?? true,
@@ -1430,7 +1894,15 @@ function normalizeMemoryPolicyConfig(value) {
   if (!slotPoliciesResult.ok) {
     errors.push(...slotPoliciesResult.errors);
   }
-  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies"]);
+  const sessionStartResult = normalizeSessionStartMemoryPolicyConfig(value.sessionStart);
+  if (!sessionStartResult.ok) {
+    errors.push(...sessionStartResult.errors);
+  }
+  const beforeTurnResult = normalizeBeforeTurnMemoryPolicyConfig(value.beforeTurn);
+  if (!beforeTurnResult.ok) {
+    errors.push(...beforeTurnResult.errors);
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["slotPolicies", "sessionStart", "beforeTurn"]);
   for (const key of Object.keys(value)) {
     if (!allowedKeys.has(key)) {
       errors.push(`unknown config field: memoryPolicy.${key}`);
@@ -1441,8 +1913,79 @@ function normalizeMemoryPolicyConfig(value) {
   }
   return {
     ok: true,
-    value: slotPoliciesResult.ok && slotPoliciesResult.value ? {
-      slotPolicies: slotPoliciesResult.value
+    value: slotPoliciesResult.ok && slotPoliciesResult.value || sessionStartResult.ok && sessionStartResult.value || beforeTurnResult.ok && beforeTurnResult.value ? {
+      ...slotPoliciesResult.ok && slotPoliciesResult.value ? { slotPolicies: slotPoliciesResult.value } : {},
+      ...sessionStartResult.ok && sessionStartResult.value ? { sessionStart: sessionStartResult.value } : {},
+      ...beforeTurnResult.ok && beforeTurnResult.value ? { beforeTurn: beforeTurnResult.value } : {}
+    } : void 0
+  };
+}
+function normalizeSessionStartMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["memoryPolicy.sessionStart must be an object when provided"] };
+  }
+  const errors = [];
+  const relevantDurableMemory = normalizeOptionalBoolean(value.relevantDurableMemory, "memoryPolicy.sessionStart.relevantDurableMemory", errors);
+  const allowedKeys = /* @__PURE__ */ new Set(["relevantDurableMemory"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.sessionStart.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: relevantDurableMemory !== void 0 ? { relevantDurableMemory } : void 0
+  };
+}
+function normalizeBeforeTurnMemoryPolicyConfig(value) {
+  if (value === void 0) {
+    return { ok: true, value: void 0 };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["memoryPolicy.beforeTurn must be an object when provided"] };
+  }
+  const errors = [];
+  const enabled = normalizeOptionalBoolean(value.enabled, "memoryPolicy.beforeTurn.enabled", errors);
+  const procedureSuggestion = normalizeOptionalBoolean(value.procedureSuggestion, "memoryPolicy.beforeTurn.procedureSuggestion", errors);
+  const maxDurableEntries = normalizeOptionalPositiveInteger(value.maxDurableEntries, "memoryPolicy.beforeTurn.maxDurableEntries", errors);
+  const recallThreshold = normalizeOptionalUnitInterval(value.recallThreshold, "memoryPolicy.beforeTurn.recallThreshold", errors);
+  const highConfidenceRecallThreshold = normalizeOptionalUnitInterval(
+    value.highConfidenceRecallThreshold,
+    "memoryPolicy.beforeTurn.highConfidenceRecallThreshold",
+    errors
+  );
+  const procedureThreshold = normalizeOptionalUnitInterval(value.procedureThreshold, "memoryPolicy.beforeTurn.procedureThreshold", errors);
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "enabled",
+    "procedureSuggestion",
+    "maxDurableEntries",
+    "recallThreshold",
+    "highConfidenceRecallThreshold",
+    "procedureThreshold"
+  ]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`unknown config field: memoryPolicy.beforeTurn.${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: enabled !== void 0 || procedureSuggestion !== void 0 || maxDurableEntries !== void 0 || recallThreshold !== void 0 || highConfidenceRecallThreshold !== void 0 || procedureThreshold !== void 0 ? {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...procedureSuggestion !== void 0 ? { procedureSuggestion } : {},
+      ...maxDurableEntries !== void 0 ? { maxDurableEntries } : {},
+      ...recallThreshold !== void 0 ? { recallThreshold } : {},
+      ...highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold } : {},
+      ...procedureThreshold !== void 0 ? { procedureThreshold } : {}
     } : void 0
   };
 }
@@ -1512,6 +2055,16 @@ function normalizeOptionalPositiveInteger(value, label, errors) {
   }
   return value;
 }
+function normalizeOptionalUnitInterval(value, label, errors) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    errors.push(`${label} must be a number between 0 and 1 when provided`);
+    return void 0;
+  }
+  return value;
+}
 
 // src/adapters/openclaw/format/prompt-section.ts
 var MEMORY_TOOL_NAMES = {
@@ -1535,10 +2088,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.",
@@ -1800,6 +2354,267 @@ function hasNonEmptyString(value) {
   return readString(value) !== void 0;
 }
 
+// src/adapters/openclaw/hooks/before-prompt-build.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/app/session-start/service.ts
+var DEFAULT_MAX_CORE_ENTRIES = 4;
+var DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES = 3;
+var DEFAULT_MAX_DURABLE_ENTRIES = 5;
+var DEFAULT_MAX_ARTIFACT_CHARS = 1200;
+async function runSessionStart(input, deps) {
+  const policy = normalizePolicy(input.policy);
+  const contextSections = buildContextSections(input);
+  const coreEntries = await deps.repository.listCoreEntries(policy.maxCoreEntries);
+  const coreItems = coreEntries.map((entry) => buildCorePatchItem(entry));
+  const diagnostics = {
+    coreCandidateCount: coreEntries.length,
+    artifactRecallCandidateCount: 0,
+    artifactRecallUsed: false,
+    notices: []
+  };
+  const artifactRecallQuery = policy.enableArtifactRecall ? buildArtifactRecallQuery(contextSections, policy.maxArtifactChars) : void 0;
+  if (!policy.enableArtifactRecall) {
+    diagnostics.notices.push("Artifact-grounded durable recall disabled by session-start policy.");
+  }
+  const artifactRecallItems = artifactRecallQuery ? await runArtifactRecallSelection(artifactRecallQuery, input.sessionKey, policy, deps, diagnostics) : [];
+  const durableMemory = assignRanks(mergeDurableMemory(coreItems, artifactRecallItems, policy.maxDurableEntries));
+  return {
+    contextSections,
+    durableMemory,
+    diagnostics
+  };
+}
+function buildContextSections(input) {
+  const sections = [];
+  const continuitySummaryText = normalizeOptionalString(input.continuitySummaryText);
+  if (continuitySummaryText) {
+    sections.push({
+      kind: "continuity_summary",
+      title: "Previous session summary",
+      content: continuitySummaryText
+    });
+  }
+  const recentSessionText = normalizeOptionalString(input.recentSessionText);
+  if (recentSessionText) {
+    sections.push({
+      kind: "recent_session",
+      title: "Recent session",
+      content: recentSessionText
+    });
+  }
+  return sections;
+}
+async function runArtifactRecallSelection(query, sessionKey, policy, deps, diagnostics) {
+  diagnostics.artifactRecallUsed = true;
+  diagnostics.artifactRecallQuery = query;
+  let artifactRecallTrace;
+  try {
+    const recalled = await recall(
+      {
+        text: query,
+        limit: policy.maxArtifactRecallEntries,
+        threshold: policy.recallThreshold,
+        sessionKey
+      },
+      deps.recall,
+      {
+        trace: {
+          reportSummary(summary) {
+            artifactRecallTrace = summary;
+          }
+        },
+        slotPolicyConfig: deps.slotPolicyConfig
+      }
+    );
+    diagnostics.artifactRecallTrace = artifactRecallTrace;
+    diagnostics.artifactRecallCandidateCount = recalled.length;
+    if (artifactRecallTrace?.degraded.notices.length) {
+      diagnostics.notices.push(...artifactRecallTrace.degraded.notices);
+    }
+    return recalled.map((item) => buildArtifactRecallPatchItem(item, deps));
+  } catch (error) {
+    diagnostics.artifactRecallTrace = artifactRecallTrace;
+    diagnostics.notices.push(`Artifact-grounded durable recall failed: ${formatErrorMessage3(error)}`);
+    return [];
+  }
+}
+function buildCorePatchItem(entry) {
+  return {
+    rank: 0,
+    entry,
+    sourceKind: "core",
+    whySurfaced: {
+      summary: `always-on core memory; importance ${entry.importance}`,
+      reasons: ["always-on core memory", `importance ${entry.importance}`, `expiry ${entry.expiry}`]
+    },
+    memoryState: resolveMemoryState(entry),
+    claimStatus: resolveClaimStatus(entry),
+    freshnessLabel: buildFreshnessLabel(entry),
+    ...buildProvenanceSummary(entry) ? { provenanceSummary: buildProvenanceSummary(entry) } : {}
+  };
+}
+function buildArtifactRecallPatchItem(recalled, deps) {
+  const projected = projectClaimCentricRecallEntry(recalled, {
+    slotPolicyConfig: deps.slotPolicyConfig
+  });
+  return {
+    rank: 0,
+    entry: recalled.entry,
+    sourceKind: "artifact_recall",
+    score: recalled.score,
+    whySurfaced: projected.whySurfaced,
+    memoryState: projected.memoryState,
+    claimStatus: projected.claimStatus,
+    freshnessLabel: projected.freshness.label,
+    ...formatProjectedProvenance(projected.provenance) ? { provenanceSummary: formatProjectedProvenance(projected.provenance) } : {}
+  };
+}
+function buildArtifactRecallQuery(sections, maxChars) {
+  if (sections.length === 0 || maxChars <= 0) {
+    return void 0;
+  }
+  let remaining = maxChars;
+  const parts = [];
+  for (const section of sections) {
+    if (remaining <= 0) {
+      break;
+    }
+    const normalizedContent = normalizeWhitespace(section.content);
+    if (normalizedContent.length === 0) {
+      continue;
+    }
+    const labeled = `${section.title}: ${normalizedContent}`;
+    const truncated = truncate2(labeled, remaining);
+    if (truncated.length === 0) {
+      continue;
+    }
+    parts.push(truncated);
+    remaining -= truncated.length;
+  }
+  const query = normalizeWhitespace(parts.join("\n"));
+  return query.length > 0 ? query : void 0;
+}
+function mergeDurableMemory(coreItems, artifactRecallItems, maxDurableEntries) {
+  const merged = [];
+  const seenEntryIds = /* @__PURE__ */ new Set();
+  for (const item of [...coreItems, ...artifactRecallItems]) {
+    if (seenEntryIds.has(item.entry.id)) {
+      continue;
+    }
+    seenEntryIds.add(item.entry.id);
+    merged.push(item);
+    if (merged.length >= maxDurableEntries) {
+      break;
+    }
+  }
+  return merged;
+}
+function assignRanks(items) {
+  return items.map((item, index) => ({
+    ...item,
+    rank: index + 1
+  }));
+}
+function normalizePolicy(policy) {
+  const maxCoreEntries = normalizeCount(policy?.maxCoreEntries, DEFAULT_MAX_CORE_ENTRIES);
+  const maxArtifactRecallEntries = normalizeCount(policy?.maxArtifactRecallEntries, DEFAULT_MAX_ARTIFACT_RECALL_ENTRIES);
+  const maxDurableEntries = Math.max(maxCoreEntries, normalizeCount(policy?.maxDurableEntries, DEFAULT_MAX_DURABLE_ENTRIES));
+  return {
+    maxCoreEntries,
+    enableArtifactRecall: policy?.enableArtifactRecall !== false,
+    maxArtifactRecallEntries,
+    maxDurableEntries,
+    maxArtifactChars: normalizeCount(policy?.maxArtifactChars, DEFAULT_MAX_ARTIFACT_CHARS),
+    recallThreshold: normalizeThreshold(policy?.recallThreshold)
+  };
+}
+function normalizeCount(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeThreshold(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function resolveMemoryState(entry) {
+  if (entry.superseded_by) {
+    return "superseded";
+  }
+  if (entry.retired || entry.valid_to) {
+    return "historical";
+  }
+  return "current";
+}
+function resolveClaimStatus(entry) {
+  if (!normalizeOptionalString(entry.claim_key)) {
+    return "no_key";
+  }
+  return entry.claim_key_status ?? "legacy";
+}
+function buildFreshnessLabel(entry) {
+  const parts = [`created ${entry.created_at}`];
+  const validFrom = normalizeOptionalString(entry.valid_from);
+  const validTo = normalizeOptionalString(entry.valid_to);
+  if (validFrom || validTo) {
+    parts.push(`valid ${validFrom ?? "?"} -> ${validTo ?? "ongoing"}`);
+  }
+  return parts.join(" | ");
+}
+function buildProvenanceSummary(entry) {
+  const parts = [
+    entry.superseded_by ? `superseded_by=${entry.superseded_by}` : void 0,
+    entry.supersession_kind ? `kind=${entry.supersession_kind}` : void 0,
+    entry.supersession_reason ? `reason=${entry.supersession_reason}` : void 0,
+    entry.claim_support_source_kind ? `support=${entry.claim_support_source_kind}` : void 0,
+    entry.claim_support_mode ? `support_mode=${entry.claim_support_mode}` : void 0,
+    entry.claim_support_observed_at ? `observed=${entry.claim_support_observed_at}` : void 0,
+    entry.claim_support_locator ? `locator=${entry.claim_support_locator}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function formatProjectedProvenance(provenance) {
+  const parts = [
+    provenance.supersededById ? `superseded_by=${provenance.supersededById}` : void 0,
+    provenance.supersessionKind ? `kind=${provenance.supersessionKind}` : void 0,
+    provenance.supersessionReason ? `reason=${provenance.supersessionReason}` : void 0,
+    provenance.supportSourceKind ? `support=${provenance.supportSourceKind}` : void 0,
+    provenance.supportMode ? `support_mode=${provenance.supportMode}` : void 0,
+    provenance.supportObservedAt ? `observed=${provenance.supportObservedAt}` : void 0,
+    provenance.supportLocator ? `locator=${provenance.supportLocator}` : void 0
+  ].filter((value) => value !== void 0);
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncate2(value, maxChars) {
+  if (maxChars <= 0) {
+    return "";
+  }
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+}
+function formatErrorMessage3(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/adapters/openclaw/hooks/before-prompt-build.ts
+import path5 from "path";
+
 // src/adapters/openclaw/episode/episode-writer.ts
 import { resolveAgentEffectiveModelPrimary as resolveAgentEffectiveModelPrimary2, resolveDefaultAgentId as resolveDefaultAgentId2 } from "openclaw/plugin-sdk/agent-runtime";
 
@@ -1809,7 +2624,7 @@ import { completeSimple, getModel } from "@mariozechner/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);
@@ -1852,7 +2667,7 @@ async function createOpenClawLlmClient(openClaw, modelRef, label = "model overri
     provider: execution.provider,
     cfg: openClaw.config
   });
-  const apiKey = normalizeOptionalString(auth.apiKey);
+  const apiKey = normalizeOptionalString2(auth.apiKey);
   if (!apiKey) {
     throw new Error(`OpenClaw auth did not resolve an API-key-compatible credential for ${execution.provider} (source=${auth.source}, mode=${auth.mode}).`);
   }
@@ -1897,7 +2712,7 @@ function stripCodeFence(text) {
   const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/iu.exec(trimmed);
   return match?.[1]?.trim() ?? trimmed;
 }
-function normalizeOptionalString(value) {
+function normalizeOptionalString2(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
@@ -2216,33 +3031,51 @@ function truncateSubject(subject) {
 }
 
 // src/adapters/openclaw/format/recall-format.ts
-var MAX_CONTENT_CHARS = 280;
-function formatAgenrSessionStartRecall(recall) {
-  const sections = buildSections(recall);
-  if (sections.length === 0) {
+var MAX_CONTENT_CHARS = 220;
+function formatAgenrSessionStartRecall(patch) {
+  if (patch.contextSections.length === 0 && patch.durableMemory.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));
-    }
+  const lines = [];
+  for (const section of patch.contextSections) {
+    lines.push(`## ${section.title}`);
+    lines.push(section.content);
     lines.push("");
   }
+  const durableSections = buildSections(patch);
+  if (durableSections.length > 0) {
+    const recallLines = [
+      "## Agenr Session Recall",
+      "Use this as prior context. Confirm anything important if the current conversation conflicts with it.",
+      ""
+    ];
+    for (const section of durableSections) {
+      recallLines.push(`### ${section.title}`);
+      for (const item of section.entries) {
+        recallLines.push(formatEntryHeader(item));
+        recallLines.push(...formatEntryBodyLines(item));
+      }
+      recallLines.push("");
+    }
+    lines.push(wrapAgenrMemoryContext(recallLines.join("\n").trim()));
+  }
   return lines.join("\n").trim();
 }
-function buildSections(recall) {
+function buildSections(patch) {
   const sections = [];
-  const coreEntries = recall.core.map((entry) => ({ entry }));
+  const coreEntries = patch.durableMemory.filter((item) => item.sourceKind === "core");
   if (coreEntries.length > 0) {
     sections.push({ title: "Core Memory", entries: coreEntries });
   }
+  const artifactRecallEntries = patch.durableMemory.filter((item) => item.sourceKind === "artifact_recall");
+  if (artifactRecallEntries.length > 0) {
+    sections.push({ title: "Relevant Durable Memory", entries: artifactRecallEntries });
+  }
   return sections;
 }
 function formatEntryHeader(item) {
   const metadata = [
+    `rank ${item.rank}`,
     item.entry.id,
     item.entry.type,
     item.entry.expiry,
@@ -2251,18 +3084,20 @@ function formatEntryHeader(item) {
   ].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
+function formatEntryBodyLines(item) {
+  const lines = [`  ${truncate3(item.entry.content.trim(), MAX_CONTENT_CHARS)}`];
+  lines.push(`  why: ${item.whySurfaced.summary}`);
+  const metadata = [
+    item.entry.tags.length > 0 ? `tags: ${item.entry.tags.join(", ")}` : void 0,
+    item.freshnessLabel ? `freshness: ${item.freshnessLabel}` : void 0,
+    item.provenanceSummary ? `provenance: ${truncate3(item.provenanceSummary, MAX_CONTENT_CHARS)}` : void 0
   ].filter((value) => value !== void 0);
-  if (extra.length === 0) {
-    return `  ${content}`;
+  if (metadata.length > 0) {
+    lines.push(`  ${metadata.join(" | ")}`);
   }
-  return `  ${content} (${extra.join(" | ")})`;
+  return lines;
 }
-function truncate2(value, maxChars) {
+function truncate3(value, maxChars) {
   if (value.length <= maxChars) {
     return value;
   }
@@ -2275,14 +3110,14 @@ import { resolveAgentEffectiveModelPrimary as resolveAgentEffectiveModelPrimary3
 
 // 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;
 }
@@ -2476,10 +3311,10 @@ async function generateAndWriteOpenClawContinuitySummary(params) {
         durationMs
       };
     }
-    debugLog2(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage3(error)}`);
+    debugLog2(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage4(error)}`);
     return {
       status: "failed",
-      reason: formatErrorMessage3(error),
+      reason: formatErrorMessage4(error),
       continuitySummaryPath,
       messageCount: cleanedMessages.length,
       transcriptChars: normalizedTranscript.length,
@@ -2498,7 +3333,7 @@ function normalizeContinuitySummary(value) {
   const trimmed = value.trim();
   return trimmed.replace(/^# .+\n+/u, "").trim();
 }
-function formatErrorMessage3(error) {
+function formatErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function resolveOpenClawSummaryModelRef(openClaw, agentId, modelOverride) {
@@ -2538,7 +3373,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 +3596,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 +3780,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 +3792,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,19 +3818,40 @@ 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) {
-    logger.debug?.(`[agenr] before_prompt_build: failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage4(error)}`);
+    logger.debug?.(`[agenr] before_prompt_build: failed to build recent session tail for file=${sessionFile}: ${formatErrorMessage5(error)}`);
     return "";
   }
 }
-function formatErrorMessage4(error) {
+function formatErrorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function capRecentSession(value, maxChars) {
@@ -3005,6 +3861,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 +4039,32 @@ async function awaitWithTimeout(promise, timeoutMs) {
 }
 
 // src/adapters/openclaw/hooks/before-prompt-build.ts
-var CORE_ENTRY_LIMIT = 4;
+var DEFAULT_SESSION_START_POLICY = {
+  maxCoreEntries: 4,
+  maxArtifactRecallEntries: 3,
+  maxDurableEntries: 5,
+  maxArtifactChars: 1200
+};
+var DEFAULT_BEFORE_TURN_POLICY = {
+  maxDurableEntries: 1,
+  maxHighConfidenceDurableEntries: 2,
+  maxRecentTurns: 2,
+  maxQueryChars: 450,
+  maxProcedureCandidates: 3,
+  recallThreshold: 0.6,
+  highConfidenceRecallThreshold: 0.85,
+  procedureThreshold: 0.72
+};
 var NON_USER_TRIGGER_SET = /* @__PURE__ */ new Set(["heartbeat", "cron", "memory"]);
 var DEFAULT_STORE_NUDGE_CONFIG = resolveStoreNudgeConfig(void 0);
+var INLINE_METADATA_SENTINELS2 = [
+  "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,7 +4072,7 @@ 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}`);
@@ -3154,24 +4080,52 @@ async function handleAgenrBeforePromptBuild(event, ctx, params) {
   try {
     const services = await params.servicesPromise;
     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)
+      },
+      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 +4134,131 @@ ${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);
+  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: extractRecentTurns(event.messages),
+        trigger: ctx.trigger,
+        policy: resolveBeforeTurnPolicy(services)
+      },
+      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 +4298,182 @@ 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()}...`;
+}
+function resolveSessionStartPolicy(services) {
+  return {
+    ...DEFAULT_SESSION_START_POLICY,
+    enableArtifactRecall: services.pluginConfig.memoryPolicy?.sessionStart?.relevantDurableMemory !== false
+  };
+}
+function resolveBeforeTurnPolicy(services) {
+  return {
+    ...DEFAULT_BEFORE_TURN_POLICY,
+    enableProcedureSuggestion: services.pluginConfig.memoryPolicy?.beforeTurn?.procedureSuggestion !== false,
+    ...services.pluginConfig.memoryPolicy?.beforeTurn?.maxDurableEntries !== void 0 ? { maxDurableEntries: services.pluginConfig.memoryPolicy.beforeTurn.maxDurableEntries } : {},
+    ...services.pluginConfig.memoryPolicy?.beforeTurn?.recallThreshold !== void 0 ? { recallThreshold: services.pluginConfig.memoryPolicy.beforeTurn.recallThreshold } : {},
+    ...services.pluginConfig.memoryPolicy?.beforeTurn?.highConfidenceRecallThreshold !== void 0 ? { highConfidenceRecallThreshold: services.pluginConfig.memoryPolicy.beforeTurn.highConfidenceRecallThreshold } : {},
+    ...services.pluginConfig.memoryPolicy?.beforeTurn?.procedureThreshold !== void 0 ? { procedureThreshold: services.pluginConfig.memoryPolicy.beforeTurn.procedureThreshold } : {}
+  };
+}
+function extractRecentTurns(messages) {
+  const turns = [];
+  for (const message of messages) {
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+    const typed = message;
+    const role = typed.role === "user" || typed.role === "assistant" ? typed.role : void 0;
+    if (!role) {
+      continue;
+    }
+    const text = sanitizeRecentTurnText(extractMessageText(typed.content), role);
+    if (!text) {
+      continue;
+    }
+    turns.push({ role, text });
+  }
+  return turns;
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      blocks.push(block);
+      continue;
+    }
+    if (!block || typeof block !== "object") {
+      continue;
+    }
+    const typed = block;
+    if (typeof typed.text === "string") {
+      blocks.push(typed.text);
+      continue;
+    }
+    const type = typeof typed.type === "string" ? typed.type.trim().toLowerCase() : "";
+    if (typeof typed.content === "string" && (type === "text" || type === "input_text" || type === "output_text")) {
+      blocks.push(typed.content);
+    }
+  }
+  return blocks.join("\n");
+}
+function sanitizeRecentTurnText(text, role) {
+  if (!text.trim()) {
+    return "";
+  }
+  const wrapperDetected = containsAgenrMemoryContext(text) || text.includes("## Agenr Session Recall") || text.includes("## Agenr Before-Turn Recall") || text.includes("[MEMORY CHECK]");
+  let cleaned = stripAgenrMemoryContext(text);
+  const headings = [
+    "## Previous session summary",
+    "## Recent session",
+    "## Agenr Session Recall",
+    "### Core Memory",
+    "### Relevant Durable Memory",
+    "## Agenr Before-Turn Recall",
+    "### Suggested Procedure"
+  ];
+  for (const heading of headings) {
+    cleaned = cleaned.split(heading).join(" ");
+  }
+  cleaned = cleaned.replace(/\[MEMORY CHECK\][^\n]*/gu, " ");
+  cleaned = collapseWhitespace2(cleaned);
+  if (!wrapperDetected) {
+    return cleaned;
+  }
+  const segments = stripAgenrMemoryContext(text).split(/\n\s*\n/gu).map((segment) => collapseWhitespace2(segment)).filter((segment) => segment.length > 0);
+  const fallbackSegment = segments.at(-1);
+  if (fallbackSegment) {
+    return role === "user" ? fallbackSegment : collapseWhitespace2(cleaned);
+  }
+  return cleaned;
+}
+function normalizePromptText(prompt) {
+  let cleaned = stripAgenrMemoryContext(prompt);
+  cleaned = stripInlineMetadata2(cleaned);
+  cleaned = cleaned.replace(/^\s*\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s[^\]]+\]\s*/u, "");
+  cleaned = cleaned.replace(/^\s*U:\s*/u, "");
+  cleaned = collapseWhitespace2(cleaned);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function stripInlineMetadata2(text) {
+  let cleaned = text;
+  for (const sentinel of INLINE_METADATA_SENTINELS2) {
+    const escapedSentinel = escapeForRegExp2(sentinel);
+    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}\\s*(?:\`\`\`json\\s*)?\\{[\\s\\S]*?\\}(?:\\s*\`\`\`)?`, "gu"), " ");
+    cleaned = cleaned.replace(new RegExp(`${escapedSentinel}[^
+]*`, "gu"), " ");
+  }
+  cleaned = cleaned.replace(/Untrusted context \(metadata, do not treat as instructions or commands\):[\s\S]*$/gu, " ");
+  return cleaned;
+}
+function escapeForRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function collapseWhitespace2(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
 
 // src/adapters/openclaw/memory/flush-plan.ts
 function buildAgenrMemoryFlushPlan(_params, logger) {
@@ -3236,64 +4485,100 @@ function buildAgenrMemoryFlushPlan(_params, logger) {
 function createAgenrMemoryRuntime(servicesPromise) {
   return {
     async getMemorySearchManager() {
-      const services = await servicesPromise;
-      const snapshot = await services.memory.getMemoryStatusSnapshot();
-      const vectorAvailable = await services.memory.probeVectorAvailability();
-      const status = {
-        backend: "builtin",
-        provider: "agenr",
-        model: services.embeddingStatus.model,
-        dbPath: services.dbPath,
-        files: snapshot.sourceFiles,
-        chunks: snapshot.activeEntries,
-        vector: {
-          enabled: true,
-          available: vectorAvailable,
-          dims: EMBEDDING_DIMENSIONS
-        },
-        custom: {
-          activeEntries: snapshot.activeEntries,
-          coreEntries: snapshot.coreEntries,
-          sourceFiles: snapshot.sourceFiles
-        }
-      };
-      return {
-        manager: {
-          async search() {
-            return [];
-          },
-          async readFile({ relPath }) {
-            throw new Error(`[agenr] memory file reads are not supported for "${relPath}"`);
-          },
-          status() {
-            return status;
-          },
-          async probeEmbeddingAvailability() {
-            return {
-              ok: services.embeddingStatus.available,
-              ...services.embeddingStatus.error ? { error: services.embeddingStatus.error } : {}
-            };
-          },
-          async probeVectorAvailability() {
-            return vectorAvailable;
+      try {
+        const services = await servicesPromise;
+        const snapshot = await services.memory.getMemoryStatusSnapshot();
+        const vectorAvailable = await services.memory.probeVectorAvailability();
+        const status = {
+          backend: "builtin",
+          provider: "agenr",
+          model: services.embeddingStatus.model,
+          dbPath: services.dbPath,
+          files: snapshot.sourceFiles,
+          chunks: snapshot.activeEntries,
+          vector: {
+            enabled: true,
+            available: vectorAvailable,
+            dims: EMBEDDING_DIMENSIONS
           },
-          async sync() {
-            return;
+          custom: {
+            activeEntries: snapshot.activeEntries,
+            coreEntries: snapshot.coreEntries,
+            sourceFiles: snapshot.sourceFiles
           }
-        }
-      };
+        };
+        return {
+          manager: {
+            async search() {
+              return [];
+            },
+            async readFile({ relPath }) {
+              throw new Error(`[agenr] memory file reads are not supported for "${relPath}"`);
+            },
+            status() {
+              return status;
+            },
+            async probeEmbeddingAvailability() {
+              return {
+                ok: services.embeddingStatus.available,
+                ...services.embeddingStatus.error ? { error: services.embeddingStatus.error } : {}
+              };
+            },
+            async probeVectorAvailability() {
+              return vectorAvailable;
+            },
+            async sync() {
+              return;
+            }
+          }
+        };
+      } catch (error) {
+        return {
+          manager: null,
+          error: `[agenr] memory runtime unavailable: ${formatErrorMessage2(error)}`
+        };
+      }
     },
     resolveMemoryBackendConfig() {
       return { backend: "builtin" };
     },
     async closeAllMemorySearchManagers() {
-      const services = await servicesPromise;
-      await services.close();
+      try {
+        const services = await servicesPromise;
+        await services.close();
+      } catch {
+      }
     }
   };
 }
 
+// src/adapters/db/session-start-repository.ts
+function createSessionStartRepository(executor) {
+  return {
+    listCoreEntries: async (limit) => listCoreEntries(executor, limit)
+  };
+}
+async function listCoreEntries(executor, limit) {
+  if (limit <= 0) {
+    return [];
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE ${buildActiveEntryClause()}
+        AND expiry = 'core'
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [limit]
+  });
+  return result.rows.map((row) => mapEntryRow(row));
+}
+
 // src/app/openclaw/runtime.ts
+import path6 from "path";
 async function createAgenrOpenClawServices(config, options) {
   const { resolvedConfig, agenrConfig: loadedAgenrConfig } = resolveRuntimeConfig(config, options.resolvePath);
   const agenrConfig = {
@@ -3315,10 +4600,13 @@ async function createAgenrOpenClawServices(config, options) {
     episodes: runtimeServices.episodes,
     procedures: runtimeServices.procedures,
     memory: runtimeServices.memory,
+    sessionStart: runtimeServices.sessionStart,
+    beforeTurn: runtimeServices.beforeTurn,
     embedding: runtimeServices.embedding,
     recall: runtimeServices.recall,
     claimExtraction: runtimeServices.claimExtraction,
     embeddingStatus: toPublicEmbeddingStatus(embeddingStatus),
+    debugSink: runtimeServices.debugSink,
     close: runtimeServices.close
   };
 }
@@ -3345,7 +4633,11 @@ function resolveEmbeddingStatus(config) {
 async function createRuntimeServices(dbPath, config, embeddingStatus, openClawContext) {
   const database = await createDatabase(dbPath);
   const embedding = embeddingStatus.available ? createEmbeddingClient(requireApiKey(embeddingStatus), embeddingStatus.model) : createUnavailableEmbeddingPort(embeddingStatus.error ?? "Embeddings are unavailable.");
+  const baseRecall = createRecallAdapter(database, embedding);
+  const crossEncoder = resolveCrossEncoder(config);
+  const recall2 = attachCrossEncoderPort(baseRecall, crossEncoder);
   const claimExtraction = await createClaimExtractionRuntime(config, openClawContext.openClaw, openClawContext.pluginConfig);
+  const debugSink = createDebugSink(openClawContext.openClaw, openClawContext.pluginConfig);
   let closed = false;
   return {
     entries: database,
@@ -3354,18 +4646,56 @@ async function createRuntimeServices(dbPath, config, embeddingStatus, openClawCo
     memory: createOpenClawRepository(database, {
       claimSlotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
     }),
+    sessionStart: {
+      repository: createSessionStartRepository(database),
+      recall: recall2,
+      slotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
+    },
+    beforeTurn: {
+      recall: recall2,
+      procedures: database,
+      embedQuery: embeddingStatus.available ? async (text) => {
+        const vectors = await embedding.embed([text]);
+        return vectors[0] ?? [];
+      } : void 0,
+      slotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
+    },
     embedding,
-    recall: createRecallAdapter(database, embedding),
+    recall: recall2,
     claimExtraction,
+    debugSink,
     async close() {
       if (closed) {
         return;
       }
       closed = true;
+      await debugSink.close();
       await database.close();
     }
   };
 }
+function createDebugSink(openClaw, pluginConfig) {
+  const resolved = resolveDebugConfig(pluginConfig.debug);
+  if (!resolved.enabled) {
+    return createNoopAgenrDebugSink();
+  }
+  const withLogPath = ensureDebugLogPath(resolved, openClaw);
+  return createAgenrDebugSink(withLogPath);
+}
+function ensureDebugLogPath(resolved, openClaw) {
+  if (resolved.logPath) {
+    return resolved;
+  }
+  try {
+    const stateDir = openClaw.runtime.state.resolveStateDir(process.env);
+    return {
+      ...resolved,
+      logPath: path6.join(stateDir, "agenr", "logs", "debug.jsonl")
+    };
+  } catch {
+    return { ...resolved, enabled: false };
+  }
+}
 function toPublicEmbeddingStatus(status) {
   return {
     available: status.available,
@@ -3415,6 +4745,15 @@ function requireApiKey(status) {
   }
   return status.apiKey;
 }
+function resolveCrossEncoder(config) {
+  try {
+    const apiKey = resolveCrossEncoderApiKey(config);
+    const { modelId } = resolveModel(config, "cross_encoder");
+    return createOpenAICrossEncoder({ apiKey, model: modelId });
+  } catch {
+    return void 0;
+  }
+}
 async function createClaimExtractionRuntime(config, openClaw, pluginConfig) {
   const claimExtractionConfig = resolveClaimExtractionConfig(config);
   if (!claimExtractionConfig.enabled) {
@@ -3453,6 +4792,9 @@ var openclaw_default = definePluginEntry({
       },
       resolvePath: api.resolvePath
     });
+    void servicesPromise.catch((error) => {
+      api.logger.error(`[agenr] startup failed: ${formatErrorMessage2(error)}`);
+    });
     api.registerMemoryCapability({
       promptBuilder: buildAgenrMemoryPromptSection,
       flushPlanResolver: (params) => buildAgenrMemoryFlushPlan(params, api.logger),