@agenr/openclaw-plugin 2026.6.2 → 2026.6.3

package/dist/{chunk-Q5UTJXHZ.js → chunk-IBPS64W3.js}

@@ -1,6 +1,6 @@
 import {
   formatTargetSelectorFromParams
-} from "./chunk-LDJN7CVU.js";
+} from "./chunk-U74RE3L7.js";
 
 // src/adapters/openclaw/transcript/parser.ts
 import { createHash } from "crypto";

package/dist/{chunk-NBS62ES5.js → chunk-SIY3JA7T.js}

@@ -28,7 +28,7 @@ import {
   parseExpiry,
   parseRecallMode,
   storeDurablesDetailed
-} from "./chunk-LDJN7CVU.js";
+} from "./chunk-U74RE3L7.js";
 import {
   containsAgenrMemoryContext,
   createSessionStartRepository,
@@ -768,6 +768,17 @@ function buildSessionEndSourceRef(source) {
   return `${SESSION_END_SOURCE_REF_PREFIX}${source.trim()}`;
 }
 
+// src/adapters/shared/light-dream-trigger-deps.ts
+function buildLightDreamTriggerDeps(services) {
+  return {
+    port: services.dreaming,
+    dbPath: services.config.dbPath,
+    config: services.agenrConfig,
+    embedding: services.embedding,
+    ...services.claimExtraction ? { createClaimExtractionLlm: () => services.claimExtraction.llm } : {}
+  };
+}
+
 // src/app/dreaming/background-triggers.ts
 var MINUTE_MS = 60 * 1e3;
 async function maybeRunLightDream(input, deps) {
@@ -852,6 +863,36 @@ function hasEvidence(scan) {
   return scan.episodesSinceLastRun > 0 || scan.ingestFilesSinceLastRun > 0 || scan.durablesCreatedSinceLastRun > 0;
 }
 
+// src/adapters/shared/post-session-light-dream.ts
+async function runPostSessionLightDream(params) {
+  const contextSuffix = params.sessionContext ? ` for ${params.sessionContext}` : "";
+  try {
+    const result = await maybeRunLightDream({ trigger: "post_session" }, params.deps);
+    if (result.status === "ran") {
+      params.logger.info(`[agenr] ${params.scope} light dream completed${contextSuffix} run=${result.result.runId}`);
+      return;
+    }
+    if (result.reason === "run_in_progress" || result.reason === "episode_write_in_progress") {
+      params.logger.info(`[agenr] ${params.scope} light dream skipped${contextSuffix} reason=${result.reason}`);
+      return;
+    }
+    params.logger.debug?.(`[agenr] ${params.scope} light dream skipped${contextSuffix} reason=${result.reason}`);
+  } catch (error) {
+    params.logger.warn(`[agenr] ${params.scope} light dream failed${contextSuffix}: ${formatErrorMessage(error)}`);
+  }
+}
+
+// src/adapters/shared/guarded-post-session-episode-capture.ts
+async function runGuardedPostSessionEpisodeCapture(params) {
+  await withEpisodeWriteGuard({ port: params.services.dreaming, dbPath: params.services.config.dbPath }, params.writeEpisode);
+  await runPostSessionLightDream({
+    deps: buildLightDreamTriggerDeps(params.services),
+    logger: params.logger,
+    scope: params.scope,
+    sessionContext: params.sessionContext
+  });
+}
+
 // src/adapters/plugin-runtime/claim-extraction.ts
 async function buildClaimExtractionRuntime(config, resolveLlm) {
   const claimExtractionConfig = resolveClaimExtractionConfig(config);
@@ -2042,6 +2083,12 @@ async function createHostMemoryServices(featureFlags, options = {}) {
   };
 }
 
+// src/adapters/shared/shutdown-episode-threshold.ts
+var HOST_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD = {
+  minMaterialTurns: 8,
+  minDurationMs: 20 * 60 * 1e3
+};
+
 // src/adapters/shared/bounded-episode-embedding.ts
 var EPISODE_EMBEDDING_RACE_TIMEOUT = /* @__PURE__ */ Symbol("episode-embedding-race-timeout");
 var EPISODE_EMBEDDING_MIN_HEADROOM_MS = 5e3;
@@ -2982,6 +3029,7 @@ export {
   isPluginEpisodeWriteEnabled,
   resolveAgenrFeatureFlags,
   resolveCompactionPromptContext,
+  HOST_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD,
   embedEpisodeSummaryWithinBudget,
   EPISODE_SUMMARY_TIMEOUT_MS,
   writeBoundedSingleTranscriptEpisode,
@@ -2989,7 +3037,9 @@ export {
   buildSessionFileSourceRef,
   buildCompactionSourceRef,
   buildSessionEndSourceRef,
+  buildLightDreamTriggerDeps,
   maybeRunLightDream,
+  runGuardedPostSessionEpisodeCapture,
   buildClaimExtractionRuntime,
   createClaimExtractionFromAgenrConfig,
   createEmbedQuery,

package/dist/{chunk-LDJN7CVU.js → chunk-U74RE3L7.js}

@@ -343,64 +343,6 @@ function sanitizeFetchToolParams(params) {
   };
 }
 
-// src/app/episode-ingest/activity-threshold.ts
-function resolveEpisodeActivityEligibility(materialTurns, startedAt, endedAt, threshold) {
-  const durationMs = resolveTranscriptDurationMs(startedAt, endedAt);
-  if (materialTurns >= threshold.minMaterialTurns || durationMs >= threshold.minDurationMs) {
-    return {
-      eligible: true,
-      materialTurns,
-      durationMs
-    };
-  }
-  return {
-    eligible: false,
-    reason: "below_activity_threshold",
-    materialTurns,
-    durationMs
-  };
-}
-function resolveTranscriptDurationMs(startedAt, endedAt) {
-  if (!startedAt || !endedAt) {
-    return 0;
-  }
-  const started = Date.parse(startedAt);
-  const ended = Date.parse(endedAt);
-  return Number.isFinite(started) && Number.isFinite(ended) && ended > started ? ended - started : 0;
-}
-
-// src/core/episode/transcript-render.ts
-var MIN_EPISODE_MESSAGES = 4;
-var MAX_EPISODE_TRANSCRIPT_CHARS = 14e3;
-function countMaterialTranscriptTurns(messages) {
-  return messages.filter((message) => message.text.trim().length > 0).length;
-}
-function renderTranscript(messages) {
-  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
-}
-function capEpisodeTranscript(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/u);
-    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/app/episode-ingest/single-transcript.ts
 function createSingleTranscriptDiscoveryPort(filePath) {
   return {
@@ -693,6 +635,66 @@ async function generateEpisodeSummary(transcript, llm) {
 
 // src/app/episode-ingest/service/preflight.ts
 import path from "path";
+
+// src/app/episode-ingest/activity-threshold.ts
+function resolveEpisodeActivityEligibility(materialTurns, startedAt, endedAt, threshold) {
+  const durationMs = resolveTranscriptDurationMs(startedAt, endedAt);
+  if (materialTurns >= threshold.minMaterialTurns || durationMs >= threshold.minDurationMs) {
+    return {
+      eligible: true,
+      materialTurns,
+      durationMs
+    };
+  }
+  return {
+    eligible: false,
+    reason: "below_activity_threshold",
+    materialTurns,
+    durationMs
+  };
+}
+function resolveTranscriptDurationMs(startedAt, endedAt) {
+  if (!startedAt || !endedAt) {
+    return 0;
+  }
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+  return Number.isFinite(started) && Number.isFinite(ended) && ended > started ? ended - started : 0;
+}
+
+// src/core/episode/transcript-render.ts
+var MIN_EPISODE_MESSAGES = 4;
+var MAX_EPISODE_TRANSCRIPT_CHARS = 14e3;
+function countMaterialTranscriptTurns(messages) {
+  return messages.filter((message) => message.text.trim().length > 0).length;
+}
+function renderTranscript(messages) {
+  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
+}
+function capEpisodeTranscript(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/u);
+    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/app/episode-ingest/service/preflight.ts
 var ACTIVE_SESSION_WINDOW_MS = 5 * 60 * 1e3;
 async function prepareEpisodeIngest(targetPath, ports, options = {}) {
   const files = await ports.files.discoverFiles(targetPath);

package/dist/index.js

@@ -6,15 +6,17 @@ import {
   openClawTranscriptParser,
   parseJsonObjectLineWithDiagnostics,
   parseTuiSessionKey
-} from "./chunk-Q5UTJXHZ.js";
+} from "./chunk-IBPS64W3.js";
 import {
   EPISODE_SUMMARY_TIMEOUT_MS,
   FETCH_TOOL_PARAMETERS,
+  HOST_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD,
   RECALL_TOOL_PARAMETERS,
   STORE_TOOL_PARAMETERS,
   UPDATE_TOOL_PARAMETERS,
   buildClaimExtractionRuntime,
   buildCompactionSourceRef,
+  buildLightDreamTriggerDeps,
   buildRecallToolServices,
   buildSessionEndSourceRef,
   buildSessionFileSourceRef,
@@ -48,12 +50,13 @@ import {
   resolveSessionStartPolicy,
   routeSessionMemoryTriggerSafely,
   runFetchMemoryTool,
+  runGuardedPostSessionEpisodeCapture,
   runRecallMemoryTool,
   runStoreMemoryTool,
   runUpdateMemoryTool,
   scheduleGuardedEpisodeWrite,
   writeBoundedSingleTranscriptEpisode
-} from "./chunk-NBS62ES5.js";
+} from "./chunk-SIY3JA7T.js";
 import "./chunk-OJSIZDZD.js";
 import "./chunk-NSLTJBUC.js";
 import {
@@ -68,7 +71,7 @@ import {
   formatTargetSelector,
   sanitizeFetchToolParams,
   sanitizeUpdateToolParams
-} from "./chunk-LDJN7CVU.js";
+} from "./chunk-U74RE3L7.js";
 import {
   formatAgenrBeforeTurnRecall,
   runBeforeTurn,
@@ -84,9 +87,7 @@ import {
   sanitizeStoreToolParams
 } from "./chunk-5TIP2EPP.js";
 import "./chunk-GAERET5Q.js";
-import {
-  withEpisodeWriteGuard
-} from "./chunk-SOQW7356.js";
+import "./chunk-SOQW7356.js";
 import "./chunk-VTHBPXDQ.js";
 import "./chunk-VBPYU7GO.js";
 
@@ -294,7 +295,7 @@ function createAgenrStoreTool(ctx, servicesPromise, logger) {
           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}`)
+          onWarning: (warning) => logger.info(`[agenr] tool=agenr_store session=${ctx.sessionId ?? "unknown"} note: ${warning}`)
         });
         triggerOpenClawImportanceLightDream(services, logger, outcome.details.status);
         return toOpenClawToolResult(outcome);
@@ -309,16 +310,7 @@ function triggerOpenClawImportanceLightDream(services, logger, status) {
   if (status !== "stored") {
     return;
   }
-  void maybeRunLightDream(
-    { trigger: "importance" },
-    {
-      port: services.dreaming,
-      dbPath: services.config.dbPath,
-      config: services.agenrConfig,
-      embedding: services.embedding,
-      ...services.claimExtraction ? { createClaimExtractionLlm: () => services.claimExtraction.llm } : {}
-    }
-  ).then((result) => {
+  void maybeRunLightDream({ trigger: "importance" }, buildLightDreamTriggerDeps(services)).then((result) => {
     if (result.status === "ran") {
       logger.info(`[agenr] importance light dream completed run=${result.result.runId}`);
     } else if (result.reason === "run_in_progress" || result.reason === "episode_write_in_progress") {
@@ -385,7 +377,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "2026.6.2",
+  version: "2026.6.3",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {
@@ -1133,17 +1125,18 @@ function normalizeOptionalString(value) {
 var OPENCLAW_EPISODE_GENERATOR_VERSION = "openclaw-episodic-summary-v1";
 
 // src/adapters/openclaw/episode/episode-writer.ts
-async function writeOpenClawCurrentSessionEpisode(params) {
+async function writeOpenClawSessionEndEpisode(params) {
   await writeOpenClawSessionEpisode({
     ctx: params.ctx,
-    target: params.current,
+    target: params.target,
     services: params.services,
     logger: params.logger,
     actionLabel: "session-end episode write",
-    sourceSessionId: params.current.sessionId,
+    sourceSessionId: params.target.sessionId,
     fileField: "file",
     shortCountField: "materialTurns",
-    embeddingSkipLogContext: `[agenr] session-end episode embedding skipped for ${formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey)} file=${params.current.sessionFile}`
+    activityGate: "host-shutdown",
+    embeddingSkipLogContext: `[agenr] session-end episode embedding skipped for ${formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey)} file=${params.target.sessionFile}`
   });
 }
 async function writeOpenClawPreCompactionEpisode(params) {
@@ -1159,6 +1152,7 @@ async function writeOpenClawPreCompactionEpisode(params) {
     sourceSessionId: `${params.sessionId}:pre-compaction:${params.messageCount}`,
     fileField: "file",
     shortCountField: "materialTurns",
+    activityGate: "none",
     embeddingSkipLogContext: `[agenr] pre-compaction episode embedding skipped for ${formatSessionContext(params.ctx.sessionId, params.ctx.sessionKey)} file=${params.sessionFile}`
   });
 }
@@ -1223,6 +1217,7 @@ async function writeOpenClawSessionEpisode(params) {
     ingestOptions: {
       genVersion: OPENCLAW_EPISODE_GENERATOR_VERSION,
       skipActiveSessionCheck: true,
+      ...params.activityGate === "host-shutdown" ? { activityThreshold: HOST_SHUTDOWN_EPISODE_ACTIVITY_THRESHOLD } : {},
       candidateOverrides: {
         sessionId: params.sourceSessionId,
         agentId: trimOptionalString(params.ctx.agentId) ?? null,
@@ -1415,9 +1410,6 @@ function buildOpenClawSessionShutdownTriggerEvent(scope, event) {
 function shouldRouteOpenClawSessionTreeTrigger(reason) {
   return reason !== void 0 && TREE_SESSION_END_REASONS.has(reason);
 }
-function shouldSkipOpenClawSessionEndMemoryTrigger(reason) {
-  return reason === "compaction";
-}
 function buildOpenClawCompactionCheckpointArtifact(sessionKey, event, compactionEntry) {
   const sourceId = compactionEntry?.id?.trim() || event.sessionFile?.trim() || `${sessionKey}:${event.compactedCount}`;
   const summary = compactionEntry?.summary.trim() || `Compacted ${event.compactedCount} messages; ${event.messageCount} messages remain.`;
@@ -1848,32 +1840,25 @@ function resolveAgentIdFromSessionKey(sessionKey) {
   return match?.[1]?.trim() || void 0;
 }
 
-// src/adapters/openclaw/hooks/session-end.ts
-async function handleAgenrSessionEnd(event, params) {
-  params.midSessionTracker.clear(event.sessionId, event.sessionKey);
-  const sessionContext = formatSessionContext(event.sessionId, event.sessionKey);
-  const scopeContext = {
-    sessionId: event.sessionId,
-    ...event.sessionKey ? { sessionKey: event.sessionKey } : {}
-  };
-  if (!shouldSkipOpenClawSessionEndMemoryTrigger(event.reason)) {
-    if (shouldRouteOpenClawSessionTreeTrigger(event.reason)) {
-      await routeOpenClawSessionMemoryTrigger(params.servicesPromise, scopeContext, (scope) => buildOpenClawSessionTreeTriggerEvent(scope, event));
-    } else {
-      await routeOpenClawSessionMemoryTrigger(params.servicesPromise, scopeContext, (scope) => buildOpenClawSessionShutdownTriggerEvent(scope, event));
-    }
+// src/adapters/openclaw/episode/session-end-episode-write.ts
+function resolveOpenClawSessionEndEpisodeTarget(event) {
+  const sessionId = event.sessionId.trim();
+  const sessionFile = event.sessionFile?.trim();
+  if (!sessionId || !sessionFile) {
+    return void 0;
   }
+  return { sessionId, sessionFile };
+}
+async function runOpenClawSessionEndEpisodeCapture(params) {
+  const sessionContext = formatSessionContext(params.event.sessionId, params.event.sessionKey);
+  const syncTarget = resolveOpenClawSessionEndEpisodeTarget(params.event);
   try {
     const services = await params.servicesPromise;
     if (!isPluginEpisodeWriteEnabled(services.pluginConfig.memoryPolicy)) {
       params.logger.debug?.(`[agenr] session-end episode write skipped for ${sessionContext} reason=memory_policy_disabled`);
       return;
     }
-    const ctx = {
-      sessionId: event.sessionId,
-      ...event.sessionKey ? { sessionKey: event.sessionKey } : {}
-    };
-    const target = await resolveOpenClawCurrentSessionTarget(ctx, {
+    const target = syncTarget ?? await resolveOpenClawCurrentSessionTarget(params.ctx, {
       resolveStateDir: services.openClaw.runtime.state.resolveStateDir,
       logger: params.logger
     });
@@ -1881,37 +1866,60 @@ async function handleAgenrSessionEnd(event, params) {
       params.logger.info(`[agenr] session-end episode write skipped for ${sessionContext} reason=no_current_session`);
       return;
     }
-    await withEpisodeWriteGuard(
-      { port: services.dreaming, dbPath: services.config.dbPath },
-      async () => writeOpenClawCurrentSessionEpisode({ ctx, current: target, services, logger: params.logger })
-    );
-    await runOpenClawPostSessionLightDream(services, params.logger, sessionContext);
+    await runGuardedPostSessionEpisodeCapture({
+      services,
+      writeEpisode: () => writeOpenClawSessionEndEpisode({
+        ctx: params.ctx,
+        target,
+        services,
+        logger: params.logger
+      }),
+      logger: params.logger,
+      scope: "session-end",
+      sessionContext
+    });
   } catch (error) {
-    params.logger.warn(`[agenr] session-end episode write failed for ${sessionContext}: ${formatErrorMessage2(error)}`);
+    params.logger.warn(`[agenr] session-end episode write failed for ${sessionContext}: ${formatErrorMessage(error)}`);
   }
 }
-async function runOpenClawPostSessionLightDream(services, logger, sessionContext) {
-  try {
-    const result = await maybeRunLightDream(
-      { trigger: "post_session" },
-      {
-        port: services.dreaming,
-        dbPath: services.config.dbPath,
-        config: services.agenrConfig,
-        embedding: services.embedding,
-        ...services.claimExtraction ? { createClaimExtractionLlm: () => services.claimExtraction.llm } : {}
-      }
-    );
-    if (result.status === "ran") {
-      logger.info(`[agenr] session-end light dream completed for ${sessionContext} run=${result.result.runId}`);
-    } else if (result.reason === "run_in_progress" || result.reason === "episode_write_in_progress") {
-      logger.info(`[agenr] session-end light dream skipped for ${sessionContext} reason=${result.reason}`);
+
+// src/adapters/openclaw/session-end-policy.ts
+function resolveOpenClawSessionEndPolicy(reason) {
+  const isCompaction = reason === "compaction";
+  return {
+    routeMemoryIntake: !isCompaction,
+    captureEpisode: !isCompaction
+  };
+}
+
+// src/adapters/openclaw/hooks/session-end.ts
+async function handleAgenrSessionEnd(event, params) {
+  params.midSessionTracker.clear(event.sessionId, event.sessionKey);
+  const scopeContext = {
+    sessionId: event.sessionId,
+    ...event.sessionKey ? { sessionKey: event.sessionKey } : {}
+  };
+  const policy = resolveOpenClawSessionEndPolicy(event.reason);
+  if (policy.routeMemoryIntake) {
+    if (shouldRouteOpenClawSessionTreeTrigger(event.reason)) {
+      await routeOpenClawSessionMemoryTrigger(params.servicesPromise, scopeContext, (scope) => buildOpenClawSessionTreeTriggerEvent(scope, event));
     } else {
-      logger.debug?.(`[agenr] session-end light dream skipped for ${sessionContext} reason=${result.reason}`);
+      await routeOpenClawSessionMemoryTrigger(params.servicesPromise, scopeContext, (scope) => buildOpenClawSessionShutdownTriggerEvent(scope, event));
     }
-  } catch (error) {
-    logger.warn(`[agenr] session-end light dream failed for ${sessionContext}: ${formatErrorMessage2(error)}`);
   }
+  if (!policy.captureEpisode) {
+    return;
+  }
+  const ctx = {
+    sessionId: event.sessionId,
+    ...event.sessionKey ? { sessionKey: event.sessionKey } : {}
+  };
+  await runOpenClawSessionEndEpisodeCapture({
+    event,
+    ctx,
+    servicesPromise: params.servicesPromise,
+    logger: params.logger
+  });
 }
 
 // src/adapters/openclaw/memory/flush-plan.ts

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "agenr",
   "name": "agenr",
-  "version": "2026.6.2",
+  "version": "2026.6.3",
   "description": "agenr memory plugin for OpenClaw",
   "kind": "memory",
   "contracts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenr/openclaw-plugin",
-  "version": "2026.6.2",
+  "version": "2026.6.3",
   "description": "agenr memory plugin for OpenClaw",
   "type": "module",
   "exports": {