agenr 0.8.27 → 0.8.28

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.8.28] - 2026-02-24
+
+### Fixed
+- command hook fires before_reset handoff logic for RPC-triggered /new (closes #210)
+  - before_reset hook only fires in the in-process auto-reply path; sessions.reset RPC
+    path only fires the command hook
+  - new command hook handler reads and parses the session JSONL directly, then runs
+    the same Phase 1 fallback store + Phase 2 LLM upgrade logic
+  - dedup guard (Set<sessionId>) prevents double-writes when both hooks fire in
+    auto-reply path
+
+### Added
+- [AGENR-PROBE] debug logging throughout command hook path for observability
+  (to be removed in a future cleanup pass)
+- readAndParseSessionJsonl() helper to parse JSONL session files line by line
+- runHandoffForSession() shared helper extracted from before_reset for reuse
+
+### Tests
+- 5 new tests for command hook handoff behavior in index.test.ts
+
 ## [0.8.27] - 2026-02-24
 
 ### Changed

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

@@ -78,6 +78,7 @@ type HandoffMessage = {
 };
 declare function getBaseSessionPath(filePath: string): string;
 declare function readSessionsJson(sessionsDir: string): Promise<Record<string, unknown>>;
+declare function readAndParseSessionJsonl(sessionFile: string): Promise<unknown[]>;
 declare function getSurfaceForSessionFile(sessionFilePath: string, sessionsJson: Record<string, unknown>): string;
 declare function readMessagesFromJsonl(filePath: string): Promise<HandoffMessage[]>;
 declare function findPriorResetFile(sessionsDir: string, currentSessionFile: string): Promise<string | null>;
@@ -90,6 +91,20 @@ declare function capTranscriptLength(params: {
     maxChars: number;
 }): string;
 declare function summarizeSessionForHandoff(currentRawMessages: BeforeResetEvent["messages"], sessionsDir: string, currentSessionFile: string, logger: PluginApi["logger"], streamSimpleImpl?: StreamSimpleFn): Promise<string | null>;
+declare function runHandoffForSession(opts: {
+    messages: unknown[];
+    sessionFile: string | null;
+    sessionId: string;
+    sessionKey: string;
+    agentId: string;
+    agenrPath: string;
+    budget: number;
+    defaultProject: string | undefined;
+    storeConfig: Record<string, unknown>;
+    sessionsDir: string;
+    logger: PluginLogger | undefined;
+    source: "before_reset" | "command";
+}): Promise<void>;
 declare const plugin: {
     id: string;
     name: string;
@@ -99,6 +114,7 @@ declare const plugin: {
 declare const __testing: {
     clearState(): void;
     readSessionsJson: typeof readSessionsJson;
+    readAndParseSessionJsonl: typeof readAndParseSessionJsonl;
     getBaseSessionPath: typeof getBaseSessionPath;
     getSurfaceForSessionFile: typeof getSurfaceForSessionFile;
     readMessagesFromJsonl: typeof readMessagesFromJsonl;
@@ -106,6 +122,7 @@ declare const __testing: {
     buildMergedTranscript: typeof buildMergedTranscript;
     capTranscriptLength: typeof capTranscriptLength;
     summarizeSessionForHandoff: typeof summarizeSessionForHandoff;
+    runHandoffForSession: typeof runHandoffForSession;
 };
 
 export { __testing, plugin as default };

package/dist/openclaw-plugin/index.js

@@ -917,6 +917,7 @@ var SKIP_SESSION_PATTERNS = [":subagent:", ":cron:"];
 var DEFAULT_MAX_SEEN_SESSIONS = 1e3;
 var seenSessions = /* @__PURE__ */ new Map();
 var sessionSignalState = /* @__PURE__ */ new Map();
+var handoffSeenSessionIds = /* @__PURE__ */ new Set();
 var pluginDb = null;
 var pluginDbInit = null;
 var didRegisterDbShutdown = false;
@@ -1072,6 +1073,26 @@ async function readSessionsJson(sessionsDir) {
     return {};
   }
 }
+async function readAndParseSessionJsonl(sessionFile) {
+  try {
+    const raw = await fs.promises.readFile(sessionFile, "utf8");
+    const messages = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        messages.push(parsed);
+      } catch {
+      }
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
 function getSurfaceForSessionFile(sessionFilePath, sessionsJson) {
   try {
     const normalizedTarget = path3.resolve(sessionFilePath);
@@ -1407,19 +1428,144 @@ async function retireFallbackHandoffEntries(params) {
     );
   }
 }
+function normalizeHandoffMessages(messages) {
+  return messages.map((message) => {
+    if (!isRecord2(message)) {
+      return message;
+    }
+    if (message["role"] === "user" || message["role"] === "assistant") {
+      return message;
+    }
+    if (message["type"] !== "message" || !isRecord2(message["message"])) {
+      return message;
+    }
+    const parsedMessage = { ...message["message"] };
+    if (typeof parsedMessage["timestamp"] !== "string" && typeof message["timestamp"] === "string") {
+      parsedMessage["timestamp"] = message["timestamp"];
+    }
+    return parsedMessage;
+  });
+}
+async function runHandoffForSession(opts) {
+  const sessionId = opts.sessionId.trim() || opts.sessionKey;
+  if (handoffSeenSessionIds.has(sessionId)) {
+    process.stderr.write(
+      `[AGENR-PROBE] ${opts.source} hook: dedup skip sessionId=${sessionId} source=${opts.source}
+`
+    );
+    return;
+  }
+  handoffSeenSessionIds.add(sessionId);
+  const evictionTimer = setTimeout(() => {
+    handoffSeenSessionIds.delete(sessionId);
+  }, 6e4);
+  if (typeof evictionTimer.unref === "function") {
+    evictionTimer.unref();
+  }
+  const normalizedMessages = normalizeHandoffMessages(opts.messages);
+  if (normalizedMessages.length === 0) {
+    process.stderr.write(`[AGENR-PROBE] ${opts.source} hook: no messages after normalization source=${opts.source}
+`);
+    return;
+  }
+  if (!opts.sessionFile) {
+    opts.logger?.debug?.(`[agenr] ${opts.source}: no sessionFile in event, using fallback`);
+  }
+  const fallbackText = extractLastExchangeText(normalizedMessages);
+  let fallbackEntrySubject = null;
+  if (fallbackText) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
+    fallbackEntrySubject = `session handoff ${timestamp}`;
+    const fallbackEntry = {
+      entries: [
+        {
+          type: "event",
+          importance: 9,
+          subject: fallbackEntrySubject,
+          content: fallbackText,
+          tags: ["handoff", "session"]
+        }
+      ]
+    };
+    try {
+      await runStoreTool(opts.agenrPath, fallbackEntry, opts.storeConfig, opts.defaultProject);
+      opts.logger?.debug?.(`[agenr] ${opts.source}: fallback handoff stored`);
+    } catch (err) {
+      opts.logger?.debug?.(
+        `[agenr] ${opts.source}: fallback store failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      fallbackEntrySubject = null;
+    }
+  }
+  if (opts.sessionFile) {
+    void testingApi.summarizeSessionForHandoff(
+      normalizedMessages,
+      opts.sessionsDir,
+      opts.sessionFile,
+      opts.logger ?? {
+        warn: () => void 0,
+        error: () => void 0
+      }
+    ).then(async (summary) => {
+      if (!summary) {
+        return;
+      }
+      if (fallbackEntrySubject && fallbackText) {
+        await retireFallbackHandoffEntries({
+          agenrPath: opts.agenrPath,
+          budget: opts.budget,
+          defaultProject: opts.defaultProject,
+          fallbackSubject: fallbackEntrySubject,
+          fallbackText,
+          logger: opts.logger ?? {
+            warn: () => void 0,
+            error: () => void 0
+          }
+        });
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
+      const llmEntry = {
+        entries: [
+          {
+            type: "event",
+            importance: 10,
+            subject: `session handoff ${timestamp}`,
+            content: summary,
+            tags: ["handoff", "session"]
+          }
+        ]
+      };
+      try {
+        await runStoreTool(opts.agenrPath, llmEntry, opts.storeConfig, opts.defaultProject);
+        opts.logger?.debug?.(`[agenr] ${opts.source}: LLM handoff stored`);
+      } catch (err) {
+        opts.logger?.debug?.(
+          `[agenr] ${opts.source}: LLM handoff store failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }).catch((err) => {
+      opts.logger?.debug?.(
+        `[agenr] ${opts.source}: LLM handoff rejected: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  }
+}
 var testingApi = {
   clearState() {
     seenSessions.clear();
     sessionSignalState.clear();
+    handoffSeenSessionIds.clear();
   },
   readSessionsJson,
+  readAndParseSessionJsonl,
   getBaseSessionPath,
   getSurfaceForSessionFile,
   readMessagesFromJsonl,
   findPriorResetFile,
   buildMergedTranscript,
   capTranscriptLength,
-  summarizeSessionForHandoff
+  summarizeSessionForHandoff,
+  runHandoffForSession
 };
 var plugin = {
   id: "agenr",
@@ -1578,26 +1724,25 @@ ${formatted.trim()}`);
     api.on("before_reset", async (event, ctx) => {
       try {
         process.stderr.write(
-          `[AGENR-PROBE] before_reset FIRED sessionKey=${ctx.sessionKey ?? "none"} msgs=${Array.isArray(event.messages) ? event.messages.length : "non-array"}
+          `[AGENR-PROBE] before_reset FIRED sessionKey=${ctx.sessionKey ?? "none"} msgs=${Array.isArray(event.messages) ? event.messages.length : "non-array"} source=before_reset
 `
         );
-        api.logger.info?.(`[agenr] before_reset: fired sessionKey=${ctx.sessionKey ?? "none"} agentId=${ctx.agentId ?? "none"} msgs=${Array.isArray(event.messages) ? event.messages.length : "non-array"} sessionFile=${event.sessionFile ?? "none"}`);
+        api.logger.info?.(`[agenr] before_reset: fired sessionKey=${ctx.sessionKey ?? "none"} agentId=${ctx.agentId ?? "none"} msgs=${Array.isArray(event.messages) ? event.messages.length : "non-array"} sessionFile=${event.sessionFile ?? "none"} source=before_reset`);
         const sessionKey = ctx.sessionKey;
         if (!sessionKey) {
           return;
         }
-        process.stderr.write(`[AGENR-PROBE] before_reset: sessionKey ok
+        process.stderr.write(`[AGENR-PROBE] before_reset: sessionKey ok source=before_reset
 `);
         const messages = event.messages;
         if (!Array.isArray(messages) || messages.length === 0) {
           return;
         }
-        process.stderr.write(`[AGENR-PROBE] before_reset: messages ok count=${messages.length}
-`);
+        process.stderr.write(
+          `[AGENR-PROBE] before_reset: messages ok count=${messages.length} source=before_reset
+`
+        );
         const currentSessionFile = typeof event.sessionFile === "string" && event.sessionFile.trim() ? event.sessionFile.trim() : null;
-        if (!currentSessionFile) {
-          api.logger.debug?.("[agenr] before_reset: no sessionFile in event, using fallback");
-        }
         const agentId = ctx.agentId?.trim() || "main";
         const sessionsDir = config?.sessionsDir ?? path3.join(os.homedir(), `.openclaw/agents/${agentId}/sessions`);
         const agenrPath = resolveAgenrPath(config);
@@ -1607,73 +1752,21 @@ ${formatted.trim()}`);
           ...config,
           logger: api.logger
         };
-        const fallbackText = extractLastExchangeText(messages);
-        let fallbackEntrySubject = null;
-        if (fallbackText) {
-          const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-          fallbackEntrySubject = `session handoff ${timestamp}`;
-          const fallbackEntry = {
-            entries: [
-              {
-                type: "event",
-                importance: 9,
-                subject: fallbackEntrySubject,
-                content: fallbackText,
-                tags: ["handoff", "session"]
-              }
-            ]
-          };
-          try {
-            await runStoreTool(agenrPath, fallbackEntry, storeConfig, defaultProject);
-            api.logger.debug?.("[agenr] before_reset: fallback handoff stored");
-          } catch (err) {
-            api.logger.debug?.(
-              `[agenr] before_reset: fallback store failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-            fallbackEntrySubject = null;
-          }
-        }
-        if (currentSessionFile) {
-          void testingApi.summarizeSessionForHandoff(messages, sessionsDir, currentSessionFile, api.logger).then(async (summary) => {
-            if (!summary) {
-              return;
-            }
-            if (fallbackEntrySubject && fallbackText) {
-              await retireFallbackHandoffEntries({
-                agenrPath,
-                budget,
-                defaultProject,
-                fallbackSubject: fallbackEntrySubject,
-                fallbackText,
-                logger: api.logger
-              });
-            }
-            const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-            const llmEntry = {
-              entries: [
-                {
-                  type: "event",
-                  importance: 10,
-                  subject: `session handoff ${timestamp}`,
-                  content: summary,
-                  tags: ["handoff", "session"]
-                }
-              ]
-            };
-            try {
-              await runStoreTool(agenrPath, llmEntry, storeConfig, defaultProject);
-              api.logger.debug?.("[agenr] before_reset: LLM handoff stored");
-            } catch (err) {
-              api.logger.debug?.(
-                `[agenr] before_reset: LLM handoff store failed: ${err instanceof Error ? err.message : String(err)}`
-              );
-            }
-          }).catch((err) => {
-            api.logger.debug?.(
-              `[agenr] before_reset: LLM handoff rejected: ${err instanceof Error ? err.message : String(err)}`
-            );
-          });
-        }
+        const sessionId = ctx.sessionId ?? ctx.sessionKey ?? sessionKey;
+        await runHandoffForSession({
+          messages,
+          sessionFile: currentSessionFile,
+          sessionId,
+          sessionKey,
+          agentId,
+          agenrPath,
+          budget,
+          defaultProject,
+          storeConfig,
+          sessionsDir,
+          logger: api.logger,
+          source: "before_reset"
+        });
       } catch (err) {
         api.logger.warn(
           `agenr plugin before_reset failed: ${err instanceof Error ? err.message : String(err)}`
@@ -1682,6 +1775,81 @@ ${formatted.trim()}`);
     });
     process.stderr.write(`[AGENR-PROBE] before_reset hook registered
 `);
+    api.on(
+      "command",
+      async (event, ctx) => {
+        try {
+          process.stderr.write(
+            `[AGENR-PROBE] command hook FIRED action=${event.action ?? "none"} sessionKey=${event.sessionKey ?? "none"} source=${String(event.context?.commandSource ?? "unknown")}
+`
+          );
+          if (event.action !== "new" && event.action !== "reset") {
+            process.stderr.write(
+              `[AGENR-PROBE] command hook: skipping action=${event.action ?? "none"} source=command
+`
+            );
+            return;
+          }
+          const sessionKey = event.sessionKey;
+          if (!sessionKey) {
+            process.stderr.write("[AGENR-PROBE] command hook: no sessionKey, skipping source=command\n");
+            return;
+          }
+          const sessionFile = event.context?.sessionEntry?.sessionFile ?? null;
+          const sessionId = event.context?.sessionEntry?.sessionId ?? sessionKey;
+          process.stderr.write(
+            `[AGENR-PROBE] command hook: new/reset detected sessionKey=${sessionKey} sessionFile=${sessionFile ?? "none"} source=command
+`
+          );
+          api.logger.info?.(
+            `[agenr] command hook: fired action=${event.action} sessionKey=${sessionKey} sessionFile=${sessionFile ?? "none"} source=command`
+          );
+          let messages = [];
+          if (sessionFile) {
+            messages = await testingApi.readAndParseSessionJsonl(sessionFile);
+            process.stderr.write(
+              `[AGENR-PROBE] command hook: parsed ${messages.length} messages from JSONL source=command
+`
+            );
+          } else {
+            process.stderr.write("[AGENR-PROBE] command hook: no sessionFile available source=command\n");
+          }
+          if (messages.length === 0) {
+            process.stderr.write("[AGENR-PROBE] command hook: no messages, skipping handoff source=command\n");
+            return;
+          }
+          const agentId = ctx.agentId?.trim() || "main";
+          const sessionsDir = config?.sessionsDir ?? path3.join(os.homedir(), `.openclaw/agents/${agentId}/sessions`);
+          const agenrPath = resolveAgenrPath(config);
+          const defaultProject = config?.project?.trim() || void 0;
+          const budget = resolveBudget(config);
+          const storeConfig = {
+            ...config,
+            logger: api.logger
+          };
+          await runHandoffForSession({
+            messages,
+            sessionFile,
+            sessionId,
+            sessionKey,
+            agentId,
+            agenrPath,
+            budget,
+            defaultProject,
+            storeConfig,
+            sessionsDir,
+            logger: api.logger,
+            source: "command"
+          });
+          process.stderr.write("[AGENR-PROBE] command hook: handoff complete source=command\n");
+        } catch (err) {
+          api.logger.warn(
+            `agenr plugin command hook failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    );
+    process.stderr.write("[AGENR-PROBE] command hook registered\n");
     if (api.registerTool) {
       if (config?.enabled === false) {
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"