agenr 0.6.7 → 0.6.10

package/CHANGELOG.md

@@ -1,10 +1,32 @@
+# 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
+- fix(openclaw-plugin): OpenClaw plugin now uses api.on("before_agent_start") instead of api.registerHook("agent:bootstrap"). The previous approach registered the handler in the gateway bundle's internal handlers map, which is a different module instance from the embedded agent runner. The typed hook system (api.on) uses the shared global plugin registry and works correctly across both bundles.
+
 ## [0.6.7] - 2026-02-19
 
 ### Fixed
 - fix(openclaw-plugin): add name and description to registerHook opts to resolve OpenClaw hook registration warning
 
-# Changelog
-
 ## [0.6.6] - 2026-02-19
 
 ### Added

package/dist/cli-main.js

@@ -12451,7 +12451,22 @@ function resolveWatcherPidPath(configDir) {
 async function writeWatcherPid(configDir) {
   const pidPath = resolveWatcherPidPath(configDir);
   await fs26.mkdir(path25.dirname(pidPath), { recursive: true });
-  await fs26.writeFile(pidPath, String(process.pid), "utf8");
+  const tmpPath = `${pidPath}.${process.pid}.${Date.now()}.tmp`;
+  let handle = null;
+  try {
+    handle = await fs26.open(tmpPath, "w");
+    await handle.writeFile(String(process.pid), "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await fs26.rename(tmpPath, pidPath);
+  } catch (error) {
+    if (handle) {
+      await handle.close().catch(() => void 0);
+    }
+    await fs26.unlink(tmpPath).catch(() => void 0);
+    throw error;
+  }
 }
 async function deleteWatcherPid(configDir) {
   try {
@@ -12778,6 +12793,8 @@ async function runIngestCommand(inputPaths, options, deps) {
     loadWatchStateFn: deps?.loadWatchStateFn ?? loadWatchState,
     saveWatchStateFn: deps?.saveWatchStateFn ?? saveWatchState,
     isWatcherRunningFn: deps?.isWatcherRunningFn ?? isWatcherRunning,
+    readWatcherPidFn: deps?.readWatcherPidFn ?? readWatcherPid,
+    resolveWatcherPidPathFn: deps?.resolveWatcherPidPathFn ?? resolveWatcherPidPath,
     nowFn: deps?.nowFn ?? (() => /* @__PURE__ */ new Date()),
     sleepFn: deps?.sleepFn ?? sleep,
     shouldShutdownFn: deps?.shouldShutdownFn ?? isShutdownRequested
@@ -12785,8 +12802,8 @@ async function runIngestCommand(inputPaths, options, deps) {
   const clackOutput = { output: process.stderr };
   clack4.intro(banner(), clackOutput);
   if (await resolvedDeps.isWatcherRunningFn()) {
-    const pid = await readWatcherPid();
-    const pidFile = resolveWatcherPidPath();
+    const pid = await resolvedDeps.readWatcherPidFn();
+    const pidFile = resolvedDeps.resolveWatcherPidPathFn();
     clack4.log.error(
       formatError(
         `agenr watcher is running (PID ${pid ?? "unknown"}). Stop the watcher before running ingest.
@@ -16259,6 +16276,7 @@ async function runWatchCommand(file, options, deps) {
   const clackOutput = { output: process.stderr };
   warnIfLocked();
   installSignalHandlers();
+  clack10.intro(banner(), clackOutput);
   try {
     await resolvedDeps.writeWatcherPidFn();
   } catch (error) {
@@ -16286,7 +16304,6 @@ async function runWatchCommand(file, options, deps) {
     const raw = options.raw === true;
     const contextEnabled = Boolean(options.context);
     const modeConfig = await resolveWatchMode(file, options, resolvedDeps.statFileFn);
-    clack10.intro(banner(), clackOutput);
     for (const warning of modeConfig.warnings) {
       process.stderr.write(`${warning}
 `);
@@ -16364,13 +16381,12 @@ async function runWatchCommand(file, options, deps) {
         },
         onCycle: (result, ctx) => {
           cycleCount += 1;
-          const timestamp = formatClock(resolvedDeps.nowFn());
+          const now = resolvedDeps.nowFn();
+          const timestamp = formatClock(now);
           const fileLabel = result.filePath ? ` | file=${result.filePath}` : "";
           if (json) {
-            process.stdout.write(
-              `${JSON.stringify({ cycle: cycleCount, at: resolvedDeps.nowFn().toISOString(), ...result })}
-`
-            );
+            process.stdout.write(`${JSON.stringify({ cycle: cycleCount, at: now.toISOString(), ...result })}
+`);
           }
           if (result.error) {
             clack10.log.warn(formatWarn(`[${timestamp}] Cycle ${cycleCount}: ${result.error}${fileLabel}`), clackOutput);

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

@@ -1,10 +1,15 @@
-type HookEvent = {
-    type: string;
-    action: string;
-    sessionKey: string;
-    context: Record<string, unknown>;
-    timestamp: Date;
-    messages: string[];
+type BeforeAgentStartEvent = {
+    prompt?: string;
+    messages?: unknown[];
+    [key: string]: unknown;
+};
+type PluginHookAgentContext = {
+    sessionKey?: string;
+    workspaceDir?: string;
+    [key: string]: unknown;
+};
+type BeforeAgentStartResult = {
+    prependContext?: string;
 };
 type PluginLogger = {
     debug?: (message: string) => void;
@@ -18,7 +23,7 @@ type PluginApi = {
     version?: string;
     pluginConfig?: Record<string, unknown>;
     logger: PluginLogger;
-    registerHook: (events: string | string[], handler: (event: HookEvent) => Promise<void> | void) => 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,31 +1,30 @@
-// src/openclaw-plugin/index.ts
-import os from "os";
-import path2 from "path";
-
 // 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;
@@ -34,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(() => {
@@ -65,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 "";
   }
@@ -112,52 +120,139 @@ 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 AGENR_CONTEXT_PATH = path2.join(os.homedir(), ".agenr", "AGENR.md");
 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",
-  description: "Injects agenr long-term memory into every agent session via agent:bootstrap",
+  description: "Injects agenr long-term memory into every agent session via before_agent_start",
   register(api) {
-    api.registerHook("agent:bootstrap", async (event) => {
-      try {
-        const ctx = event.context;
-        if (!Array.isArray(ctx.bootstrapFiles)) {
-          return;
-        }
-        const sessionKey = ctx.sessionKey ?? event.sessionKey ?? "";
-        if (shouldSkipSession(sessionKey)) {
+    api.on(
+      "before_agent_start",
+      async (_event, ctx) => {
+        try {
+          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);
+          if (!result) {
+            return;
+          }
+          const markdown = formatRecallAsMarkdown(result);
+          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(
+            `agenr plugin before_agent_start recall failed: ${err instanceof Error ? err.message : String(err)}`
+          );
           return;
         }
-        const config = api.pluginConfig;
-        if (config?.enabled === false) {
-          return;
-        }
-        const agenrPath = resolveAgenrPath(config);
-        const budget = resolveBudget(config);
-        const result = await runRecall(agenrPath, budget);
-        if (!result) {
-          return;
-        }
-        const markdown = formatRecallAsMarkdown(result);
-        if (!markdown.trim()) {
-          return;
-        }
-        const file = {
-          name: "AGENR.md",
-          path: AGENR_CONTEXT_PATH,
-          content: markdown,
-          missing: false
-        };
-        ctx.bootstrapFiles.push(file);
-      } catch {
       }
-    });
+    );
   }
 };
 var openclaw_plugin_default = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.6.7",
+  "version": "0.6.10",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"
@@ -11,6 +11,13 @@
   "bin": {
     "agenr": "dist/cli.js"
   },
+  "scripts": {
+    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts",
+    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
     "@libsql/client": "^0.17.0",
@@ -53,11 +60,9 @@
     "README.md"
   ],
   "author": "agenr-ai",
-  "scripts": {
-    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts",
-    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit"
+  "pnpm": {
+    "overrides": {
+      "fast-xml-parser": "^5.3.6"
+    }
   }
-}
+}