agenr 3.1.0 → 3.3.0

package/dist/adapters/openclaw/index.js

@@ -1,3112 +0,0 @@
-import {
-  OpenClawTranscriptParser,
-  deriveOpenClawSessionIdFromFilePath,
-  openClawTranscriptParser,
-  parseTuiSessionKey,
-  readOpenClawSessionsStore
-} from "../../chunk-JSVQILB3.js";
-import {
-  BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K,
-  BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K,
-  RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K,
-  RECALL_DEBUG_ARTIFACT_MAX_TOP_K
-} from "../../chunk-GELCEVFA.js";
-import {
-  EPISODE_SUMMARY_TIMEOUT_MS,
-  FETCH_TOOL_PARAMETERS,
-  RECALL_TOOL_PARAMETERS,
-  STORE_TOOL_PARAMETERS,
-  UPDATE_TOOL_PARAMETERS,
-  buildClaimExtractionRuntime,
-  buildRecallToolServices,
-  composeHostPluginServices,
-  createDeadlineAwareEpisodeSummaryLlm,
-  createSessionStartTracker,
-  embedEpisodeSummaryWithinBudget,
-  extractRecentTurnsFromMessages,
-  formatAgenrSessionStartRecall,
-  formatUnifiedRecallResults,
-  normalizeOptionalBoolean,
-  normalizeOptionalPositiveInteger,
-  normalizePluginInjectionMemoryPolicyConfig,
-  normalizePromptText,
-  parseFetchToolParams,
-  parseRecallToolParams,
-  parseStoreToolParams,
-  parseUpdateToolParams,
-  resolveBeforeTurnPolicy,
-  resolveSessionIdentityKey,
-  resolveSessionStartPolicy,
-  runFetchMemoryTool,
-  runRecallMemoryTool,
-  runSessionStart,
-  runStoreMemoryTool,
-  runUpdateMemoryTool,
-  writeBoundedSingleTranscriptEpisode
-} from "../../chunk-E2DHUFZK.js";
-import {
-  asRecord,
-  buildEntryMemoryResolverPorts,
-  createSingleTranscriptDiscoveryPort,
-  formatErrorMessage,
-  formatTargetSelector,
-  readBooleanParam,
-  resolveTargetEntry,
-  sanitizeFetchToolParams,
-  sanitizeUpdateToolParams
-} from "../../chunk-EEEL53X4.js";
-import {
-  containsAgenrMemoryContext,
-  formatAgenrBeforeTurnRecall,
-  runBeforeTurn,
-  stripAgenrMemoryContext
-} from "../../chunk-V5CDMHRN.js";
-import {
-  EMBEDDING_DIMENSIONS,
-  buildRecallToolDetails,
-  formatRecallToolSummary,
-  formatUnifiedRecallLogSummary,
-  sanitizeRecallToolParams,
-  sanitizeStoreToolParams,
-  truncate
-} from "../../chunk-NNO2V4GH.js";
-import {
-  resolveClaimSlotPolicy
-} from "../../chunk-5LADPJ4C.js";
-
-// src/adapters/openclaw/index.ts
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-
-// src/adapters/openclaw/tools/shared.ts
-import { failedTextResult, readNumberParam, readStringArrayParam, readStringParam, textResult } from "openclaw/plugin-sdk/agent-runtime";
-var OPENCLAW_PARAM_READER = {
-  readString: readStringParam,
-  readNumber: readNumberParam,
-  readStringArray: readStringArrayParam
-};
-function toOpenClawToolResult(outcome) {
-  if (outcome.failed) {
-    return failedTextResult(outcome.text, {
-      ...outcome.details,
-      status: "failed"
-    });
-  }
-  return textResult(outcome.text, outcome.details);
-}
-async function resolveTargetEntry2(services, params, options = {}) {
-  return resolveTargetEntry(buildEntryMemoryResolverPorts(services), params, options);
-}
-function logToolCall(logger, toolName, ctx, summary, sanitizedParams) {
-  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} ${summary}`);
-  logger.info(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} params=${JSON.stringify(sanitizedParams)}`);
-}
-function logToolFailure(logger, toolName, ctx, error) {
-  logger.warn(`[agenr] tool=${toolName} ${formatToolSessionContext(ctx)} failed: ${formatErrorMessage(error)}`);
-}
-function sanitizeRetireToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {},
-    ...params.reason !== void 0 ? { reasonLength: params.reason.length } : {}
-  };
-}
-function sanitizeTraceToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {},
-    ...params.last !== void 0 ? { last: params.last } : {}
-  };
-}
-function formatTrace(entry, supersededBy, supersedes, claimFamily, recallEvents) {
-  const slotPolicy = entry.claim_key ? claimFamily ? {
-    policy: claimFamily.slotPolicy ?? resolveClaimSlotPolicy(claimFamily.claimKey).policy,
-    reason: claimFamily.slotPolicyReason ?? resolveClaimSlotPolicy(claimFamily.claimKey).reason
-  } : resolveClaimSlotPolicy(entry.claim_key) : void 0;
-  const lines = [
-    `Trace for ${entry.id} | ${entry.subject}`,
-    `type=${entry.type} expiry=${entry.expiry} importance=${entry.importance} retired=${entry.retired}`,
-    `content=${truncate(entry.content, 220)}`
-  ];
-  if (supersededBy) {
-    lines.push(`superseded_by=${supersededBy.id} | ${supersededBy.subject}`);
-  }
-  if (supersedes.length > 0) {
-    lines.push(`supersedes=${supersedes.map((item) => `${item.id} (${item.subject})`).join(", ")}`);
-  }
-  if (entry.claim_key) {
-    lines.push(`claim_key=${entry.claim_key}`);
-    if (slotPolicy) {
-      lines.push(`slot_policy=${slotPolicy.policy}`);
-      lines.push(`slot_policy_reason=${slotPolicy.reason}`);
-    }
-  }
-  if (claimFamily && claimFamily.entries.length > 0) {
-    lines.push(
-      `claim_family=${claimFamily.claimKey} | slot_policy=${slotPolicy?.policy ?? "exclusive"} | ${claimFamily.entries.map((item) => `${item.id}:${describeTraceEntryState(item)}:${formatClaimLifecycleLabel(item)}`).join(", ")}`
-    );
-    if (slotPolicy) {
-      lines.push(`claim_family_policy_reason=${slotPolicy.reason}`);
-    }
-    const transitionSummary = summarizeTraceClaimFamilyTransition(claimFamily.entries);
-    if (transitionSummary) {
-      lines.push(`transition=${transitionSummary}`);
-    }
-  }
-  if (entry.valid_from || entry.valid_to) {
-    lines.push(`validity=${entry.valid_from ?? "?"} -> ${entry.valid_to ?? "ongoing"}`);
-  }
-  if (entry.supersession_kind) {
-    lines.push(`supersession_kind=${entry.supersession_kind}${entry.supersession_reason ? ` reason=${truncate(entry.supersession_reason, 120)}` : ""}`);
-  }
-  if (recallEvents.length > 0) {
-    lines.push(
-      `recent_recalls=${recallEvents.map((event) => `${event.recalledAt}${event.query ? ` query=${event.query}` : ""}${event.sessionKey ? ` session=${event.sessionKey}` : ""}`).join(" ; ")}`
-    );
-  }
-  return lines.join("\n");
-}
-function toolFailureResult(error) {
-  return failedTextResult(formatErrorMessage(error), {
-    status: "failed"
-  });
-}
-function formatToolSessionContext(ctx) {
-  const normalizedSessionId = ctx.sessionId?.trim();
-  const normalizedSessionKey = ctx.sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-function describeTraceEntryState(entry) {
-  if (entry.superseded_by) {
-    return "superseded";
-  }
-  if (entry.retired || entry.valid_to) {
-    return "historical";
-  }
-  return "current";
-}
-function formatClaimLifecycleLabel(entry) {
-  if (!entry.claim_key) {
-    return "no-key";
-  }
-  return entry.claim_key_status ?? "legacy";
-}
-function summarizeTraceClaimFamilyTransition(entries) {
-  const current = entries.find((entry) => !entry.retired && !entry.superseded_by);
-  const prior = [...entries].reverse().find((entry) => entry.id !== current?.id && (entry.superseded_by !== void 0 || entry.retired || entry.valid_to !== void 0));
-  if (current && prior) {
-    return `${prior.id} -> ${current.id}`;
-  }
-  if (prior) {
-    return `${prior.id} is historical with no current sibling in the traced family`;
-  }
-  if (current) {
-    return `${current.id} is the only current sibling in the traced family`;
-  }
-  return void 0;
-}
-
-// src/adapters/openclaw/tools/fetch.ts
-function createAgenrFetchTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_fetch",
-    label: "Agenr Fetch",
-    description: "Fetch the full body and metadata for one durable memory entry by id or subject.",
-    parameters: FETCH_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = parseFetchToolParams(rawParams, OPENCLAW_PARAM_READER);
-        logToolCall(logger, "agenr_fetch", ctx, `target=${formatTargetSelector(params.id, params.subject)}`, sanitizeFetchToolParams(params));
-        const services = await servicesPromise;
-        return toOpenClawToolResult(
-          await runFetchMemoryTool(params, services, {
-            extraDetails: { sessionKey: ctx.sessionKey }
-          })
-        );
-      } catch (error) {
-        logToolFailure(logger, "agenr_fetch", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/recall.ts
-import { textResult as textResult2 } from "openclaw/plugin-sdk/agent-runtime";
-import { randomUUID } from "crypto";
-
-// 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/recall.ts
-function createAgenrRecallTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_recall",
-    label: "Agenr Recall",
-    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y and procedural questions like how to do something or what steps to follow; use mode=entries for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions; use mode=procedures for canonical methods and checklists. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
-    parameters: RECALL_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = parseRecallToolParams(rawParams, OPENCLAW_PARAM_READER);
-        const sanitizedParams = sanitizeRecallToolParams(params);
-        logToolCall(logger, "agenr_recall", ctx, formatRecallToolSummary(params), sanitizedParams);
-        const services = await servicesPromise;
-        void services.debugSink.emit({
-          type: "tool_call",
-          tool: "agenr_recall",
-          ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
-          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
-          params: sanitizedParams
-        });
-        const result = await runRecallMemoryTool(params, buildRecallToolServices(services), {
-          sessionKey: ctx.sessionKey,
-          slotPolicyConfig: services.pluginConfig.memoryPolicy?.slotPolicies,
-          debugLog: (message) => {
-            logger.debug?.(message);
-          }
-        });
-        logger.info(
-          `[agenr] tool=agenr_recall session=${ctx.sessionId ?? "unknown"} key=${ctx.sessionKey ?? "unknown"} result: ${formatUnifiedRecallLogSummary(result)}`
-        );
-        emitRecallDebugArtifacts(services, ctx, params.query, result);
-        return textResult2(formatUnifiedRecallResults(result), buildRecallToolDetails(result));
-      } catch (error) {
-        logToolFailure(logger, "agenr_recall", ctx, error);
-        await emitRecallError(servicesPromise, ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-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 readStringParam2, textResult as textResult3 } from "openclaw/plugin-sdk/agent-runtime";
-var RETIRE_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    id: {
-      type: "string",
-      description: "Entry id to retire. Provide exactly one of id or subject."
-    },
-    subject: {
-      type: "string",
-      description: "Subject text to resolve when the id is unknown. The most recent exact or substring match wins. Provide exactly one of id or subject."
-    },
-    reason: {
-      type: "string",
-      description: "Optional retirement reason so later trace output explains why this memory was removed."
-    }
-  }
-};
-function createAgenrRetireTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_retire",
-    label: "Agenr Retire",
-    description: "Mark a memory entry as retired (soft delete). Retired entries are excluded from all recall.",
-    parameters: RETIRE_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = asRecord(rawParams);
-        const id = readStringParam2(params, "id");
-        const subject = readStringParam2(params, "subject");
-        const reason = readStringParam2(params, "reason");
-        logToolCall(logger, "agenr_retire", ctx, `target=${formatTargetSelector(id, subject)}`, sanitizeRetireToolParams({ id, subject, reason }));
-        const services = await servicesPromise;
-        const entry = await resolveTargetEntry2(services, params);
-        const retired = await services.entries.retireEntry(entry.id, reason);
-        if (!retired) {
-          return failedTextResult2(`Entry ${entry.id} is not active, so it could not be retired.`, {
-            status: "failed",
-            entryId: entry.id
-          });
-        }
-        return textResult3(`Retired "${entry.subject}".`, {
-          status: "retired",
-          entryId: entry.id,
-          subject: entry.subject,
-          sessionKey: ctx.sessionKey
-        });
-      } catch (error) {
-        logToolFailure(logger, "agenr_retire", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/store.ts
-function createAgenrStoreTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_store",
-    label: "Agenr Store",
-    description: "Store a new durable memory entry in agenr. Apply the future-session test first: will a fresh future session make a better decision because this was stored, or are you just logging that something happened?\n\nIf another system is already the canonical record - such as version control, a task or ticket tracker, a calendar, a signed document, a chat or email thread, or a database/CRM - usually do not store that record here. Store only the durable takeaway: the standing implication, rule, lesson, preference, risk, or relationship.\n\nType guide: fact = durable truth about a person, system, place, or how something works. decision = a standing rule, constraint, policy, or chosen approach future sessions should follow. preference = what someone likes, wants, values, or wants avoided. lesson = a non-obvious takeaway learned from experience that should change future behavior. milestone = a rare one-time event with durable future significance, not ordinary execution progress. relationship = a meaningful durable connection between people, groups, or systems.\n\nUsually do not store: 'I merged PR #123.', 'I filed a ticket with support.', 'We had a meeting at 3 PM.', 'I sent the contract for signature.', 'We spent two hours debugging the outage.' Do store the takeaway instead: 'Always use the structured export path because raw sync corrupts timestamps.' 'Jim prefers text-first updates and dislikes surprise calls.' 'Service restarts fail unless config Y is enabled.' 'The office Wi-Fi name is Acorn-5G.'\n\nDo not use decision as a catch-all for important activity updates. Do not store plans, checklists, speculative future state, progress snapshots, session narration, or rephrased recalled material.\n\nWhen replacing an existing fact, pass `supersedes` with the old entry's ID. When storing a slot-like fact (for example, a library version or a rollout strategy), pass `claimKey` to enable future supersession detection.\n\nDo not ask before storing - but do ask whether future-you actually needs it.",
-    parameters: STORE_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        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;
-        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}`)
-          })
-        );
-      } catch (error) {
-        logToolFailure(logger, "agenr_store", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/trace.ts
-import { failedTextResult as failedTextResult3, readStringParam as readStringParam3, textResult as textResult4 } from "openclaw/plugin-sdk/agent-runtime";
-var TRACE_TOOL_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    id: {
-      type: "string",
-      description: "Entry id to trace. Provide exactly one of id, subject, or last."
-    },
-    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, subject, or last."
-    },
-    last: {
-      type: "boolean",
-      description: "Set true to trace the most recently created agenr entry. Provide exactly one of id, subject, or last."
-    }
-  }
-};
-function createAgenrTraceTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_trace",
-    label: "Agenr Trace",
-    description: "Trace the provenance of a knowledge entry. The current v1 trace view shows the entry itself, supersession links, and recent recall history. Accepts id, subject, or last for lookup.",
-    parameters: TRACE_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = asRecord(rawParams);
-        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 resolveTargetEntry2(services, params, { allowLast: true });
-        const trace = await services.memory.getEntryTrace(entry.id);
-        if (!trace) {
-          return failedTextResult3(`Entry ${entry.id} was not found for tracing.`, {
-            status: "failed",
-            entryId: entry.id
-          });
-        }
-        return textResult4(formatTrace(trace.entry, trace.supersededBy, trace.supersedes, trace.claimFamily, trace.recallEvents), {
-          status: "ok",
-          sessionKey: ctx.sessionKey,
-          trace: {
-            entry: trace.entry,
-            supersededBy: trace.supersededBy,
-            supersedes: trace.supersedes,
-            claimFamily: trace.claimFamily,
-            recallEvents: trace.recallEvents
-          }
-        });
-      } catch (error) {
-        logToolFailure(logger, "agenr_trace", ctx, error);
-        return toolFailureResult(error);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/update.ts
-function createAgenrUpdateTool(ctx, servicesPromise, logger) {
-  return {
-    name: "agenr_update",
-    label: "Agenr Update",
-    description: "Update an existing memory entry in place. Currently supports importance, expiry, claim_key, valid_from, and valid_to.",
-    parameters: UPDATE_TOOL_PARAMETERS,
-    async execute(_toolCallId, rawParams) {
-      try {
-        const params = parseUpdateToolParams(rawParams, OPENCLAW_PARAM_READER);
-        logToolCall(
-          logger,
-          "agenr_update",
-          ctx,
-          `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;
-        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);
-      }
-    }
-  };
-}
-
-// src/adapters/openclaw/tools/index.ts
-function registerAgenrOpenClawTools(api, servicesPromise, logger) {
-  api.registerTool((ctx) => createAgenrStoreTool(ctx, servicesPromise, logger), { names: ["agenr_store"] });
-  api.registerTool((ctx) => createAgenrRecallTool(ctx, servicesPromise, logger), { names: ["agenr_recall"] });
-  api.registerTool((ctx) => createAgenrFetchTool(ctx, servicesPromise, logger), { names: ["agenr_fetch"] });
-  api.registerTool((ctx) => createAgenrRetireTool(ctx, servicesPromise, logger), { names: ["agenr_retire"] });
-  api.registerTool((ctx) => createAgenrUpdateTool(ctx, servicesPromise, logger), { names: ["agenr_update"] });
-  api.registerTool((ctx) => createAgenrTraceTool(ctx, servicesPromise, logger), { names: ["agenr_trace"] });
-}
-
-// src/adapters/openclaw/openclaw.plugin.json
-var openclaw_plugin_default = {
-  id: "agenr",
-  name: "agenr",
-  version: "3.1.0",
-  description: "agenr memory plugin for OpenClaw",
-  kind: "memory",
-  contracts: {
-    tools: ["agenr_store", "agenr_recall", "agenr_fetch", "agenr_retire", "agenr_update", "agenr_trace"]
-  },
-  uiHints: {
-    dbPath: {
-      label: "Database path",
-      help: "Optional override for the agenr knowledge database. Defaults to the dbPath in agenr's config.json, then ~/.agenr/knowledge.db."
-    },
-    configPath: {
-      label: "Config path",
-      help: "Optional path to agenr's config.json. Defaults to AGENR_CONFIG_PATH, then config.json next to dbPath when dbPath is set, then ~/.agenr/config.json."
-    },
-    continuityModel: {
-      label: "Continuity summary model",
-      help: "Optional model override for continuity summary generation (provider/model format). Falls back to the agent's primary model when unset."
-    },
-    episodeModel: {
-      label: "Episode summary model",
-      help: "Optional model override for episode summary generation (provider/model format). Falls back to the agent's primary model when unset."
-    },
-    claimExtractionModel: {
-      label: "Claim extraction model",
-      help: "Model used for claim-key extraction when storing entries. Uses OpenClaw's configured auth. Format: provider/model (for example, openai/gpt-5.4-nano). Defaults to the agent's primary model."
-    },
-    storeNudge: {
-      label: "Store nudge",
-      help: "Optional mid-session reminder settings for prompting durable memory storage after several turns of memory silence."
-    },
-    memoryPolicy: {
-      label: "Memory policy",
-      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: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      dbPath: {
-        type: "string",
-        minLength: 1
-      },
-      configPath: {
-        type: "string",
-        minLength: 1
-      },
-      continuityModel: {
-        type: "string",
-        minLength: 1,
-        description: "Model override for continuity summary generation (e.g. 'openai/gpt-5.4-mini'). Falls back to the agent's primary model."
-      },
-      episodeModel: {
-        type: "string",
-        minLength: 1,
-        description: "Model override for episode summary generation (e.g. 'openai/gpt-5.4-mini'). Falls back to the agent's primary model."
-      },
-      claimExtractionModel: {
-        type: "string",
-        minLength: 1,
-        description: "Model override for claim-key extraction at store time (e.g. 'openai/gpt-5.4-mini'). Uses OpenClaw auth and falls back to the agent's primary model."
-      },
-      storeNudge: {
-        type: "object",
-        additionalProperties: false,
-        description: "Optional mid-session reminder settings for prompting durable memory storage after several turns without memory activity.",
-        properties: {
-          enabled: {
-            type: "boolean",
-            description: "Enable or disable mid-session store nudges. Defaults to true."
-          },
-          threshold: {
-            type: "integer",
-            minimum: 1,
-            description: "Turns without durable memory activity before prompting the agent to review recent conversation. Defaults to 8."
-          },
-          maxPerSession: {
-            type: "integer",
-            minimum: 1,
-            description: "Maximum nudges injected during one session lifetime. Defaults to 5."
-          }
-        }
-      },
-      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,
-            description: "Claim-slot policy overrides keyed by canonical claim-key attribute head.",
-            properties: {
-              attributeHeads: {
-                type: "object",
-                description: "Map canonical attribute heads such as `integration` or `preference` to `exclusive` or `multivalued` read-time slot behavior.",
-                propertyNames: {
-                  pattern: "^[A-Za-z0-9][A-Za-z0-9_-]*$"
-                },
-                additionalProperties: {
-                  type: "string",
-                  enum: ["exclusive", "multivalued"]
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-// src/adapters/openclaw/config.ts
-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: {} };
-  }
-  if (!isRecord(value)) {
-    return { ok: false, errors: ["config must be an object"] };
-  }
-  const errors = [];
-  const rawDbPath = value.dbPath;
-  const dbPath = typeof rawDbPath === "string" ? rawDbPath.trim() : void 0;
-  if (rawDbPath !== void 0 && !dbPath) {
-    errors.push("dbPath must be a non-empty string");
-  }
-  const rawConfigPath = value.configPath;
-  const configPath = typeof rawConfigPath === "string" ? rawConfigPath.trim() : void 0;
-  if (rawConfigPath !== void 0 && !configPath) {
-    errors.push("configPath must be a non-empty string when provided");
-  }
-  const rawContinuityModel = value.continuityModel;
-  const continuityModel = typeof rawContinuityModel === "string" ? rawContinuityModel.trim() : void 0;
-  if (rawContinuityModel !== void 0 && !continuityModel) {
-    errors.push("continuityModel must be a non-empty string when provided");
-  } else if (continuityModel && !continuityModel.includes("/")) {
-    errors.push("continuityModel must use provider/model format when provided");
-  }
-  const rawEpisodeModel = value.episodeModel;
-  const episodeModel = typeof rawEpisodeModel === "string" ? rawEpisodeModel.trim() : void 0;
-  if (rawEpisodeModel !== void 0 && !episodeModel) {
-    errors.push("episodeModel must be a non-empty string when provided");
-  } else if (episodeModel && !episodeModel.includes("/")) {
-    errors.push("episodeModel must use provider/model format when provided");
-  }
-  const rawClaimExtractionModel = value.claimExtractionModel;
-  const claimExtractionModel = typeof rawClaimExtractionModel === "string" ? rawClaimExtractionModel.trim() : void 0;
-  if (rawClaimExtractionModel !== void 0 && !claimExtractionModel) {
-    errors.push("claimExtractionModel must be a non-empty string when provided");
-  } else if (claimExtractionModel && !claimExtractionModel.includes("/")) {
-    errors.push("claimExtractionModel must use provider/model format when provided");
-  }
-  const storeNudgeResult = normalizeStoreNudgeConfig(value.storeNudge);
-  if (!storeNudgeResult.ok) {
-    errors.push(...storeNudgeResult.errors);
-  }
-  const memoryPolicyResult = normalizePluginInjectionMemoryPolicyConfig(value.memoryPolicy);
-  if (!memoryPolicyResult.ok) {
-    errors.push(...memoryPolicyResult.errors);
-  }
-  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}`);
-    }
-  }
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-  return {
-    ok: true,
-    value: {
-      ...dbPath ? { dbPath } : {},
-      ...configPath ? { configPath } : {},
-      ...continuityModel ? { continuityModel } : {},
-      ...episodeModel ? { episodeModel } : {},
-      ...claimExtractionModel ? { claimExtractionModel } : {},
-      ...storeNudgeResult.ok && storeNudgeResult.value ? { storeNudge: storeNudgeResult.value } : {},
-      ...memoryPolicyResult.ok && memoryPolicyResult.value ? { memoryPolicy: memoryPolicyResult.value } : {},
-      ...debugResult.ok && debugResult.value ? { debug: debugResult.value } : {}
-    }
-  };
-}
-function coerceAgenrOpenClawPluginConfig(value) {
-  const normalized = normalizeAgenrOpenClawPluginConfig(value);
-  if (normalized.ok) {
-    return normalized.value;
-  }
-  throw new Error(`Invalid agenr OpenClaw plugin config: ${normalized.errors.join("; ")}`);
-}
-function createAgenrOpenClawPluginConfigSchema() {
-  return {
-    validate(value) {
-      const parsed = normalizeAgenrOpenClawPluginConfig(value);
-      return parsed.ok ? { ok: true, value: parsed.value } : { ok: false, errors: parsed.errors };
-    },
-    ...manifest.uiHints ? { uiHints: manifest.uiHints } : {},
-    jsonSchema: manifest.configSchema
-  };
-}
-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,
-    threshold: value?.threshold ?? DEFAULT_STORE_NUDGE_THRESHOLD,
-    maxPerSession: value?.maxPerSession ?? DEFAULT_STORE_NUDGE_MAX_PER_SESSION
-  };
-}
-function normalizeStoreNudgeConfig(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"] };
-  }
-  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"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(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: Object.keys(normalizedValue).length > 0 ? resolveStoreNudgeConfig(normalizedValue) : void 0
-  };
-}
-
-// src/adapters/openclaw/format/prompt-section.ts
-var MEMORY_TOOL_NAMES = {
-  recall: "agenr_recall",
-  fetch: "agenr_fetch",
-  store: "agenr_store",
-  update: "agenr_update",
-  retire: "agenr_retire",
-  trace: "agenr_trace"
-};
-var MEMORY_TOOL_NAME_SET = new Set(Object.values(MEMORY_TOOL_NAMES));
-var ORCHESTRATION_TOOL_PATTERNS = [/subagent/iu, /delegate/iu, /background/iu, /fork/iu, /teammate/iu, /parallel/iu, /spawn/iu];
-function buildAgenrMemoryPromptSection({
-  availableTools,
-  citationsMode
-}) {
-  if (!availableTools.has(MEMORY_TOOL_NAMES.recall)) {
-    return [];
-  }
-  const hasOrchestrationTool = [...availableTools].some(
-    (toolName) => !MEMORY_TOOL_NAME_SET.has(toolName) && ORCHESTRATION_TOOL_PATTERNS.some((pattern) => pattern.test(toolName))
-  );
-  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, and conservative before-turn recall may also appear as injected background context; use agenr_recall mid-session when you need context you do not already have.",
-    "agenr_recall supports exact fact recall plus historical and episodic recall behind one tool: use mode=entries for exact facts, decisions, thresholds, and versions; use mode=auto for prior-state questions like what was the previous approach, what did we use before, or what changed from X to Y; use mode=episodes when you explicitly want session narrative recall.",
-    "agenr_recall returns truncated entry previews with ids, scores, and preview_truncated flags.",
-    "For temporal narrative questions, put the time phrase in the query itself: examples include yesterday, last week, this month, 2 weeks ago, or in March.",
-    "One focused agenr_recall call with the right scope beats several broad ones.",
-    "When Agenr injects memory automatically, treat it as non-user background context and use it silently when relevant rather than forcing it into the reply.",
-    "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.",
-    "- Session handoffs and continuity summaries are approximate restart context and may be incomplete or stale.",
-    "- Live verification beats stored memory whenever you can check quickly.",
-    "The newest completed session may not be consolidated into episodes yet, so very recent work can be missing from episode recall."
-  ];
-  if (availableTools.has(MEMORY_TOOL_NAMES.store)) {
-    lines.push(
-      "Use agenr_store for durable memory, not for logging. Apply the future-session test: will a fresh future session make a better decision because this was stored, or are you just recording that something happened?"
-    );
-    lines.push(
-      "If another system already holds the canonical record - such as version control, a task or ticket tracker, a calendar, a signed document, a chat or email thread, or a database/CRM - usually do not store that record. Store only the durable takeaway: the standing rule, implication, lesson, preference, risk, or relationship."
-    );
-    lines.push(
-      "Type guide: fact = durable truth about a person, system, place, or how something works; decision = standing rule, constraint, policy, or chosen approach future sessions should follow; preference = what someone likes, wants, values, or wants avoided; lesson = non-obvious takeaway from experience that should change future behavior; milestone = rare one-time event with durable future significance, not ordinary task completion."
-    );
-    lines.push("Do not use decision as a catch-all for important activity updates.");
-    lines.push(
-      "Usually do not store: 'I merged PR #123.', 'I filed a support ticket.', 'We had a meeting at 3 PM.', 'I sent the contract for signature.', or 'We spent two hours debugging the outage.'"
-    );
-    lines.push(
-      "Do store the durable takeaway instead: 'Always use the structured export path because raw sync corrupts timestamps.' (decision or lesson), 'Jim prefers text-first updates and dislikes surprise calls.' (preference), 'Service restarts fail unless config Y is enabled.' (lesson), 'The office Wi-Fi name is Acorn-5G.' (fact)."
-    );
-    lines.push("Do not store progress snapshots or current-state narration about what is happening right now as durable memory.");
-    lines.push("Do not store plans, checklists, or speculative future state as facts or decisions.");
-    lines.push("Do not re-store recalled entries, episode summaries, continuity text, or conversation summaries as new evidence.");
-    lines.push("Do not store meta narration about the current session.");
-    lines.push(
-      "Use memory lifetimes deliberately: core is injected at every session start and should be rare, permanent is durable recall-on-demand memory, and temporary is short-horizon. Importance is 1 to 10; 7 is normal durable memory and 9 to 10 is rare and critical."
-    );
-  }
-  if (availableTools.has(MEMORY_TOOL_NAMES.update) || availableTools.has(MEMORY_TOOL_NAMES.retire)) {
-    lines.push("When memory is contradicted by live evidence, fix it with agenr_update or agenr_retire instead of silently working around it.");
-  }
-  if (availableTools.has(MEMORY_TOOL_NAMES.fetch)) {
-    lines.push("Call agenr_fetch with id when preview_truncated=true or exact stored wording is required.");
-  }
-  if (availableTools.has(MEMORY_TOOL_NAMES.trace)) {
-    lines.push("Use agenr_trace when provenance, recall history, or supersession matters.");
-  }
-  if (hasOrchestrationTool) {
-    lines.push("Do not summarize or assert results from unfinished background work.");
-    lines.push("Do not fabricate completion status for delegated tasks.");
-  }
-  if (citationsMode === "off") {
-    lines.push("Citations are disabled: do not mention agenr entry IDs in user-facing replies unless the user asks for them.");
-  } else {
-    lines.push("Citations: mention the relevant agenr entry ID only when it helps the user verify a claim.");
-  }
-  lines.push("");
-  return lines;
-}
-
-// src/adapters/openclaw/logging.ts
-function formatSessionContext(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-function formatErrorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/adapters/openclaw/session/state.ts
-function createMidSessionTracker() {
-  const states = /* @__PURE__ */ new Map();
-  return {
-    getOrCreate(sessionId, sessionKey) {
-      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
-      if (!identityKey) {
-        return void 0;
-      }
-      const existingState = states.get(identityKey);
-      if (existingState) {
-        return existingState;
-      }
-      const nextState = createMidSessionState();
-      states.set(identityKey, nextState);
-      return nextState;
-    },
-    peek(sessionId, sessionKey) {
-      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
-      return identityKey ? states.get(identityKey) : void 0;
-    },
-    recordTurn(sessionId, sessionKey) {
-      const state = this.getOrCreate(sessionId, sessionKey);
-      if (!state) {
-        return void 0;
-      }
-      state.turnCount += 1;
-      return state;
-    },
-    clear(sessionId, sessionKey) {
-      const identityKey = resolveSessionIdentityKey(sessionId, sessionKey);
-      return identityKey ? states.delete(identityKey) : false;
-    },
-    activeCount() {
-      return states.size;
-    }
-  };
-}
-function pushMidSessionStoredSubject(state, subject) {
-  const normalizedSubject = subject?.trim();
-  if (!normalizedSubject) {
-    return;
-  }
-  const existingIndex = state.storedSubjects.findIndex((value) => value === normalizedSubject);
-  if (existingIndex >= 0) {
-    state.storedSubjects.splice(existingIndex, 1);
-  }
-  state.storedSubjects.push(normalizedSubject);
-  while (state.storedSubjects.length > MAX_STORED_SUBJECTS) {
-    state.storedSubjects.shift();
-  }
-}
-function createMidSessionState() {
-  return {
-    turnCount: 0,
-    lastSuccessfulStoreTurn: 0,
-    lastMemoryActionTurn: 0,
-    lastExplicitMemoryActionTurn: 0,
-    nudgeCount: 0,
-    entriesStored: 0,
-    storedSubjects: []
-  };
-}
-var MAX_STORED_SUBJECTS = 5;
-
-// src/adapters/openclaw/hooks/after-tool-call.ts
-var STORE_TOOL_NAME = "agenr_store";
-var UPDATE_TOOL_NAME = "agenr_update";
-var RETIRE_TOOL_NAME = "agenr_retire";
-function handleAgenrAfterToolCall(event, ctx, params) {
-  if (event.toolName !== STORE_TOOL_NAME && event.toolName !== UPDATE_TOOL_NAME && event.toolName !== RETIRE_TOOL_NAME) {
-    return;
-  }
-  const state = params.midSessionTracker.getOrCreate(ctx.sessionId, ctx.sessionKey);
-  if (!state) {
-    params.logger.debug?.(`[agenr] after_tool_call: skipped mid-session tracking without session identity for tool=${event.toolName}`);
-    return;
-  }
-  if (event.toolName === STORE_TOOL_NAME) {
-    handleStoreToolResult(event, ctx, state, params.logger);
-    return;
-  }
-  state.lastMemoryActionTurn = state.turnCount;
-  state.lastExplicitMemoryActionTurn = state.turnCount;
-  params.logger.debug?.(
-    `[agenr] after_tool_call: memory maintenance tool=${event.toolName} turn=${state.turnCount} ${formatSessionContext(ctx.sessionId, ctx.sessionKey)}`
-  );
-}
-function handleStoreToolResult(event, ctx, state, logger) {
-  const status = readToolStatus(event.result);
-  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
-  const hasExplicitMemoryParams = hasNonEmptyString(event.params.claimKey) || hasNonEmptyString(event.params.supersedes);
-  if (status === "stored" && !event.error) {
-    state.entriesStored += 1;
-    state.lastSuccessfulStoreTurn = state.turnCount;
-    state.lastMemoryActionTurn = state.turnCount;
-    if (hasExplicitMemoryParams) {
-      state.lastExplicitMemoryActionTurn = state.turnCount;
-    }
-    pushMidSessionStoredSubject(state, readString(event.params.subject));
-    logger.debug?.(`[agenr] after_tool_call: store recorded status=stored turn=${state.turnCount} entriesStored=${state.entriesStored} ${sessionContext}`);
-    return;
-  }
-  if (status === "skipped" && !event.error) {
-    state.lastMemoryActionTurn = state.turnCount;
-    if (hasExplicitMemoryParams) {
-      state.lastExplicitMemoryActionTurn = state.turnCount;
-    }
-    logger.debug?.(`[agenr] after_tool_call: store recorded status=skipped turn=${state.turnCount} ${sessionContext}`);
-    return;
-  }
-  if (hasExplicitMemoryParams) {
-    state.lastExplicitMemoryActionTurn = state.turnCount;
-  }
-  logger.debug?.(
-    `[agenr] after_tool_call: store ignored for nudge reset status=${status ?? "unknown"} error=${event.error ?? "none"} turn=${state.turnCount} ${sessionContext}`
-  );
-}
-function readToolStatus(value) {
-  const record = asRecord2(value);
-  const directStatus = readString(record?.status);
-  if (directStatus) {
-    return directStatus;
-  }
-  return readString(asRecord2(record?.details)?.status);
-}
-function asRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function readString(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const normalizedValue = value.trim();
-  return normalizedValue.length > 0 ? normalizedValue : void 0;
-}
-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 "@earendil-works/pi-ai";
-
-// src/adapters/openclaw/embedded-agent/task-runner.ts
-import * as fs from "fs/promises";
-import os from "os";
-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);
-  if (params.modelOverride) {
-    const parsedModelRef2 = parseModelRef(params.modelOverride, DEFAULT_PROVIDER);
-    if (!parsedModelRef2) {
-      throw new Error(`Invalid ${params.invalidOverrideLabel}: ${params.modelOverride}`);
-    }
-    return {
-      agentId,
-      agentDir: params.openClaw.runtime.agent.resolveAgentDir(params.openClaw.config, agentId),
-      workspaceDir: params.openClaw.runtime.agent.resolveAgentWorkspaceDir(params.openClaw.config, agentId),
-      modelRef: params.modelOverride,
-      provider: parsedModelRef2.provider,
-      model: parsedModelRef2.model
-    };
-  }
-  const modelRef = resolveAgentEffectiveModelPrimary(params.openClaw.config, agentId);
-  const parsedModelRef = modelRef ? parseModelRef(modelRef, DEFAULT_PROVIDER) : null;
-  return {
-    agentId,
-    agentDir: params.openClaw.runtime.agent.resolveAgentDir(params.openClaw.config, agentId),
-    workspaceDir: params.openClaw.runtime.agent.resolveAgentWorkspaceDir(params.openClaw.config, agentId),
-    modelRef,
-    provider: parsedModelRef?.provider ?? DEFAULT_PROVIDER,
-    model: parsedModelRef?.model ?? DEFAULT_MODEL
-  };
-}
-
-// src/adapters/openclaw/llm/openclaw-llm-client.ts
-var getModelWithStrings = getModel;
-async function createOpenClawLlmClient(openClaw, modelRef, label = "model override") {
-  const execution = resolveOpenClawEmbeddedAgentExecution({
-    openClaw,
-    modelOverride: modelRef,
-    invalidOverrideLabel: label
-  });
-  const model = getModelWithStrings(execution.provider, execution.model);
-  const auth = await openClaw.runtime.modelAuth.resolveApiKeyForProvider({
-    provider: execution.provider,
-    cfg: openClaw.config
-  });
-  const apiKey = normalizeOptionalString(auth.apiKey);
-  if (!apiKey) {
-    throw new Error(`OpenClaw auth did not resolve an API-key-compatible credential for ${execution.provider} (source=${auth.source}, mode=${auth.mode}).`);
-  }
-  const complete = async (systemPrompt, userMessage) => {
-    const response = await completeSimple(
-      model,
-      {
-        systemPrompt,
-        messages: [
-          {
-            role: "user",
-            content: userMessage,
-            timestamp: Date.now()
-          }
-        ]
-      },
-      {
-        apiKey
-      }
-    );
-    if (response.stopReason === "error") {
-      throw new Error(response.errorMessage ?? `LLM completion failed for ${execution.provider}/${execution.model}.`);
-    }
-    return extractText(response);
-  };
-  return {
-    complete,
-    completeJson: async (systemPrompt, userMessage) => {
-      const text = await complete(systemPrompt, userMessage);
-      return JSON.parse(stripCodeFence(text));
-    }
-  };
-}
-function extractText(response) {
-  if (!response.content) {
-    return "";
-  }
-  return response.content.filter((block) => block.type === "text" && block.text).map((block) => block.text ?? "").join("");
-}
-function stripCodeFence(text) {
-  const trimmed = text.trim();
-  const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/iu.exec(trimmed);
-  return match?.[1]?.trim() ?? trimmed;
-}
-function normalizeOptionalString(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
-}
-
-// src/adapters/openclaw/episode/episode-summary-prompt.ts
-var OPENCLAW_EPISODE_GENERATOR_VERSION = "openclaw-episodic-summary-v1";
-
-// src/adapters/openclaw/episode/episode-writer.ts
-async function writeOpenClawPredecessorEpisode(params) {
-  const sessionContext = formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey);
-  const writeStartedAtMs = Date.now();
-  if (!params.predecessor) {
-    params.logger.info(`[agenr] session-start predecessor episode write skipped for ${sessionContext} reason=no_predecessor`);
-    return;
-  }
-  const predecessor = params.predecessor;
-  params.logger.info(`[agenr] session-start predecessor episode write triggered for ${sessionContext} predecessor=${predecessor.sessionFile}`);
-  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}`
-      })
-    },
-    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"
-      }
-    }
-  });
-}
-function resolveSessionSurface(ctx) {
-  const sessionKey = ctx.sessionKey?.trim() ?? "";
-  if (/^agent:[^:]+:tui/i.test(sessionKey)) {
-    return "tui";
-  }
-  const provider = ctx.messageProvider?.trim();
-  if (provider) {
-    return provider.toLowerCase();
-  }
-  return void 0;
-}
-function trimOptionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function resolveOpenClawEpisodeModelRef(openClaw, agentId, modelOverride) {
-  const requestedOverride = trimOptionalString(modelOverride);
-  if (requestedOverride) {
-    return requestedOverride;
-  }
-  const resolvedAgentId = trimOptionalString(agentId) ?? resolveDefaultAgentId2(openClaw.config);
-  return resolveAgentEffectiveModelPrimary2(openClaw.config, resolvedAgentId) ?? void 0;
-}
-
-// src/adapters/openclaw/format/nudge-format.ts
-var MAX_DISPLAY_SUBJECTS = 3;
-var MAX_SUBJECT_LENGTH = 48;
-function buildStoreNudgeMessage(state, maxPerSession) {
-  const isFirstNudge = state.nudgeCount === 1;
-  const isFinalNudge = state.nudgeCount >= maxPerSession;
-  const hasStoredEntries = state.entriesStored > 0;
-  const subjectsLabel = formatStoredSubjects(state.storedSubjects) ?? "recent durable session memory";
-  if (hasStoredEntries) {
-    if (isFinalNudge) {
-      return "[MEMORY CHECK] Session may end soon. Capture final durable takeaways: validated preferences, confirmed lessons, important decisions, open risks. Skip transient progress and derivable project state.";
-    }
-    if (isFirstNudge) {
-      return `[MEMORY CHECK] You've stored ${state.entriesStored} ${state.entriesStored === 1 ? "entry" : "entries"} this session covering ${subjectsLabel}. Review recent conversation for anything else worth keeping - decisions, confirmed approaches, preferences, lessons, or open risks. Store both corrections and validated wins. Skip transient progress and derivable repo facts.`;
-    }
-    return `[MEMORY CHECK] Session memory covers ${subjectsLabel}. Check for newer durable knowledge - especially non-obvious approaches the user confirmed worked well. Use memory for future-session knowledge, not current task state.`;
-  }
-  if (isFinalNudge) {
-    return "[MEMORY CHECK] Session may end soon and nothing has been stored. Capture durable takeaways a future session would need: validated preferences, confirmed lessons, important decisions, durable facts, and open risks. Skip transient progress and derivable project state.";
-  }
-  if (isFirstNudge) {
-    return "[MEMORY CHECK] You haven't stored anything this session. Review recent conversation for future-session knowledge: decisions, preferences, lessons (including confirmed successes, not just corrections), durable facts, and open risks. Skip transient progress, derivable repo facts, and conversation summaries.";
-  }
-  return "[MEMORY CHECK] Still no stores this session. If anything here matters after session reset, store it now. Record both what went wrong and what worked well. For lessons and preferences, capture the rule, why it matters, and when it applies.";
-}
-function formatStoredSubjects(subjects) {
-  if (subjects.length === 0) {
-    return void 0;
-  }
-  const displaySubjects = subjects.slice(-MAX_DISPLAY_SUBJECTS).map((subject) => `"${truncateSubject(subject)}"`);
-  const overflowCount = subjects.length - displaySubjects.length;
-  if (overflowCount > 0) {
-    displaySubjects.push(`and ${overflowCount} more`);
-  }
-  return displaySubjects.join(", ");
-}
-function truncateSubject(subject) {
-  const trimmedSubject = subject.trim();
-  if (trimmedSubject.length <= MAX_SUBJECT_LENGTH) {
-    return trimmedSubject;
-  }
-  return `${trimmedSubject.slice(0, MAX_SUBJECT_LENGTH - 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 path3 from "path";
-function resolveOpenClawContinuitySummaryPath(sessionFile, logger) {
-  const normalizedSessionFile = sessionFile.trim();
-  const sessionId = deriveOpenClawSessionIdFromFilePath(normalizedSessionFile, logger);
-  if (!sessionId) {
-    return void 0;
-  }
-  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;
-}
-async function readOpenClawContinuitySummaryFile(sessionFile, logger) {
-  const continuitySummaryPath = resolveOpenClawContinuitySummaryPath(sessionFile, logger);
-  const sessionId = deriveOpenClawSessionIdFromFilePath(sessionFile, logger);
-  if (!continuitySummaryPath || !sessionId) {
-    return null;
-  }
-  try {
-    const continuitySummaryContent = (await fs2.readFile(continuitySummaryPath, "utf8")).trim();
-    if (continuitySummaryContent.length === 0) {
-      debugLog(logger, "continuity-summary-reader", `continuity summary file is empty for session=${sessionId} path=${continuitySummaryPath}`);
-      return null;
-    }
-    debugLog(
-      logger,
-      "continuity-summary-reader",
-      `loaded continuity summary file for session=${sessionId} path=${continuitySummaryPath} chars=${continuitySummaryContent.length}`
-    );
-    return {
-      sessionId,
-      continuitySummaryPath,
-      content: continuitySummaryContent
-    };
-  } catch (error) {
-    if (isFileNotFound(error)) {
-      debugLog(logger, "continuity-summary-reader", `continuity summary file missing for session=${sessionId} path=${continuitySummaryPath}`);
-      return null;
-    }
-    throw error;
-  }
-}
-function debugLog(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function isFileNotFound(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
-// src/adapters/openclaw/session/continuity/continuity-summary-generator.ts
-var MIN_CONTINUITY_SUMMARY_MESSAGES = 4;
-var MAX_CONTINUITY_TRANSCRIPT_CHARS = 14e3;
-var CONTINUITY_SUMMARY_TIMEOUT_MS = 3e4;
-var CONTINUITY_SUMMARY_SYSTEM_PROMPT = [
-  "You write concise narrative continuity summaries that help the next session continue smoothly.",
-  "The transcript can be about any domain. Do not assume technical, project, or coding context unless the transcript shows it.",
-  "Write 200 to 500 words in plain Markdown with no code fences.",
-  "Capture:",
-  "- what topics were discussed",
-  "- what was learned, decided, agreed on, or corrected",
-  "- what remains unfinished, open, or pending",
-  "- user preferences, clarifications, and constraints that matter for continuity",
-  "- the overall direction or intent of the conversation",
-  "Do not replay the transcript turn by turn. Do not invent facts. If something is uncertain, say so briefly."
-].join("\n");
-var ContinuitySummaryTimeoutError = class extends Error {
-  /**
-   * Creates a timeout error with a stable name for caller-side handling.
-   */
-  constructor() {
-    super("Continuity summary generation timed out.");
-    this.name = "ContinuitySummaryTimeoutError";
-  }
-};
-async function generateAndWriteOpenClawContinuitySummary(params) {
-  const sessionFile = params.sessionFile.trim();
-  const continuitySummaryPath = resolveOpenClawContinuitySummaryPath(sessionFile, params.logger);
-  if (!continuitySummaryPath) {
-    return {
-      status: "skipped",
-      reason: "missing_session_id"
-    };
-  }
-  const parsedTranscript = await openClawTranscriptParser.parseFile(sessionFile);
-  const cleanedMessages = parsedTranscript.messages.filter((message) => message.text.trim().length > 0);
-  const transcript = renderTranscriptForContinuitySummary(cleanedMessages);
-  const normalizedTranscript = capContinuityTranscript(transcript, MAX_CONTINUITY_TRANSCRIPT_CHARS);
-  debugLog2(
-    params.logger,
-    "continuity-summary",
-    `transcript adapter output for file=${sessionFile}: messages=${cleanedMessages.length} chars=${normalizedTranscript.length}`
-  );
-  if (cleanedMessages.length === 0 || normalizedTranscript.length === 0) {
-    return {
-      status: "skipped",
-      reason: "empty",
-      continuitySummaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length
-    };
-  }
-  if (cleanedMessages.length < MIN_CONTINUITY_SUMMARY_MESSAGES) {
-    return {
-      status: "skipped",
-      reason: "too_short",
-      continuitySummaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length
-    };
-  }
-  const continuityModelRef = resolveOpenClawSummaryModelRef(params.openClaw, params.agentId, params.pluginConfig?.continuityModel);
-  const continuityModel = continuityModelRef ?? "default";
-  const prompt = [
-    "Produce a concise continuity summary for the next session.",
-    "Prefer short paragraphs. Use a short 'Open loops' section only if it adds clarity.",
-    "",
-    "Transcript:",
-    normalizedTranscript
-  ].join("\n");
-  debugLog2(
-    params.logger,
-    "continuity-summary",
-    `sending continuity summary prompt model=${continuityModel} promptChars=${prompt.length} transcriptChars=${normalizedTranscript.length}`
-  );
-  params.logger.info(`[agenr] continuity-summary: using OpenClaw LLM client model=${continuityModel}`);
-  const startedAt = Date.now();
-  try {
-    const llm = await createOpenClawLlmClient(params.openClaw, continuityModelRef, "continuity model override");
-    const rawSummary = await Promise.race([
-      llm.complete(CONTINUITY_SUMMARY_SYSTEM_PROMPT, prompt),
-      new Promise((_, reject) => {
-        setTimeout(() => reject(new ContinuitySummaryTimeoutError()), CONTINUITY_SUMMARY_TIMEOUT_MS);
-      })
-    ]);
-    const durationMs = Date.now() - startedAt;
-    const normalizedContinuitySummary = normalizeContinuitySummary(rawSummary);
-    debugLog2(
-      params.logger,
-      "continuity-summary",
-      `received continuity summary response model=${continuityModel} durationMs=${durationMs} chars=${normalizedContinuitySummary.length}`
-    );
-    if (normalizedContinuitySummary.length === 0) {
-      return {
-        status: "failed",
-        reason: "empty_response",
-        continuitySummaryPath,
-        messageCount: cleanedMessages.length,
-        transcriptChars: normalizedTranscript.length,
-        model: continuityModel,
-        durationMs
-      };
-    }
-    const existingContinuitySummary = await readOpenClawContinuitySummaryFile(sessionFile, params.logger);
-    if (existingContinuitySummary?.continuitySummaryPath === continuitySummaryPath) {
-      debugLog2(
-        params.logger,
-        "continuity-summary",
-        `continuity summary file already exists at write time path=${continuitySummaryPath} chars=${existingContinuitySummary.content.length}`
-      );
-      return {
-        status: "skipped",
-        reason: "already_exists",
-        continuitySummaryPath,
-        content: existingContinuitySummary.content,
-        messageCount: cleanedMessages.length,
-        transcriptChars: normalizedTranscript.length,
-        model: continuityModel,
-        durationMs
-      };
-    }
-    const continuitySummaryBytes = Buffer.byteLength(`${normalizedContinuitySummary}
-`, "utf8");
-    await fs3.writeFile(continuitySummaryPath, `${normalizedContinuitySummary}
-`, "utf8");
-    debugLog2(
-      params.logger,
-      "continuity-summary",
-      `wrote continuity summary file path=${continuitySummaryPath} chars=${normalizedContinuitySummary.length} bytes=${continuitySummaryBytes}`
-    );
-    return {
-      status: "written",
-      continuitySummaryPath,
-      content: normalizedContinuitySummary,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length,
-      model: continuityModel,
-      durationMs,
-      bytesWritten: continuitySummaryBytes
-    };
-  } catch (error) {
-    const durationMs = Date.now() - startedAt;
-    if (error instanceof ContinuitySummaryTimeoutError) {
-      return {
-        status: "failed",
-        reason: "timeout",
-        continuitySummaryPath,
-        messageCount: cleanedMessages.length,
-        transcriptChars: normalizedTranscript.length,
-        model: continuityModel,
-        durationMs
-      };
-    }
-    debugLog2(params.logger, "continuity-summary", `continuity summary generation error for file=${sessionFile}: ${formatErrorMessage3(error)}`);
-    return {
-      status: "failed",
-      reason: formatErrorMessage3(error),
-      continuitySummaryPath,
-      messageCount: cleanedMessages.length,
-      transcriptChars: normalizedTranscript.length,
-      model: continuityModel,
-      durationMs
-    };
-  }
-}
-function renderTranscriptForContinuitySummary(messages) {
-  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
-}
-function debugLog2(logger, subsystem, message) {
-  logger.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function normalizeContinuitySummary(value) {
-  const trimmed = value.trim();
-  return trimmed.replace(/^# .+\n+/u, "").trim();
-}
-function formatErrorMessage3(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function resolveOpenClawSummaryModelRef(openClaw, agentId, modelOverride) {
-  const requestedOverride = trimOptionalString2(modelOverride);
-  if (requestedOverride) {
-    return requestedOverride;
-  }
-  const resolvedAgentId = trimOptionalString2(agentId) ?? resolveDefaultAgentId3(openClaw.config);
-  return resolveAgentEffectiveModelPrimary3(openClaw.config, resolvedAgentId) ?? void 0;
-}
-function trimOptionalString2(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function capContinuityTranscript(transcript, maxChars) {
-  if (transcript.length <= maxChars) {
-    return transcript;
-  }
-  const omissionMarker = "\n\n[Earlier middle transcript omitted for brevity]\n\n";
-  const headBudget = Math.max(0, Math.floor((maxChars - omissionMarker.length) * 0.35));
-  const tailBudget = Math.max(0, maxChars - omissionMarker.length - headBudget);
-  const head = trimToBoundary(transcript.slice(0, headBudget), false);
-  const tail = trimToBoundary(transcript.slice(-tailBudget), true);
-  return `${head}${omissionMarker}${tail}`.trim();
-}
-function trimToBoundary(value, fromStart) {
-  if (value.length === 0) {
-    return value;
-  }
-  if (fromStart) {
-    const boundary = value.search(/\s/);
-    return boundary >= 0 ? value.slice(boundary).trimStart() : value.trim();
-  }
-  const reversedBoundary = value.trimEnd().search(/\s\S*$/u);
-  return reversedBoundary >= 0 ? value.slice(0, reversedBoundary).trimEnd() : value.trim();
-}
-
-// src/adapters/openclaw/session/continuity/predecessor-resolver.ts
-import * as fs4 from "fs/promises";
-import path4 from "path";
-
-// src/adapters/openclaw/session/session-key-parser.ts
-var AGENT_SESSION_KEY_PATTERN = /^agent:([^:]+):(.+)$/i;
-var TOPIC_SUFFIX_TOKENS = 2;
-var THREAD_SUFFIX_TOKENS = 2;
-var ACCOUNT_SCOPED_DIRECT_MIN_TOKENS = 4;
-var CHANNEL_SCOPED_MIN_TOKENS = 3;
-function parseOpenClawSessionContinuityKey(sessionKey, params) {
-  const normalizedSessionKey = sessionKey.trim();
-  const normalizedMainKey = normalizeMainKey(params?.mainKey);
-  if (normalizedSessionKey.length === 0) {
-    return buildUnknownIdentity();
-  }
-  const tuiIdentity = parseTuiSessionKey(normalizedSessionKey);
-  if (tuiIdentity) {
-    return {
-      agentId: tuiIdentity.agentId,
-      kind: "tui",
-      stableLane: tuiIdentity.stableLane,
-      instanceLane: tuiIdentity.instanceLane,
-      eligible: true
-    };
-  }
-  const agentMatch = AGENT_SESSION_KEY_PATTERN.exec(normalizedSessionKey);
-  if (!agentMatch) {
-    return buildUnknownIdentity();
-  }
-  const [, rawAgentId, rawLane] = agentMatch;
-  const agentId = rawAgentId?.trim() ?? "";
-  const lane = rawLane?.trim() ?? "";
-  if (!agentId || !lane) {
-    return buildUnknownIdentity();
-  }
-  if (lane === normalizedMainKey) {
-    return {
-      agentId,
-      kind: "main",
-      stableLane: normalizedMainKey,
-      instanceLane: normalizedMainKey,
-      eligible: true
-    };
-  }
-  const tokens = lane.split(":").map((token) => token.trim()).filter((token) => token.length > 0);
-  if (tokens.length === 0) {
-    return buildUnknownIdentity(agentId);
-  }
-  if (tokens[0] === "subagent" && tokens.length >= 2) {
-    return buildIneligibleIdentity(agentId, "subagent", lane);
-  }
-  if (tokens[0] === "acp" && tokens.length >= 2) {
-    return buildIneligibleIdentity(agentId, "acp", lane);
-  }
-  if (tokens[0] === "direct" && tokens.length >= 2) {
-    return buildEligibleIdentity(agentId, "direct", lane);
-  }
-  if (tokens.length >= ACCOUNT_SCOPED_DIRECT_MIN_TOKENS && tokens[2] === "direct") {
-    return buildEligibleIdentity(agentId, "direct", lane);
-  }
-  if (tokens.length >= CHANNEL_SCOPED_MIN_TOKENS && tokens[1] === "direct") {
-    return buildEligibleIdentity(agentId, "direct", lane);
-  }
-  if (isSupportedGroupLane(tokens)) {
-    return buildEligibleIdentity(agentId, "group", lane);
-  }
-  if (isSupportedChannelLane(tokens)) {
-    return buildEligibleIdentity(agentId, "channel", lane);
-  }
-  return buildUnknownIdentity(agentId);
-}
-function isSupportedGroupLane(tokens) {
-  if (tokens.length < CHANNEL_SCOPED_MIN_TOKENS || tokens[1] !== "group" || !tokens[0] || !tokens[2]) {
-    return false;
-  }
-  if (tokens.length === CHANNEL_SCOPED_MIN_TOKENS) {
-    return true;
-  }
-  return tokens.length === CHANNEL_SCOPED_MIN_TOKENS + TOPIC_SUFFIX_TOKENS && tokens[3] === "topic" && Boolean(tokens[4]);
-}
-function isSupportedChannelLane(tokens) {
-  if (tokens.length < CHANNEL_SCOPED_MIN_TOKENS || tokens[1] !== "channel" || !tokens[0] || !tokens[2]) {
-    return false;
-  }
-  if (tokens.length === CHANNEL_SCOPED_MIN_TOKENS) {
-    return true;
-  }
-  return tokens.length === CHANNEL_SCOPED_MIN_TOKENS + THREAD_SUFFIX_TOKENS && tokens[3] === "thread" && Boolean(tokens[4]);
-}
-function normalizeMainKey(mainKey) {
-  return mainKey?.trim() || "main";
-}
-function buildEligibleIdentity(agentId, kind, lane) {
-  return {
-    agentId,
-    kind,
-    stableLane: lane,
-    instanceLane: lane,
-    eligible: true
-  };
-}
-function buildIneligibleIdentity(agentId, kind, lane) {
-  return {
-    agentId,
-    kind,
-    stableLane: lane,
-    instanceLane: lane,
-    eligible: false
-  };
-}
-function buildUnknownIdentity(agentId = null) {
-  return {
-    agentId,
-    kind: "unknown",
-    stableLane: null,
-    instanceLane: null,
-    eligible: false
-  };
-}
-
-// src/adapters/openclaw/session/continuity/predecessor-resolver.ts
-async function resolveOpenClawSessionPredecessor(ctx, tracker, params) {
-  const sessionContext = formatSessionContext2(ctx.sessionId, ctx.sessionKey);
-  const currentIdentity = parseOpenClawSessionContinuityKey(ctx.sessionKey ?? "", {
-    mainKey: params.mainKey
-  });
-  debugLog3(
-    params.logger,
-    "predecessor",
-    `parsed current identity for ${sessionContext}: kind=${currentIdentity.kind} stableLane=${currentIdentity.stableLane ?? "unknown"} eligible=${currentIdentity.eligible}`
-  );
-  if (!currentIdentity.eligible || !currentIdentity.agentId) {
-    debugLog3(
-      params.logger,
-      "predecessor",
-      `skipping predecessor resolution for ${sessionContext}: kind=${currentIdentity.kind} eligible=${currentIdentity.eligible} agentId=${currentIdentity.agentId ?? "unknown"}`
-    );
-    return void 0;
-  }
-  const sessionsDir = resolveOpenClawSessionsDirectory(ctx, currentIdentity.agentId, params.resolveStateDir);
-  if (!sessionsDir) {
-    params.logger?.info?.(`[agenr] predecessor: no predecessor found for ${sessionContext} reason=no_sessions_dir`);
-    return void 0;
-  }
-  const resumedFrom = tracker.getResumedFrom(ctx.sessionId);
-  if (resumedFrom) {
-    debugLog3(params.logger, "predecessor", `session_start resumedFrom for ${sessionContext}: ${resumedFrom}`);
-    const resumedFromPredecessor = await resolveResumedFromPredecessor(sessionsDir, resumedFrom, params.logger);
-    if (resumedFromPredecessor) {
-      params.logger?.info?.(
-        `[agenr] predecessor: predecessor found for ${sessionContext} strategy=resumed_from predecessorKey=session_start predecessor=${resumedFromPredecessor.sessionFile}`
-      );
-      return resumedFromPredecessor;
-    }
-    debugLog3(
-      params.logger,
-      "predecessor",
-      `session_start resumedFrom file not found for ${sessionContext}: resumedFrom=${resumedFrom} sessionsDir=${sessionsDir}`
-    );
-  } else {
-    debugLog3(params.logger, "predecessor", `session_start resumedFrom unavailable for ${sessionContext}`);
-  }
-  if (!isSessionsStoreFallbackEligible(currentIdentity.kind)) {
-    if (resumedFrom) {
-      params.logger?.info?.(`[agenr] predecessor: no predecessor found for ${sessionContext} strategy=resumed_from reason=cold_start_after_resumed_from_miss`);
-    }
-    return void 0;
-  }
-  params.logger?.info?.(
-    `[agenr] predecessor: predecessor resolution for ${sessionContext} strategy=sessions_json_scan sessionKey=${ctx.sessionKey?.trim() ?? "unknown"} kind=${currentIdentity.kind} stableLane=${currentIdentity.stableLane ?? "unknown"}`
-  );
-  const fallbackResolution = await findSessionsStoreFallbackPredecessor(
-    currentIdentity,
-    ctx.sessionKey ?? "",
-    ctx.sessionId,
-    sessionsDir,
-    resumedFrom,
-    params.mainKey,
-    params.logger
-  );
-  if (!fallbackResolution.predecessor) {
-    params.logger?.info?.(`[agenr] predecessor: no predecessor found for ${sessionContext} strategy=sessions_json_scan reason=${fallbackResolution.reason}`);
-    return void 0;
-  }
-  params.logger?.info?.(
-    `[agenr] predecessor: predecessor found for ${sessionContext} strategy=sessions_json_scan predecessorKey=${fallbackResolution.predecessor.sessionKey} predecessor=${fallbackResolution.predecessor.sessionFile}`
-  );
-  return {
-    sessionId: fallbackResolution.predecessor.sessionId,
-    sessionFile: fallbackResolution.predecessor.sessionFile
-  };
-}
-async function resolveResumedFromPredecessor(sessionsDir, resumedFrom, logger) {
-  const normalizedResumedFrom = resumedFrom.trim();
-  if (!normalizedResumedFrom) {
-    return void 0;
-  }
-  const candidates = await findResumedFromTranscriptCandidates(sessionsDir, normalizedResumedFrom, logger);
-  const winner = candidates[0];
-  if (!winner) {
-    return void 0;
-  }
-  const sessionId = resolvePredecessorSessionId(normalizedResumedFrom, winner, logger);
-  if (!sessionId) {
-    return void 0;
-  }
-  return {
-    sessionId,
-    sessionFile: winner
-  };
-}
-async function findResumedFromTranscriptCandidates(sessionsDir, sessionId, logger) {
-  try {
-    const dirEntries = await fs4.readdir(sessionsDir, { withFileTypes: true });
-    const prefix = `${sessionId}.jsonl`;
-    const liveMatches = [];
-    const resetMatches = [];
-    const deletedMatches = [];
-    for (const entry of dirEntries) {
-      if (!entry.isFile()) {
-        continue;
-      }
-      const fileName = entry.name.trim();
-      if (fileName === prefix) {
-        liveMatches.push(path4.join(sessionsDir, fileName));
-        continue;
-      }
-      if (fileName.startsWith(`${prefix}.reset.`)) {
-        resetMatches.push(path4.join(sessionsDir, fileName));
-        continue;
-      }
-      if (fileName.startsWith(`${prefix}.deleted.`)) {
-        deletedMatches.push(path4.join(sessionsDir, fileName));
-      }
-    }
-    const ordered = [
-      ...liveMatches.sort((left, right) => left.localeCompare(right)),
-      ...resetMatches.sort(compareArchivePathsDescending),
-      ...deletedMatches.sort(compareArchivePathsDescending)
-    ];
-    debugLog3(logger, "predecessor", `resumedFrom file discovery for sessionId=${sessionId}: candidates=${ordered.length} sessionsDir=${sessionsDir}`);
-    return ordered;
-  } catch (error) {
-    if (isFileNotFound2(error)) {
-      debugLog3(logger, "predecessor", `resumedFrom file discovery skipped missing directory=${sessionsDir}`);
-      return [];
-    }
-    throw error;
-  }
-}
-async function findSessionsStoreFallbackPredecessor(currentIdentity, currentSessionKey, currentSessionId, sessionsDir, resumedFrom, mainKey, logger) {
-  if (!isSessionsStoreFallbackEligible(currentIdentity.kind)) {
-    return {
-      reason: "not_scan_eligible"
-    };
-  }
-  const entries = await readOpenClawSessionsStore(sessionsDir, logger);
-  debugLog3(
-    logger,
-    "predecessor",
-    `sessions.json read result for kind=${currentIdentity.kind} stableLane=${currentIdentity.stableLane ?? "unknown"} entries=${entries.length}`
-  );
-  const sameAgentEntries = entries.filter((entry) => {
-    const candidateIdentity = parseOpenClawSessionContinuityKey(entry.sessionKey, { mainKey });
-    if (candidateIdentity.agentId !== currentIdentity.agentId) {
-      debugLog3(
-        logger,
-        "predecessor",
-        `excluded candidate=${entry.sessionKey} reason=agent_mismatch expected=${currentIdentity.agentId} actual=${candidateIdentity.agentId ?? "unknown"}`
-      );
-      return false;
-    }
-    return true;
-  });
-  debugLog3(logger, "predecessor", `same-agent candidate count for current=${currentSessionKey}: count=${sameAgentEntries.length}`);
-  const matchedEntries = sameAgentEntries.filter(
-    (entry) => isMatchingFallbackCandidate(entry, currentIdentity, currentSessionKey, currentSessionId, mainKey, logger)
-  );
-  debugLog3(logger, "predecessor", `lane-matched candidate count for current=${currentSessionKey}: count=${matchedEntries.length}`);
-  if (matchedEntries.length === 0) {
-    return {
-      reason: "no_matching_sessions"
-    };
-  }
-  if (resumedFrom?.trim()) {
-    const resumedFromMatch = matchedEntries.find((entry) => resolveEntrySessionId(entry, logger) === resumedFrom.trim());
-    if (resumedFromMatch) {
-      const resolvedPredecessor = toResolvedCandidatePredecessor(resumedFromMatch, logger);
-      if (resolvedPredecessor) {
-        return {
-          reason: "resolved",
-          predecessor: resolvedPredecessor
-        };
-      }
-    }
-  }
-  const sortedCandidates = matchedEntries.filter((entry) => {
-    if (!entry.sessionFile?.trim()) {
-      debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=missing_session_file`);
-      return false;
-    }
-    if (entry.updatedAt === void 0) {
-      debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=missing_updated_at`);
-      return false;
-    }
-    return true;
-  }).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0));
-  if (sortedCandidates.length === 0) {
-    return {
-      reason: "no_matching_sessions"
-    };
-  }
-  for (const candidate of sortedCandidates) {
-    const resolvedPredecessor = toResolvedCandidatePredecessor(candidate, logger);
-    if (resolvedPredecessor) {
-      return {
-        reason: "resolved",
-        predecessor: resolvedPredecessor
-      };
-    }
-  }
-  return {
-    reason: "missing_session_id"
-  };
-}
-function isSessionsStoreFallbackEligible(kind) {
-  return kind === "main" || kind === "tui";
-}
-function isMatchingFallbackCandidate(entry, currentIdentity, currentSessionKey, currentSessionId, mainKey, logger) {
-  const normalizedCandidateKey = entry.sessionKey.trim();
-  const candidateSessionId = resolveEntrySessionId(entry, logger);
-  if (candidateSessionId && currentSessionId?.trim() === candidateSessionId) {
-    debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=current_session_id`);
-    return false;
-  }
-  if (normalizedCandidateKey === currentSessionKey.trim() && currentIdentity.kind !== "main") {
-    debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=current_session_key`);
-    return false;
-  }
-  if (normalizedCandidateKey === currentSessionKey.trim() && !candidateSessionId) {
-    debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=current_session_key_without_session_id`);
-    return false;
-  }
-  const candidateIdentity = parseOpenClawSessionContinuityKey(entry.sessionKey, { mainKey });
-  if (currentIdentity.kind === "main") {
-    if (candidateIdentity.kind !== "main" || candidateIdentity.stableLane !== currentIdentity.stableLane) {
-      debugLog3(
-        logger,
-        "predecessor",
-        `excluded candidate=${entry.sessionKey} reason=main_lane_mismatch currentStableLane=${currentIdentity.stableLane ?? "unknown"} candidateKind=${candidateIdentity.kind} candidateStableLane=${candidateIdentity.stableLane ?? "unknown"}`
-      );
-      return false;
-    }
-    return true;
-  }
-  if (currentIdentity.kind !== "tui") {
-    return false;
-  }
-  if (currentIdentity.stableLane === "tui" && candidateIdentity.kind === "main") {
-    return true;
-  }
-  if (candidateIdentity.kind !== "tui") {
-    debugLog3(logger, "predecessor", `excluded candidate=${entry.sessionKey} reason=not_tui_candidate kind=${candidateIdentity.kind}`);
-    return false;
-  }
-  if (!isSameTuiLane(currentIdentity.stableLane, candidateIdentity.stableLane)) {
-    debugLog3(
-      logger,
-      "predecessor",
-      `excluded candidate=${entry.sessionKey} reason=lane_mismatch currentStableLane=${currentIdentity.stableLane ?? "unknown"} candidateStableLane=${candidateIdentity.stableLane ?? "unknown"}`
-    );
-    return false;
-  }
-  return true;
-}
-function resolvePredecessorSessionId(sessionId, sessionFile, logger) {
-  const normalizedSessionId = sessionId?.trim();
-  if (normalizedSessionId) {
-    return normalizedSessionId;
-  }
-  if (!sessionFile?.trim()) {
-    return void 0;
-  }
-  return deriveOpenClawSessionIdFromFilePath(sessionFile, logger);
-}
-function resolveEntrySessionId(entry, logger) {
-  return resolvePredecessorSessionId(entry.sessionId, entry.sessionFile, logger);
-}
-function toResolvedCandidatePredecessor(candidate, logger) {
-  const sessionFile = candidate.sessionFile?.trim();
-  if (!sessionFile) {
-    return void 0;
-  }
-  const sessionId = resolvePredecessorSessionId(candidate.sessionId, sessionFile, logger);
-  if (!sessionId) {
-    return void 0;
-  }
-  return {
-    sessionFile,
-    sessionId,
-    sessionKey: candidate.sessionKey
-  };
-}
-function resolveOpenClawSessionsDirectory(ctx, parsedAgentId, resolveStateDir) {
-  const agentId = ctx.agentId?.trim() || parsedAgentId.trim();
-  if (!agentId) {
-    return void 0;
-  }
-  return path4.join(resolveStateDir(process.env), "agents", agentId, "sessions");
-}
-function isSameTuiLane(currentStableLane, candidateStableLane) {
-  if (!currentStableLane || !candidateStableLane) {
-    return false;
-  }
-  if (currentStableLane === "tui") {
-    return candidateStableLane.toLowerCase().startsWith("tui");
-  }
-  return currentStableLane === candidateStableLane;
-}
-function compareArchivePathsDescending(left, right) {
-  return path4.basename(right).localeCompare(path4.basename(left));
-}
-function debugLog3(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-function isFileNotFound2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-function formatSessionContext2(sessionId, sessionKey) {
-  const normalizedSessionId = sessionId?.trim();
-  const normalizedSessionKey = sessionKey?.trim();
-  if (normalizedSessionId && normalizedSessionKey) {
-    return `session=${normalizedSessionId} key=${normalizedSessionKey}`;
-  }
-  if (normalizedSessionId) {
-    return `session=${normalizedSessionId}`;
-  }
-  if (normalizedSessionKey) {
-    return `key=${normalizedSessionKey}`;
-  }
-  return "session=unknown";
-}
-
-// 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 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)}`);
-    return "";
-  }
-}
-function formatErrorMessage4(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function capRecentSession(value, maxChars) {
-  if (value.length <= maxChars) {
-    return value;
-  }
-  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;
-var READ_TIME_CONTINUITY_SUMMARY_TIMEOUT = /* @__PURE__ */ Symbol("read-time-continuity-summary-timeout");
-async function resolvePredecessorContinuity(ctx, tracker, services, logger) {
-  const sessionContext = formatSessionContext(ctx.sessionId, ctx.sessionKey);
-  const predecessor = await resolveOpenClawSessionPredecessor(ctx, tracker, {
-    logger,
-    mainKey: resolveOpenClawMainKey(services),
-    resolveStateDir: services.openClaw.runtime.state.resolveStateDir
-  });
-  if (!predecessor) {
-    logger.info(`[agenr] session-start predecessor continuity summary not found for ${sessionContext} reason=no_predecessor`);
-    return {
-      continuitySummaryContent: "",
-      recentSessionContent: ""
-    };
-  }
-  return {
-    predecessor,
-    continuitySummaryContent: await loadPredecessorContinuitySummaryContent(sessionContext, predecessor.sessionFile, ctx.agentId, services, logger),
-    recentSessionContent: await renderRecentSessionSection(predecessor.sessionFile, logger)
-  };
-}
-function resolveOpenClawMainKey(services) {
-  const configWithSession = services.openClaw.config;
-  return configWithSession.session?.mainKey?.trim() || "main";
-}
-async function loadPredecessorContinuitySummaryContent(sessionContext, sessionFile, agentId, services, logger) {
-  try {
-    const existingContinuitySummary = await readOpenClawContinuitySummaryFile(sessionFile, logger);
-    if (existingContinuitySummary) {
-      logger.info(
-        `[agenr] session-start read-time continuity summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=already_exists path=${existingContinuitySummary.continuitySummaryPath}`
-      );
-      logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${existingContinuitySummary.continuitySummaryPath}`);
-      return existingContinuitySummary.content;
-    }
-    logger.info(`[agenr] session-start predecessor continuity summary not found for ${sessionContext} predecessor=${sessionFile}`);
-  } catch (error) {
-    logger.info(
-      `[agenr] session-start predecessor continuity summary not found for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage2(error)}`
-    );
-    logger.debug?.(`[agenr] before_prompt_build: failed reading predecessor continuity summary for ${sessionContext}: ${formatErrorMessage2(error)}`);
-    return "";
-  }
-  logger.info(
-    `[agenr] session-start read-time continuity summary generation triggered for ${sessionContext} predecessor=${sessionFile} reason=no_existing_continuity_summary`
-  );
-  const startedAt = Date.now();
-  try {
-    const result = await awaitWithTimeout(
-      generateAndWriteOpenClawContinuitySummary({
-        sessionFile,
-        agentId,
-        openClaw: services.openClaw,
-        logger,
-        pluginConfig: services.pluginConfig
-      }),
-      READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS
-    );
-    const elapsedMs = Date.now() - startedAt;
-    if (result === READ_TIME_CONTINUITY_SUMMARY_TIMEOUT) {
-      logger.info(
-        `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=timeout elapsedMs=${elapsedMs}`
-      );
-      logger.debug?.(
-        `[agenr] before_prompt_build: read-time continuity summary generation timed out for ${sessionContext}: predecessor=${sessionFile} timeoutMs=${READ_TIME_CONTINUITY_SUMMARY_TIMEOUT_MS}`
-      );
-      return "";
-    }
-    return handleReadTimeContinuitySummaryResult(sessionContext, sessionFile, result, elapsedMs, logger);
-  } catch (error) {
-    const elapsedMs = Date.now() - startedAt;
-    logger.info(
-      `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${formatErrorMessage2(error)} elapsedMs=${elapsedMs}`
-    );
-    logger.debug?.(
-      `[agenr] before_prompt_build: unexpected read-time continuity summary generation failure for ${sessionContext}: ${formatErrorMessage2(error)}`
-    );
-    return "";
-  }
-}
-function handleReadTimeContinuitySummaryResult(sessionContext, sessionFile, result, elapsedMs, logger) {
-  if (result.status === "written" && result.content && result.continuitySummaryPath) {
-    logger.info(
-      `[agenr] session-start read-time continuity summary generation completed for ${sessionContext} predecessor=${sessionFile} elapsedMs=${elapsedMs} path=${result.continuitySummaryPath}`
-    );
-    logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${result.continuitySummaryPath}`);
-    return result.content;
-  }
-  if (result.status === "skipped") {
-    logger.info(
-      `[agenr] session-start read-time continuity summary generation skipped for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} path=${result.continuitySummaryPath ?? "n/a"}`
-    );
-    logger.debug?.(
-      `[agenr] before_prompt_build: read-time continuity summary generation skipped for ${sessionContext}: predecessor=${sessionFile} transcriptChars=${result.transcriptChars ?? 0} cleanedMessages=${result.messageCount ?? 0}`
-    );
-    if (result.reason === "already_exists" && result.content && result.continuitySummaryPath) {
-      logger.info(`[agenr] session-start predecessor continuity summary found for ${sessionContext} path=${result.continuitySummaryPath}`);
-      return result.content;
-    }
-    return "";
-  }
-  logger.info(
-    `[agenr] session-start read-time continuity summary generation failed for ${sessionContext} predecessor=${sessionFile} reason=${result.reason ?? "unknown"} elapsedMs=${elapsedMs} model=${result.model ?? "unknown"}`
-  );
-  logger.debug?.(
-    `[agenr] before_prompt_build: read-time continuity summary generation failed for ${sessionContext}: predecessor=${sessionFile} durationMs=${result.durationMs ?? 0} transcriptChars=${result.transcriptChars ?? 0}`
-  );
-  return "";
-}
-async function awaitWithTimeout(promise, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      resolve(READ_TIME_CONTINUITY_SUMMARY_TIMEOUT);
-    }, timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timeout);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      }
-    );
-  });
-}
-
-// src/adapters/openclaw/hooks/before-prompt-build.ts
-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);
-  if (!trackerState.isFirst) {
-    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 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 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}`);
-      return void 0;
-    }
-    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;
-  }
-}
-function resolveStoreNudgeResult(_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: store nudge skipped for ${sessionContext} reason=non_user_trigger trigger=${normalizedTrigger}`);
-    return void 0;
-  }
-  const storeNudgeConfig = params.storeNudgeConfig ?? DEFAULT_STORE_NUDGE_CONFIG;
-  if (!storeNudgeConfig.enabled) {
-    params.logger.debug?.(`[agenr] before_prompt_build: store nudge skipped for ${sessionContext} reason=disabled`);
-    return void 0;
-  }
-  const midSessionTracker = params.midSessionTracker ?? createMidSessionTracker();
-  const state = midSessionTracker.recordTurn(ctx.sessionId, ctx.sessionKey);
-  if (!state) {
-    params.logger.debug?.(`[agenr] before_prompt_build: store nudge skipped for ${sessionContext} reason=no_session_identity`);
-    return void 0;
-  }
-  const gapSinceSuccessfulStore = state.turnCount - state.lastSuccessfulStoreTurn;
-  const gapSinceMemoryAction = state.turnCount - state.lastMemoryActionTurn;
-  params.logger.debug?.(
-    `[agenr] before_prompt_build: store nudge check for ${sessionContext} gapSinceSuccessfulStore=${gapSinceSuccessfulStore} gapSinceMemoryAction=${gapSinceMemoryAction} nudgeCount=${state.nudgeCount} maxPerSession=${storeNudgeConfig.maxPerSession}`
-  );
-  if (gapSinceSuccessfulStore < storeNudgeConfig.threshold || gapSinceMemoryAction < storeNudgeConfig.threshold) {
-    params.logger.debug?.(`[agenr] before_prompt_build: store nudge skipped for ${sessionContext} reason=cooldown`);
-    return void 0;
-  }
-  if (state.nudgeCount >= storeNudgeConfig.maxPerSession) {
-    params.logger.debug?.(`[agenr] before_prompt_build: store nudge skipped for ${sessionContext} reason=max_reached`);
-    return void 0;
-  }
-  state.nudgeCount += 1;
-  state.lastSuccessfulStoreTurn = state.turnCount;
-  const prependContext = buildStoreNudgeMessage(state, storeNudgeConfig.maxPerSession);
-  params.logger.info(`[agenr] store nudge injected for ${sessionContext} ordinal=${state.nudgeCount} turn=${state.turnCount} gap=${gapSinceSuccessfulStore}`);
-  return { prependContext };
-}
-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) {
-  logger.debug?.("[agenr] flush-plan: pass-through (no custom flush)");
-  return null;
-}
-
-// src/adapters/openclaw/memory/runtime.ts
-function createAgenrMemoryRuntime(servicesPromise) {
-  return {
-    async getMemorySearchManager() {
-      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.config.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;
-            },
-            async sync() {
-              return;
-            }
-          }
-        };
-      } catch (error) {
-        return {
-          manager: null,
-          error: `[agenr] memory runtime unavailable: ${formatErrorMessage2(error)}`
-        };
-      }
-    },
-    resolveMemoryBackendConfig() {
-      return { backend: "builtin" };
-    },
-    async closeAllMemorySearchManagers() {
-      try {
-        const services = await servicesPromise;
-        await services.close();
-      } catch {
-      }
-    }
-  };
-}
-
-// src/app/openclaw/runtime.ts
-import path6 from "path";
-async function createAgenrOpenClawServices(config, options) {
-  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
-    })
-  });
-}
-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 };
-  }
-}
-
-// src/adapters/openclaw/index.ts
-var openclaw_default = definePluginEntry({
-  id: "agenr",
-  name: "agenr",
-  description: "agenr memory plugin for OpenClaw",
-  kind: "memory",
-  configSchema: createAgenrOpenClawPluginConfigSchema(),
-  register(api) {
-    const sessionStartTracker = createSessionStartTracker();
-    const midSessionTracker = createMidSessionTracker();
-    const pluginConfig = coerceAgenrOpenClawPluginConfig(api.pluginConfig);
-    const storeNudgeConfig = resolveStoreNudgeConfig(pluginConfig.storeNudge);
-    const servicesPromise = createAgenrOpenClawServices(pluginConfig, {
-      openClaw: {
-        config: api.config,
-        runtime: {
-          agent: api.runtime.agent,
-          state: api.runtime.state,
-          modelAuth: api.runtime.modelAuth
-        }
-      },
-      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),
-      runtime: createAgenrMemoryRuntime(servicesPromise)
-    });
-    registerAgenrOpenClawTools(api, servicesPromise, api.logger);
-    api.on(
-      "before_prompt_build",
-      (event, ctx) => handleAgenrBeforePromptBuild(event, ctx, {
-        logger: api.logger,
-        servicesPromise,
-        tracker: sessionStartTracker,
-        midSessionTracker,
-        storeNudgeConfig
-      })
-    );
-    api.on("session_start", (event) => {
-      sessionStartTracker.rememberSessionStart(event.sessionId, event.sessionKey, event.resumedFrom);
-    });
-    api.on("after_tool_call", (event, ctx) => {
-      handleAgenrAfterToolCall(event, ctx, {
-        logger: api.logger,
-        midSessionTracker
-      });
-    });
-    api.on("session_end", (event) => {
-      midSessionTracker.clear(event.sessionId, event.sessionKey);
-    });
-    api.on("gateway_stop", async () => {
-      try {
-        const services = await servicesPromise;
-        await services.close();
-      } catch {
-      }
-    });
-  }
-});
-export {
-  OpenClawTranscriptParser,
-  openclaw_default as default,
-  openClawTranscriptParser
-};