agenr 0.6.8 → 0.6.10

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.6.10] - 2026-02-19
+
+### Fixed
+- OpenClaw plugin: AGENR.md now writes a compact summary (subjects only + entry count + recall instructions) instead of full content, preventing double-injection of full context if loaded into Project Context
+- Note: version 0.6.9 was published with a stale build and unpublished; 0.6.10 is the correct release of these changes
+
+## [0.6.9] - 2026-02-19
+
+### Fixed
+- OpenClaw plugin: session-seen guard prevents recall firing on every turn (fires once per session)
+- OpenClaw plugin: sessionKey now read from ctx (second handler arg) instead of event
+- OpenClaw plugin: DEFAULT_AGENR_PATH uses correct 2-level relative path to dist/cli.js
+- OpenClaw plugin: spawn strategy detects .js vs executable binary
+
+### Added
+- OpenClaw plugin: writes AGENR.md to ctx.workspaceDir after successful recall (fire-and-forget)
+
 ## [0.6.8] - 2026-02-19
 
 ### Fixed

package/dist/openclaw-plugin/index.d.ts

@@ -1,6 +1,11 @@
 type BeforeAgentStartEvent = {
-    sessionKey?: string;
     prompt?: string;
+    messages?: unknown[];
+    [key: string]: unknown;
+};
+type PluginHookAgentContext = {
+    sessionKey?: string;
+    workspaceDir?: string;
     [key: string]: unknown;
 };
 type BeforeAgentStartResult = {
@@ -18,7 +23,7 @@ type PluginApi = {
     version?: string;
     pluginConfig?: Record<string, unknown>;
     logger: PluginLogger;
-    on: (hook: "before_agent_start", handler: (event: BeforeAgentStartEvent) => Promise<BeforeAgentStartResult | undefined> | BeforeAgentStartResult | undefined) => void;
+    on: (hook: "before_agent_start", handler: (event: BeforeAgentStartEvent, ctx: PluginHookAgentContext) => Promise<BeforeAgentStartResult | undefined> | BeforeAgentStartResult | undefined) => void;
 };
 
 declare const plugin: {

package/dist/openclaw-plugin/index.js

@@ -1,27 +1,30 @@
 // src/openclaw-plugin/recall.ts
 import { spawn } from "child_process";
+import { writeFile } from "fs/promises";
 import path from "path";
 import { fileURLToPath } from "url";
 var RECALL_TIMEOUT_MS = 5e3;
 var DEFAULT_BUDGET = 2e3;
-var DEFAULT_AGENR_PATH = path.resolve(
-  fileURLToPath(import.meta.url),
-  "..",
-  "..",
-  "..",
-  "dist",
-  "cli.js"
-);
+var MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path.resolve(MODULE_DIR, "..", "..");
+var DEFAULT_AGENR_PATH = path.join(PACKAGE_ROOT, "dist", "cli.js");
 function resolveAgenrPath(config) {
   return config?.agenrPath?.trim() || process.env["AGENR_BIN"]?.trim() || DEFAULT_AGENR_PATH;
 }
 function resolveBudget(config) {
   return config?.budget ?? DEFAULT_BUDGET;
 }
+function buildSpawnArgs(agenrPath) {
+  if (agenrPath.endsWith(".js")) {
+    return { cmd: process.execPath, args: [agenrPath] };
+  }
+  return { cmd: agenrPath, args: [] };
+}
 async function runRecall(agenrPath, budget) {
   return await new Promise((resolve) => {
     let stdout = "";
     let settled = false;
+    const spawnArgs = buildSpawnArgs(agenrPath);
     function finish(value) {
       if (settled) {
         return;
@@ -30,8 +33,8 @@ async function runRecall(agenrPath, budget) {
       resolve(value);
     }
     const child = spawn(
-      process.execPath,
-      [agenrPath, "recall", "--context", "session-start", "--budget", String(budget), "--json"],
+      spawnArgs.cmd,
+      [...spawnArgs.args, "recall", "--context", "session-start", "--budget", String(budget), "--json"],
       { stdio: ["ignore", "pipe", "ignore"] }
     );
     const timer = setTimeout(() => {
@@ -61,26 +64,35 @@ function isRecallResult(value) {
 }
 var TODO_TYPES = /* @__PURE__ */ new Set(["todo"]);
 var PREFERENCE_TYPES = /* @__PURE__ */ new Set(["preference", "decision"]);
-function formatRecallAsMarkdown(result) {
+function groupValidEntries(result) {
+  const grouped = {
+    todos: [],
+    preferences: [],
+    facts: []
+  };
   if (!result.results || result.results.length === 0) {
-    return "";
+    return grouped;
   }
-  const todos = [];
-  const preferences = [];
-  const facts = [];
   for (const item of result.results) {
     const entry = item.entry;
     if (!entry || typeof entry.type !== "string" || typeof entry.subject !== "string" || typeof entry.content !== "string") {
       continue;
     }
     if (TODO_TYPES.has(entry.type)) {
-      todos.push(entry);
+      grouped.todos.push(entry);
     } else if (PREFERENCE_TYPES.has(entry.type)) {
-      preferences.push(entry);
+      grouped.preferences.push(entry);
     } else {
-      facts.push(entry);
+      grouped.facts.push(entry);
     }
   }
+  return grouped;
+}
+function formatRecallAsMarkdown(result) {
+  if (!result.results || result.results.length === 0) {
+    return "";
+  }
+  const { todos, preferences, facts } = groupValidEntries(result);
   if (todos.length === 0 && preferences.length === 0 && facts.length === 0) {
     return "";
   }
@@ -108,12 +120,91 @@ function formatRecallAsMarkdown(result) {
   }
   return lines.join("\n").trimEnd();
 }
+function formatRecallAsSummary(result, timestamp) {
+  if (!result.results || result.results.length === 0) {
+    return "";
+  }
+  const { todos, preferences, facts } = groupValidEntries(result);
+  const totalEntries = todos.length + preferences.length + facts.length;
+  if (totalEntries === 0) {
+    return "";
+  }
+  const lines = [timestamp ? `## agenr Memory -- ${timestamp}` : "## agenr Memory", ""];
+  lines.push(
+    `${totalEntries} entries recalled. Full context injected into this session automatically.`,
+    "To pull specific memories: ask your agent, or run:",
+    '  mcporter call agenr.agenr_recall query="your topic" limit=5',
+    ""
+  );
+  if (todos.length > 0) {
+    lines.push(`### Active Todos (${todos.length})`, "");
+    for (const entry of todos) {
+      lines.push(`- ${entry.subject}`);
+    }
+    lines.push("");
+  }
+  if (preferences.length > 0) {
+    lines.push(`### Preferences and Decisions (${preferences.length})`, "");
+    for (const entry of preferences) {
+      lines.push(`- ${entry.subject}`);
+    }
+    lines.push("");
+  }
+  if (facts.length > 0) {
+    lines.push(`### Facts and Events (${facts.length})`, "");
+    for (const entry of facts) {
+      lines.push(`- ${entry.subject}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+async function writeAgenrMd(markdown, workspaceDir) {
+  try {
+    const outputPath = path.join(workspaceDir, "AGENR.md");
+    await writeFile(outputPath, markdown, "utf8");
+  } catch {
+  }
+}
 
 // src/openclaw-plugin/index.ts
 var SKIP_SESSION_PATTERNS = [":subagent:", ":cron:"];
+var DEFAULT_MAX_SEEN_SESSIONS = 1e3;
+var seenSessions = /* @__PURE__ */ new Map();
+function resolveMaxSeenSessions() {
+  const raw = process.env.AGENR_OPENCLAW_MAX_SEEN_SESSIONS;
+  if (!raw) {
+    return DEFAULT_MAX_SEEN_SESSIONS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return DEFAULT_MAX_SEEN_SESSIONS;
+}
+var maxSeenSessions = resolveMaxSeenSessions();
 function shouldSkipSession(sessionKey) {
   return SKIP_SESSION_PATTERNS.some((pattern) => sessionKey.includes(pattern));
 }
+function hasSeenSession(sessionKey) {
+  const seen = seenSessions.has(sessionKey);
+  if (!seen) {
+    return false;
+  }
+  seenSessions.delete(sessionKey);
+  seenSessions.set(sessionKey, true);
+  return true;
+}
+function markSessionSeen(sessionKey) {
+  seenSessions.set(sessionKey, true);
+  while (seenSessions.size > maxSeenSessions) {
+    const oldestKey = seenSessions.keys().next().value;
+    if (!oldestKey) {
+      break;
+    }
+    seenSessions.delete(oldestKey);
+  }
+}
 var plugin = {
   id: "agenr",
   name: "agenr memory context",
@@ -121,16 +212,22 @@ var plugin = {
   register(api) {
     api.on(
       "before_agent_start",
-      async (event) => {
+      async (_event, ctx) => {
         try {
-          const sessionKey = event.sessionKey ?? "";
+          const sessionKey = ctx.sessionKey ?? "";
           if (shouldSkipSession(sessionKey)) {
             return;
           }
+          if (sessionKey && hasSeenSession(sessionKey)) {
+            return;
+          }
           const config = api.pluginConfig;
           if (config?.enabled === false) {
             return;
           }
+          if (sessionKey) {
+            markSessionSeen(sessionKey);
+          }
           const agenrPath = resolveAgenrPath(config);
           const budget = resolveBudget(config);
           const result = await runRecall(agenrPath, budget);
@@ -141,6 +238,12 @@ var plugin = {
           if (!markdown.trim()) {
             return;
           }
+          const workspaceDir = typeof ctx.workspaceDir === "string" ? ctx.workspaceDir.trim() : "";
+          if (workspaceDir) {
+            const now = /* @__PURE__ */ new Date();
+            const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+            void writeAgenrMd(formatRecallAsSummary(result, timestamp), workspaceDir);
+          }
           return { prependContext: markdown };
         } catch (err) {
           api.logger.warn(

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "agenr",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "openclaw": {
-    "extensions": ["dist/openclaw-plugin/index.js"]
+    "extensions": [
+      "dist/openclaw-plugin/index.js"
+    ]
   },
   "description": "AGENt memoRy -- Memory infrastructure for AI agents",
   "type": "module",