@memoryrelay/plugin-memoryrelay-ai 0.17.1 → 0.18.0

package/index.ts

@@ -1,6 +1,6 @@
 /**
  * OpenClaw Memory Plugin - MemoryRelay
- * Version: 0.17.1
+ * Version: 0.18.0
  *
  * Long-term memory with vector search using MemoryRelay API.
  * Provides auto-recall and auto-capture via lifecycle hooks.
@@ -444,7 +444,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
   // Register Hooks (8 modules)
   // ========================================================================
 
-  registerBeforeAgentStart(api, pluginConfig, isToolEnabled, defaultProject);
+  registerBeforeAgentStart(api, pluginConfig, client, isToolEnabled, defaultProject);
   registerBeforePromptBuild(api, pluginConfig, client, sessionResolver, localCache, syncDaemon);
   registerAgentEnd(api, pluginConfig, client, sessionResolver, localCache, syncDaemon);
   registerSessionLifecycle(api, pluginConfig, client, agentId, defaultProject, sessionResolver);
@@ -472,7 +472,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
   // ========================================================================
 
   api.logger.info?.(
-    `memory-memoryrelay: plugin v0.17.1 loaded (${Object.values(TOOL_GROUPS).flat().length} tools, autoRecall: ${pluginConfig.autoRecall}, autoCapture: ${autoCaptureConfig.enabled ? autoCaptureConfig.tier : "off"}, debug: ${debugEnabled})`,
+    `memory-memoryrelay: plugin v0.18.0 loaded (${Object.values(TOOL_GROUPS).flat().length} tools, autoRecall: ${pluginConfig.autoRecall}, autoCapture: ${autoCaptureConfig.enabled ? autoCaptureConfig.tier : "off"}, debug: ${debugEnabled})`,
   );
 
   // ========================================================================

package/openclaw.plugin.json

@@ -2,8 +2,8 @@
   "id": "plugin-memoryrelay-ai",
   "kind": "memory",
   "name": "MemoryRelay AI",
-  "description": "MemoryRelay v0.17.1 - Long-term memory with pipeline architecture, 42 tools, 17 commands, V2 async, sessions, decisions, patterns & projects (api.memoryrelay.net)",
-  "version": "0.17.1",
+  "description": "MemoryRelay v0.18.0 - Long-term memory with pipeline architecture, 42 tools, 17 commands, V2 async, sessions, decisions, patterns & projects (api.memoryrelay.net)",
+  "version": "0.18.0",
   "uiHints": {
     "apiKey": {
       "label": "MemoryRelay API Key",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoryrelay/plugin-memoryrelay-ai",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "OpenClaw memory plugin for MemoryRelay API - 42 tools, 17 commands, V2 async, sessions, decisions, patterns, projects & semantic search",
   "type": "module",
   "main": "index.ts",
@@ -42,7 +42,8 @@
   "openclaw": {
     "extensions": [
       "index.ts"
-    ]
+    ],
+    "hooks": []
   },
   "files": [
     "index.ts",

package/src/client/memoryrelay-client.ts

@@ -153,7 +153,7 @@ export class MemoryRelayClient implements IMemoryRelayClient {
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${this.apiKey}`,
-            "User-Agent": "openclaw-memory-memoryrelay/0.17.1",
+            "User-Agent": "openclaw-memory-memoryrelay/0.18.0",
           },
           body: body ? JSON.stringify(body) : undefined,
         },

package/src/hooks/agent-end.ts

@@ -4,6 +4,65 @@ import type { PluginConfig, MemoryRelayClient, ConversationMessage, SessionResol
 import { buildRequestContext } from "../context/request-context.js";
 import { runPipeline } from "../pipelines/runner.js";
 import { capturePipeline } from "../pipelines/capture/index.js";
+import { autoSessionMap, DECISION_KEYWORDS } from "./auto-session-store.js";
+
+/**
+ * Extract potential decisions from conversation messages using keyword heuristics.
+ * Returns an array of { title, rationale } for each detected decision.
+ */
+export function extractDecisions(
+  messages: ConversationMessage[],
+): Array<{ title: string; rationale: string }> {
+  const decisions: Array<{ title: string; rationale: string }> = [];
+  const seen = new Set<string>();
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    const content = msg.content;
+    const lower = content.toLowerCase();
+
+    for (const keyword of DECISION_KEYWORDS) {
+      if (!lower.includes(keyword)) continue;
+
+      // Find the sentence containing the keyword
+      const sentences = content.split(/[.!?\n]+/).filter((s) => s.trim().length > 10);
+      for (const sentence of sentences) {
+        if (!sentence.toLowerCase().includes(keyword)) continue;
+        const trimmed = sentence.trim();
+        // Avoid duplicates and very long passages
+        if (trimmed.length > 500) continue;
+        const key = trimmed.slice(0, 80).toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+
+        decisions.push({
+          title: trimmed.slice(0, 200),
+          rationale: `Auto-detected from conversation (keyword: "${keyword}"): ${trimmed}`,
+        });
+        break; // One decision per keyword per message
+      }
+      if (decisions.length >= 5) break; // Cap at 5 decisions per session
+    }
+    if (decisions.length >= 5) break;
+  }
+  return decisions;
+}
+
+/**
+ * Generate a summary from the last few significant assistant messages.
+ */
+export function generateSessionSummary(messages: ConversationMessage[]): string {
+  const assistantMessages = messages
+    .filter((m) => m.role === "assistant" && m.content.length > 30)
+    .slice(-3);
+
+  if (assistantMessages.length === 0) return "Session completed.";
+
+  return assistantMessages
+    .map((m) => m.content.slice(0, 300))
+    .join(" | ")
+    .slice(0, 800);
+}
 
 export function registerAgentEnd(
   api: OpenClawPluginApi,
@@ -18,28 +77,67 @@ export function registerAgentEnd(
   api.on("agent_end", async (event) => {
     if (!event.success || !event.messages || event.messages.length === 0) return;
 
-    try {
-      const messages: ConversationMessage[] = [];
-      for (const msg of event.messages) {
-        if (!msg || typeof msg !== "object") continue;
-        const msgObj = msg as Record<string, unknown>;
-        const role = msgObj.role as string;
-        if (role !== "user" && role !== "assistant") continue;
-
-        const content = msgObj.content;
-        if (typeof content === "string") {
-          messages.push({ role: role as "user" | "assistant", content });
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block && typeof block === "object" && (block as any).type === "text" && (block as any).text) {
-              messages.push({ role: role as "user" | "assistant", content: (block as any).text });
-            }
+    // Parse messages first (shared by session lifecycle and capture pipeline)
+    const messages: ConversationMessage[] = [];
+    for (const msg of event.messages) {
+      if (!msg || typeof msg !== "object") continue;
+      const msgObj = msg as Record<string, unknown>;
+      const role = msgObj.role as string;
+      if (role !== "user" && role !== "assistant") continue;
+
+      const content = msgObj.content;
+      if (typeof content === "string") {
+        messages.push({ role: role as "user" | "assistant", content });
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block && typeof block === "object" && (block as any).type === "text" && (block as any).text) {
+            messages.push({ role: role as "user" | "assistant", content: (block as any).text });
           }
         }
       }
+    }
+
+    if (messages.length === 0) return;
+
+    // --- Auto session lifecycle: decisions + session_end ---
+    const sessionKey = event.ctx?.sessionKey || event.sessionId || "";
+    const sessionId = autoSessionMap.get(sessionKey);
+
+    if (sessionId) {
+      try {
+        // Extract and record decisions
+        const decisions = extractDecisions(messages);
+        const projectSlug = config.defaultProject || process.env.MEMORYRELAY_DEFAULT_PROJECT;
 
-      if (messages.length === 0) return;
+        for (const decision of decisions) {
+          try {
+            await client.recordDecision(
+              decision.title,
+              decision.rationale,
+              undefined,
+              projectSlug,
+              ["auto-detected"],
+              undefined,
+              { source: "auto-session-lifecycle", session_id: sessionId },
+            );
+          } catch (err) {
+            api.logger.warn?.(`memory-memoryrelay: auto decision_record failed: ${String(err)}`);
+          }
+        }
+
+        // End session with summary
+        const summary = generateSessionSummary(messages);
+        await client.endSession(sessionId, summary);
+        api.logger.debug?.(`memory-memoryrelay: auto-session ended ${sessionId}`);
+      } catch (err) {
+        api.logger.warn?.(`memory-memoryrelay: auto session_end failed (non-blocking): ${String(err)}`);
+      } finally {
+        autoSessionMap.delete(sessionKey);
+      }
+    }
 
+    // --- Existing capture pipeline ---
+    try {
       const requestCtx = buildRequestContext(event, config);
       const pipelineCtx = { requestCtx, config, client, sessionResolver, localCache, syncDaemon };
       await runPipeline(capturePipeline, { messages }, pipelineCtx);

package/src/hooks/auto-session-store.ts

@@ -0,0 +1,16 @@
+// src/hooks/auto-session-store.ts
+// Shared state between before-agent-start and agent-end hooks for auto session lifecycle.
+
+/** Maps agent session key → MemoryRelay session ID */
+export const autoSessionMap = new Map<string, string>();
+
+/** Decision detection keywords used in agent-end heuristics */
+export const DECISION_KEYWORDS = [
+  "decided",
+  "going with",
+  "architecture",
+  "we will",
+  "won't",
+  "instead of",
+  "chosen",
+];

package/src/hooks/before-agent-start.ts

@@ -1,10 +1,28 @@
 // src/hooks/before-agent-start.ts
+import { basename } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type { PluginConfig } from "../pipelines/types.js";
+import type { PluginConfig, MemoryRelayClient } from "../pipelines/types.js";
+import { autoSessionMap } from "./auto-session-store.js";
+
+/**
+ * Resolve project slug from config, env, or working directory name.
+ */
+function resolveProjectSlug(config: PluginConfig, defaultProject: string | undefined): string | undefined {
+  if (defaultProject) return defaultProject;
+  if (config.defaultProject) return config.defaultProject;
+  const envProject = process.env.MEMORYRELAY_DEFAULT_PROJECT;
+  if (envProject) return envProject;
+  try {
+    return basename(process.cwd());
+  } catch {
+    return undefined;
+  }
+}
 
 export function registerBeforeAgentStart(
   api: OpenClawPluginApi,
   config: PluginConfig,
+  client: MemoryRelayClient,
   isToolEnabled: (name: string) => boolean,
   defaultProject: string | undefined,
 ): void {
@@ -24,6 +42,62 @@ export function registerBeforeAgentStart(
       }
     }
 
+    // --- Auto session lifecycle: session_start + project_context ---
+    const projectSlug = resolveProjectSlug(config, defaultProject);
+    let projectContextBlock = "";
+
+    try {
+      const sessionKey = event.ctx?.sessionKey || event.sessionId || "";
+
+      // Start a tracked session (non-blocking — we await but don't let failure block the turn)
+      const today = new Date().toISOString().slice(0, 10);
+      const sessionResult = await client.startSession(
+        `Auto session ${today}`,
+        projectSlug,
+        { source: "openclaw-plugin", trigger: "before_agent_start" },
+      );
+
+      if (sessionResult?.id && sessionKey) {
+        autoSessionMap.set(sessionKey, sessionResult.id);
+        api.logger.debug?.(`memory-memoryrelay: auto-session started ${sessionResult.id}`);
+      }
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: auto session_start failed (non-blocking): ${String(err)}`);
+    }
+
+    // Load project context (hot memories, decisions, patterns)
+    if (projectSlug) {
+      try {
+        const ctx = await client.getProjectContext(projectSlug);
+        if (ctx) {
+          const parts: string[] = [];
+          if (ctx.hot_memories?.length) {
+            parts.push("### Hot Memories");
+            for (const m of ctx.hot_memories.slice(0, 10)) {
+              parts.push(`- ${m.content ?? m}`);
+            }
+          }
+          if (ctx.recent_decisions?.length) {
+            parts.push("### Active Decisions");
+            for (const d of ctx.recent_decisions.slice(0, 5)) {
+              parts.push(`- **${d.title}**: ${(d.rationale ?? "").slice(0, 200)}`);
+            }
+          }
+          if (ctx.active_patterns?.length) {
+            parts.push("### Adopted Patterns");
+            for (const p of ctx.active_patterns.slice(0, 5)) {
+              parts.push(`- **${p.title}**: ${(p.description ?? "").slice(0, 150)}`);
+            }
+          }
+          if (parts.length > 0) {
+            projectContextBlock = `\n\n## Project Context (${projectSlug})\n\n${parts.join("\n")}`;
+          }
+        }
+      } catch (err) {
+        api.logger.warn?.(`memory-memoryrelay: project_context failed (non-blocking): ${String(err)}`);
+      }
+    }
+
     // Build workflow instructions dynamically based on enabled tools
     const lines: string[] = [
       "You have MemoryRelay tools available for persistent memory across sessions.",
@@ -102,7 +176,7 @@ export function registerBeforeAgentStart(
 
     const workflowInstructions = lines.join("\n");
 
-    const prependContext = `<memoryrelay-workflow>\n${workflowInstructions}\n</memoryrelay-workflow>`;
+    const prependContext = `<memoryrelay-workflow>\n${workflowInstructions}${projectContextBlock}\n</memoryrelay-workflow>`;
 
     return { prependContext };
   });

package/src/pipelines/types.ts

@@ -109,7 +109,18 @@ export interface MemoryRelayClient {
     project?: string,
     metadata?: Record<string, string>,
   ): Promise<{ id: string }>;
+  startSession(title?: string, project?: string, metadata?: Record<string, string>): Promise<{ id: string }>;
   endSession(sessionId: string, summary?: string): Promise<void>;
+  getProjectContext(project: string): Promise<any>;
+  recordDecision(
+    title: string,
+    rationale: string,
+    alternatives?: string,
+    project?: string,
+    tags?: string[],
+    status?: string,
+    metadata?: Record<string, string>,
+  ): Promise<any>;
 }
 
 export interface SessionResolverLike {