@evermind-ai/openclaw-plugin 1.1.0 → 1.3.0

package/index.js

@@ -1,14 +1,20 @@
 /**
- * EverMemOS ContextEngine Plugin for OpenClaw
- * Registers EverMemOS as the context engine for memory management
+ * EverOS OpenClaw Plugin
+ * Registers the EverOS backend as the context engine for memory management
  */
 
+import { createRequire } from "node:module";
 import { resolveConfig } from "./src/config.js";
 import { searchMemories, saveMemories } from "./src/memory-api.js";
 import { buildMemoryPrompt, parseSearchResponse } from "./src/formatter.js";
 import { collectMessages, toText, isSessionResetPrompt } from "./src/message-utils.js";
+import { ContextAssembler } from "./src/assembler.js";
+import { SubagentTracker } from "./src/subagent.js";
 
-const PLUGIN_ID = "evermemos-openclaw-plugin";
+const require = createRequire(import.meta.url);
+const pluginMeta = require("./openclaw.plugin.json");
+const PLUGIN_ID = pluginMeta.id;
+const PLUGIN_VERSION = pluginMeta.version;
 
 /**
  * Convert OpenClaw AgentMessage to EverMemOS message format
@@ -131,7 +137,7 @@ function safePreview(content, maxLength = 200) {
 }
 
 /**
- * Create EverMemOS ContextEngine instance
+ * Create EverOS ContextEngine instance
  * @param {Object} pluginConfig - Plugin configuration
  * @param {Object} logger - Logger instance
  * @returns {Object} - ContextEngine implementation
@@ -139,36 +145,49 @@ function safePreview(content, maxLength = 200) {
 function createContextEngineInstance(pluginConfig, logger) {
   const cfg = resolveConfig(pluginConfig);
   const log = logger || { info: (...a) => console.log(...a), warn: (...a) => console.warn(...a) };
+  const assembler = new ContextAssembler(cfg, log);
+  const subagentTracker = new SubagentTracker(cfg, log);
 
-  log.info(`[evermemos] ContextEngine config: baseUrl=${cfg.serverUrl}, userId=${cfg.userId}`);
+  log.info(`[everos] ContextEngine config: baseUrl=${cfg.serverUrl}, userId=${cfg.userId}`);
 
   // Session state - shared across all sessions for this engine instance
   const sessionState = new Map();
+  const SESSION_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+  function pruneStaleSessionState() {
+    const now = Date.now();
+    for (const [key, state] of sessionState) {
+      if (now - (state.lastActiveTime || 0) > SESSION_TTL_MS) {
+        sessionState.delete(key);
+        log.info(`[everos] pruned stale session state: ${key}`);
+      }
+    }
+  }
 
   return {
     info: {
       id: PLUGIN_ID,
-      name: "EverMemOS ContextEngine",
-      version: "1.0.0",
+      name: pluginMeta.name,
+      version: PLUGIN_VERSION,
       ownsCompaction: false,
     },
 
     async bootstrap({ sessionId, sessionKey }) {
-      log.info(`[evermemos] bootstrap: session=${sessionId}, key=${sessionKey}`);
+      log.info(`[everos] bootstrap: session=${sessionId}, key=${sessionKey}`);
 
-      // Verify EverMemOS backend health
+      // Verify EverOS backend health
       try {
         const response = await fetch(`${cfg.serverUrl}/health`, {
           signal: AbortSignal.timeout(5000),
         });
         if (response.ok) {
           const result = await response.json();
-          log.info(`[evermemos] bootstrap: backend healthy, status=${result.status}`);
+          log.info(`[everos] bootstrap: backend healthy, status=${result.status}`);
         } else {
-          log.warn(`[evermemos] bootstrap: backend unhealthy, status=${response.status}`);
+          log.warn(`[everos] bootstrap: backend unhealthy, status=${response.status}`);
         }
       } catch (err) {
-        log.warn(`[evermemos] bootstrap: health check failed: ${err.message}`);
+        log.warn(`[everos] bootstrap: health check failed: ${err.message}`);
       }
 
       // Initialize or get session state
@@ -176,83 +195,81 @@ function createContextEngineInstance(pluginConfig, logger) {
         sessionState.set(sessionKey, {
           turnCount: 0,
           lastAssembleTime: 0,
+          lastActiveTime: Date.now(),
           pendingFlush: false,
-          pendingMessages: [],
         });
-        log.info(`[evermemos] bootstrap: initialized state for ${sessionKey}`);
+        log.info(`[everos] bootstrap: initialized state for ${sessionKey}`);
       } else {
-        log.info(`[evermemos] bootstrap: reusing existing state for ${sessionKey}, turn=${sessionState.get(sessionKey).turnCount}`);
+        log.info(`[everos] bootstrap: reusing existing state for ${sessionKey}, turn=${sessionState.get(sessionKey).turnCount}`);
       }
 
       return { bootstrapped: true };
     },
 
     async ingest({ sessionId, sessionKey, message }) {
-      log.info(`[evermemos] ingest: session=${sessionKey}, role=${message?.role}, isHeartbeat=${message?.isHeartbeat}`);
-
-      const state = sessionState.get(sessionKey);
-      if (!state) {
-        log.warn(`[evermemos] ingest: no state for session=${sessionKey}`);
-        return { ingested: false };
-      }
+      log.info(`[everos] ingest: session=${sessionKey}, role=${message?.role}, isHeartbeat=${message?.isHeartbeat}`);
 
       // Don't ingest heartbeats
       if (message.isHeartbeat) {
         return { ingested: false };
       }
 
-      // Store for batch processing in afterTurn
-      state.pendingMessages.push(message);
-      log.info(`[evermemos] ingest: collected ${state.pendingMessages.length} messages so far`);
+      if (!sessionState.has(sessionKey)) {
+        log.warn(`[everos] ingest: no state for session=${sessionKey}`);
+        return { ingested: false };
+      }
 
+      // Messages are not buffered here; actual saving happens in afterTurn()
+      // where the full message list is available from the OpenClaw runtime.
       return { ingested: true };
     },
 
     async ingestBatch({ sessionId, sessionKey, messages, isHeartbeat }) {
-      log.info(`[evermemos] ingestBatch: session=${sessionKey}, count=${messages?.length}, isHeartbeat=${isHeartbeat}`);
+      log.info(`[everos] ingestBatch: session=${sessionKey}, count=${messages?.length}, isHeartbeat=${isHeartbeat}`);
 
       if (isHeartbeat) {
         return { ingestedCount: 0 };
       }
 
-      const state = sessionState.get(sessionKey);
-      if (!state) {
-        log.warn(`[evermemos] ingestBatch: no state for session=${sessionKey}`);
+      if (!sessionState.has(sessionKey)) {
+        log.warn(`[everos] ingestBatch: no state for session=${sessionKey}`);
         return { ingestedCount: 0 };
       }
 
-      // Store messages for later processing
-      state.pendingMessages.push(...messages);
-      log.info(`[evermemos] ingestBatch: collected ${state.pendingMessages.length} messages so far`);
-
-      return { ingestedCount: messages.length };
+      // Messages are not buffered here; actual saving happens in afterTurn()
+      // where the full message list is available from the OpenClaw runtime.
+      return { ingestedCount: 0 };
     },
 
     async afterTurn({ sessionId, sessionKey, messages, prePromptMessageCount }) {
       const state = sessionState.get(sessionKey);
       if (!state) {
-        log.warn(`[evermemos] afterTurn: no state for session=${sessionKey}`);
+        log.warn(`[everos] afterTurn: no state for session=${sessionKey}`);
         return;
       }
 
       state.turnCount++;
+      state.lastActiveTime = Date.now();
 
-      // Get new messages (those added after prePromptMessageCount)
+      // When OpenClaw provides prePromptMessageCount, save only the new tail.
+      // Otherwise, fall back to the last conversational turn to avoid re-saving the full session.
       const newMessages = prePromptMessageCount !== undefined
         ? messages.slice(prePromptMessageCount)
-        : messages;
+        : collectMessages(messages);
 
-      log.info(`[evermemos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, totalMessages=${messages.length}, newMessages=${newMessages.length}`);
+      log.info(`[everos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, totalMessages=${messages.length}, newMessages=${newMessages.length}`);
 
       if (newMessages.length === 0) {
-        log.info(`[evermemos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, no new messages to save`);
+        log.info(`[everos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, no new messages to save`);
         return;
       }
 
       try {
-        const evermemosMessages = newMessages.map(convertMessage).filter((m) => m.content);
+        const evermemosMessages = prePromptMessageCount !== undefined
+          ? newMessages.map(convertMessage).filter((m) => m.content)
+          : newMessages.filter((m) => m.content);
         if (evermemosMessages.length === 0) {
-          log.info(`[evermemos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, no valid messages to save`);
+          log.info(`[everos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, no valid messages to save`);
           return;
         }
         await saveMemories(cfg, {
@@ -260,35 +277,39 @@ function createContextEngineInstance(pluginConfig, logger) {
           groupId: cfg.groupId,
           messages: evermemosMessages,
           flush: state.pendingFlush || false,
-        });
-        log.info(`[evermemos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, saved ${evermemosMessages.length} messages`);
+        }, log);
+        log.info(`[everos] afterTurn: session=${sessionKey}, turn=${state.turnCount}, saved ${evermemosMessages.length} messages`);
 
         if (state.pendingFlush) {
           state.pendingFlush = false;
-          log.info(`[evermemos] afterTurn: flush flag consumed`);
+          log.info(`[everos] afterTurn: flush flag consumed`);
         }
       } catch (err) {
-        log.warn(`[evermemos] afterTurn: save failed: ${err.message}`);
+        log.warn(`[everos] afterTurn: save failed: ${err.message}`);
       }
     },
 
     async assemble({ sessionId, sessionKey, messages, tokenBudget }) {
+      // Periodically prune stale sessions to prevent memory leaks
+      pruneStaleSessionState();
+
       // Initialize state if not exists (assemble can be called before bootstrap)
       if (!sessionState.has(sessionKey)) {
         sessionState.set(sessionKey, {
           turnCount: 0,
           lastAssembleTime: 0,
+          lastActiveTime: Date.now(),
           pendingFlush: false,
-          pendingMessages: [],
         });
-        log.info(`[evermemos] assemble: initialized state for ${sessionKey}`);
+        log.info(`[everos] assemble: initialized state for ${sessionKey}`);
       }
 
       const state = sessionState.get(sessionKey);
+      state.lastActiveTime = Date.now();
 
       // Get the last user message as query
       const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
-      const query = lastUserMsg ? toText(lastUserMsg) : "";
+      const query = lastUserMsg ? toText(lastUserMsg.content) : "";
 
       if (!query || query.length < 3) {
         return { messages, estimatedTokens: 0 };
@@ -296,7 +317,7 @@ function createContextEngineInstance(pluginConfig, logger) {
 
       // Detect session reset - flush memory but keep current messages
       if (isSessionResetPrompt(query)) {
-        log.info(`[evermemos] assemble: session reset detected, keeping current messages`);
+        log.info(`[everos] assemble: session reset detected, keeping current messages`);
         state.pendingFlush = true;
         // Return original messages without memory injection
         // The reset intent is captured in the query itself
@@ -313,14 +334,14 @@ function createContextEngineInstance(pluginConfig, logger) {
         const params = {
           query,
           user_id: cfg.userId,
-          group_ids: cfg.groupId ? [cfg.groupId] : undefined,
+          group_id: cfg.groupId || undefined,
           memory_types: cfg.memoryTypes,
           retrieve_method: cfg.retrieveMethod,
-          top_k,
+          top_k: topK,
         };
 
-        const result = await searchMemories(cfg, params);
-        const parsed = parseSearchResponse(result);
+        const result = await searchMemories(cfg, params, log);
+        const parsed = parseSearchResponse(result) || { episodic: [], traits: [], case: null, skill: null };
 
         const memoryCount =
           (parsed.episodic?.length || 0) +
@@ -340,26 +361,90 @@ function createContextEngineInstance(pluginConfig, logger) {
           _memory: true,
         };
 
-        log.info(`[evermemos] assemble: session=${sessionKey}, retrieved ${memoryCount} memories`);
+        log.info(`[everos] assemble: session=${sessionKey}, retrieved ${memoryCount} memories`);
 
         // Return memory message + existing messages
         return {
           messages: [memoryMessage, ...messages],
-          estimatedTokens: Math.floor((memoryText.length + JSON.stringify(messages).length) / 3),
+          estimatedTokens: Math.floor(memoryText.length / 4),
         };
       } catch (err) {
-        log.warn(`[evermemos] assemble: ${err.message}`);
+        log.warn(`[everos] assemble: ${err.message}`);
         return { messages, estimatedTokens: 0 };
       }
     },
 
+    async prepareSubagentSpawn({ sessionKey, subagentId, prompt, subagentType }) {
+      if (!sessionState.has(sessionKey)) {
+        sessionState.set(sessionKey, {
+          turnCount: 0,
+          lastAssembleTime: 0,
+          lastActiveTime: Date.now(),
+          pendingFlush: false,
+        });
+      }
+
+      const state = sessionState.get(sessionKey);
+      subagentTracker.register(subagentId, {
+        subagentType,
+        parentTurnCount: state.turnCount,
+      });
+
+      try {
+        const query = toText(prompt);
+        const prependContext = query ? await assembler.assembleForSubagent(query) : "";
+        return {
+          prependContext,
+          metadata: {
+            subagentId,
+            parentTurnCount: state.turnCount,
+          },
+        };
+      } catch (err) {
+        log.warn(`[everos] prepareSubagentSpawn: ${err.message}`);
+        return {
+          prependContext: "",
+          metadata: {
+            subagentId,
+            parentTurnCount: state.turnCount,
+          },
+        };
+      }
+    },
+
+    async onSubagentEnded({ subagentId, messages, success }) {
+      subagentTracker.unregister(subagentId);
+
+      if (!success || !messages?.length) {
+        return;
+      }
+
+      try {
+        const collected = collectMessages(messages);
+        if (!collected.length) {
+          return;
+        }
+
+        await saveMemories(cfg, {
+          userId: cfg.userId,
+          groupId: cfg.groupId,
+          messages: collected,
+          flush: false,
+        }, log);
+
+        log.info(`[everos] onSubagentEnded: saved ${collected.length} messages from subagent ${subagentId}`);
+      } catch (err) {
+        log.warn(`[everos] onSubagentEnded: ${err.message}`);
+      }
+    },
+
     async compact({ sessionId, sessionKey, tokenBudget, currentTokenCount }) {
       const state = sessionState.get(sessionKey);
       if (!state) {
         return { ok: true, compacted: false, reason: "no session state" };
       }
 
-      log.info(`[evermemos] compact: session=${sessionKey}, tokens=${currentTokenCount}, budget=${tokenBudget}`);
+      log.info(`[everos] compact: session=${sessionKey}, tokens=${currentTokenCount}, budget=${tokenBudget}`);
 
       // Simple compaction strategy: if over 80% of budget, recommend compaction
       const threshold = tokenBudget ? tokenBudget * 0.8 : 8000;
@@ -374,9 +459,15 @@ function createContextEngineInstance(pluginConfig, logger) {
       return { ok: true, compacted: false, reason: "within threshold" };
     },
 
-    async dispose() {
-      // Clean up session states
-      sessionState.clear();
+    async dispose({ sessionKey } = {}) {
+      if (sessionKey && sessionState.has(sessionKey)) {
+        sessionState.delete(sessionKey);
+        log.info(`[everos] dispose: cleared state for ${sessionKey}`);
+      } else if (!sessionKey) {
+        // No sessionKey = global shutdown; clear all sessions to avoid leaks
+        sessionState.clear();
+        log.info("[everos] dispose: cleared all session states");
+      }
     },
   };
 }
@@ -388,7 +479,7 @@ function createContextEngineInstance(pluginConfig, logger) {
 export default function register(api) {
   const log = api.logger || { info: (...a) => console.log(...a), warn: (...a) => console.warn(...a) };
 
-  log.info(`[evermemos] Registering EverMemOS ContextEngine plugin`);
+  log.info(`[everos] Registering EverOS OpenClaw Plugin`);
 
   // Register the ContextEngine factory
   api.registerContextEngine(PLUGIN_ID, (pluginConfig) => {

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "@evermind-ai/openclaw-plugin",
-  "name": "EverMemOS ContextEngine",
-  "description": "Full-lifecycle memory management with EverMemOS - supports bootstrap, assemble, afterTurn, compact, and subagent tracking",
-  "version": "1.0.0",
+  "name": "EverOS OpenClaw Plugin",
+  "description": "Full-lifecycle memory management for OpenClaw through the EverOS backend, powered by EverMemOS",
+  "version": "1.3.0",
   "kind": "context-engine",
   "contextEngine": true,
   "main": "./index.js",
@@ -12,18 +12,18 @@
     "properties": {
       "baseUrl": {
         "type": "string",
-        "description": "EverMemOS server base URL",
+        "description": "EverOS backend base URL",
         "default": "http://localhost:1995"
       },
       "userId": {
         "type": "string",
         "description": "Identity used for memory ownership and as message sender",
-        "default": "evermemos-user"
+        "default": "everos-user"
       },
       "groupId": {
         "type": "string",
         "description": "Group id for shared memory",
-        "default": "evermemos-group"
+        "default": "everos-group"
       },
       "topK": {
         "type": "integer",
@@ -32,7 +32,7 @@
       },
       "memoryTypes": {
         "type": "array",
-        "description": "EverMemOS memory types to search",
+        "description": "EverOS memory types to search",
         "items": {
           "type": "string",
           "enum": ["episodic_memory", "profile", "agent_skill", "agent_case"]
@@ -41,7 +41,7 @@
       },
       "retrieveMethod": {
         "type": "string",
-        "description": "Retrieval strategy used by EverMemOS",
+        "description": "Retrieval strategy used by the EverOS backend",
         "enum": ["keyword", "vector", "hybrid", "rrf", "agentic"],
         "default": "hybrid"
       }

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@evermind-ai/openclaw-plugin",
-  "version": "1.1.0",
-  "description": "EverMemOS ContextEngine integration for OpenClaw 3.8+",
+  "version": "1.3.0",
+  "description": "EverOS OpenClaw Plugin for OpenClaw 3.8+",
   "type": "module",
   "main": "./index.js",
+  "bin": {
+    "everos-install": "./bin/install.js"
+  },
   "exports": {
     ".": "./index.js"
   },
@@ -12,6 +15,8 @@
     "openclaw.plugin.json",
     "README.md",
     "README.zh.md",
+    "SKILL.md",
+    "bin/",
     "src/"
   ],
   "keywords": [

package/src/assembler.js

@@ -42,16 +42,16 @@ export class ContextAssembler {
     const params = {
       query,
       user_id: this.cfg.userId,
-      group_ids: this.cfg.groupId ? [this.cfg.groupId] : undefined,
+      group_id: this.cfg.groupId || undefined,
       memory_types: this.cfg.memoryTypes,
       retrieve_method: this.cfg.retrieveMethod,
       top_k: topK,
     };
 
     /** @type {any} */
-    const result = await searchMemories(this.cfg, params);
+    const result = await searchMemories(this.cfg, params, this.log);
     /** @type {ParsedMemoryResponse} */
-    const parsed = parseSearchResponse(result);
+    const parsed = parseSearchResponse(result) || { episodic: [], traits: [], case: null, skill: null };
 
     // Count total memories
     const memoryCount =
@@ -79,16 +79,16 @@ export class ContextAssembler {
     const params = {
       query,
       user_id: this.cfg.userId,
-      group_ids: this.cfg.groupId ? [this.cfg.groupId] : undefined,
+      group_id: this.cfg.groupId || undefined,
       memory_types: this.cfg.memoryTypes,
       retrieve_method: this.cfg.retrieveMethod,
       top_k: topK,
     };
 
     /** @type {any} */
-    const result = await searchMemories(this.cfg, params);
+    const result = await searchMemories(this.cfg, params, this.log);
     /** @type {ParsedMemoryResponse} */
-    const parsed = parseSearchResponse(result);
+    const parsed = parseSearchResponse(result) || { episodic: [], traits: [], case: null, skill: null };
 
     // Use no code block for subagents (cleaner format)
     return buildMemoryPrompt(parsed, { wrapInCodeBlock: false });

package/src/config.js

@@ -5,8 +5,8 @@ export const TIMEOUT_MS = 60000;
 export function resolveConfig(pc = {}) {
   return {
     serverUrl: (pc.baseUrl || DEFAULT_URL).replace(/\/*$/, ""),
-    userId: pc.userId || "evermemos-user",
-    groupId: pc.groupId || "evermemos-group",
+    userId: pc.userId || "everos-user",
+    groupId: pc.groupId || "everos-group",
     topK: pc.topK ?? 5,
     memoryTypes: pc.memoryTypes ?? ["episodic_memory", "profile", "agent_skill", "agent_case"],
     retrieveMethod: pc.retrieveMethod ?? "hybrid",

package/src/formatter.js

@@ -1,4 +1,4 @@
-export const CONTEXT_BOUNDARY = "user\u200b原\u200b始\u200bquery\u200b：\u200b\u200b\u200b\u200b";
+export const CONTEXT_BOUNDARY = "user\u200boriginal\u200bquery\u200b:\u200b\u200b\u200b\u200b";
 
 function timestampToLabel(ts) {
   if (ts == null || ts === "") return "";

package/src/http-client.js

@@ -39,7 +39,8 @@ export async function request(cfg, method, path, params) {
 
   try {
     return await send(url, method, headers, body, ms);
-  } catch {
+  } catch (err) {
+    console.warn(`[everos] first request failed, retrying: ${err.message}`);
     await sleep(150);
     return send(url, method, headers, body, ms);
   }

package/src/memory-api.js

@@ -1,6 +1,8 @@
 import { request } from "./http-client.js";
 
-export async function searchMemories(cfg, params) {
+const noop = { info() {}, warn() {} };
+
+export async function searchMemories(cfg, params, log = noop) {
   const { memory_types, ...baseParams } = params;
 
   const episodicTypes = (memory_types ?? []).filter((t) => t === "episodic_memory" || t === "profile");
@@ -13,9 +15,9 @@ export async function searchMemories(cfg, params) {
   const results = await Promise.all(
     searches.map(async ({ label, types }) => {
       const p = { ...baseParams, memory_types: types };
-      console.log("[memory-api] GET /api/v1/memories/search", label, JSON.stringify(p));
+      log.info(`[everos] GET /api/v1/memories/search ${label}`, JSON.stringify(p));
       const r = await request(cfg, "GET", "/api/v1/memories/search", p);
-      console.log("[memory-api] GET response", label, JSON.stringify(r));
+      log.info(`[everos] GET response ${label}`, JSON.stringify(r));
       return r;
     }),
   );
@@ -35,15 +37,16 @@ export async function searchMemories(cfg, params) {
   return merged;
 }
 
-export async function saveMemories(cfg, { userId, groupId, messages = [], flush = false }) {
+export async function saveMemories(cfg, { userId, groupId, messages = [], flush = false }, log = noop) {
   if (!messages.length) return;
   const stamp = Date.now();
-  for (let i = 0; i < messages.length; i++) {
-    const { role = "user", content = "", tool_calls, tool_call_id } = messages[i];
+
+  const payloads = messages.map((msg, i) => {
+    const { role = "user", content = "", tool_calls, tool_call_id } = msg;
     const sender = role === "assistant" ? role : (role === "tool" ? "tool" : userId);
     const isLast = i === messages.length - 1;
 
-    const payload = {
+    return {
       message_id: `em_${stamp}_${i}`,
       create_time: new Date().toISOString(),
       role,
@@ -58,20 +61,13 @@ export async function saveMemories(cfg, { userId, groupId, messages = [], flush
       ...(tool_call_id && { tool_call_id }),
       ...(flush && isLast && { flush: true }),
     };
-    console.log("[memory-api] POST /api/v1/memories", JSON.stringify(payload));
-    const result = await request(cfg, "POST", "/api/v1/memories", payload);
-    console.log("[memory-api] POST response", JSON.stringify(result));
-  }
-}
+  });
 
-export async function deleteMemories(cfg, { memoryId, userId, groupId }) {
-  const payload = {};
-  if (memoryId) payload.memory_id = memoryId;
-  if (userId) payload.user_id = userId;
-  if (groupId) payload.group_id = groupId;
-
-  console.log("[memory-api] DELETE /api/v1/memories", JSON.stringify(payload));
-  const result = await request(cfg, "DELETE", "/api/v1/memories", payload);
-  console.log("[memory-api] DELETE response", JSON.stringify(result));
-  return result;
+  await Promise.all(
+    payloads.map(async (payload) => {
+      log.info(`[everos] POST /api/v1/memories`, JSON.stringify(payload));
+      const result = await request(cfg, "POST", "/api/v1/memories", payload);
+      log.info(`[everos] POST response`, JSON.stringify(result));
+    }),
+  );
 }

package/src/subagent.js

@@ -38,7 +38,7 @@ export class SubagentTracker {
       startTime: Date.now(),
       ...metadata,
     });
-    this.log(`[evermemos] subagent tracker: registered ${subagentId}`);
+    this.log.info(`[everos] subagent tracker: registered ${subagentId}`);
   }
 
   /**
@@ -49,7 +49,7 @@ export class SubagentTracker {
   unregister(subagentId) {
     const removed = this.activeSubagents.delete(subagentId);
     if (removed) {
-      this.log(`[evermemos] subagent tracker: unregistered ${subagentId}`);
+      this.log.info(`[everos] subagent tracker: unregistered ${subagentId}`);
     }
     return removed;
   }
@@ -108,7 +108,7 @@ export class SubagentTracker {
     }
 
     if (stale.length > 0) {
-      this.log(`[evermemos] subagent tracker: cleaned up ${stale.length} stale subagents`);
+      this.log.info(`[everos] subagent tracker: cleaned up ${stale.length} stale subagents`);
     }
 
     return stale;