@memorilabs/openclaw-memori 0.0.14 → 0.0.16

package/dist/index.js

@@ -24,9 +24,10 @@ const memoriPlugin = {
         }
         logger.info(`\n=== ${PLUGIN_CONFIG.LOG_PREFIX} INITIALIZING PLUGIN ===`);
         logger.info(`${PLUGIN_CONFIG.LOG_PREFIX} Tracking Entity ID: ${config.entityId}`);
-        if (skillsContent) {
-            api.on('before_prompt_build', () => ({ appendSystemContext: skillsContent }));
-        }
+        const configContext = `Memori plugin configuration: projectId="${config.projectId}", entityId="${config.entityId}"`;
+        api.on('before_prompt_build', () => ({
+            appendSystemContext: [skillsContent, configContext].filter(Boolean).join('\n\n'),
+        }));
         api.on('agent_end', (event, ctx) => handleAugmentation(event, ctx, config, logger));
         registerAuthenticatedTools({ api, config, logger });
     },

package/dist/tools/index.js

@@ -3,6 +3,7 @@ import { createMemoriQuotaTool } from './memori-quota.js';
 import { createMemoriRecallTool } from './memori-recall.js';
 import { createMemoriRecallSummaryTool } from './memori-recall-summary.js';
 import { createMemoriFeedbackTool } from './memori-feedback.js';
+import { createMemoriCompactionTool } from './memori-compaction.js';
 export function registerUtilityTools(deps) {
     deps.api.registerTool(createMemoriSignupTool(deps));
 }
@@ -11,4 +12,5 @@ export function registerAuthenticatedTools(deps) {
     deps.api.registerTool(createMemoriRecallSummaryTool(deps));
     deps.api.registerTool(createMemoriFeedbackTool(deps));
     deps.api.registerTool(createMemoriQuotaTool(deps));
+    deps.api.registerTool(createMemoriCompactionTool(deps));
 }

package/dist/tools/memori-compaction.d.ts

@@ -0,0 +1,35 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriCompactionTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        required: string[];
+        properties: {
+            projectId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            numMessages: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+    execute(_toolCallId: string, params: {
+        projectId?: string;
+        sessionId?: string;
+        numMessages?: number;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-compaction.js

@@ -0,0 +1,119 @@
+import { QuotaExceededError } from '@memorilabs/memori';
+import { createRecallClient } from '../utils/memori-client.js';
+export function createMemoriCompactionTool(deps) {
+    const { config, logger } = deps;
+    return {
+        name: 'memori_compaction',
+        label: 'Compact Agent Memory',
+        description: `Use this tool to restore working state after context compaction. Returns a structured snapshot of the agent's long-term memory to enable continuation without replaying the full prior session.
+
+WHEN TO USE:
+- The agent resumes after compaction
+- A long-running workflow has lost conversational detail
+- The agent needs to continue operational work without replaying the full prior session
+- The agent needs durable state, standing instructions, environment details, open loops, or the next expected action
+
+WHEN NOT TO USE:
+- Do NOT call this on every turn — it costs 100 memory credits per execution
+- Do NOT use this for targeted memory search — use memori_recall for that instead
+- Do NOT call this if the agent is starting a brand-new task with no prior context
+- Compaction is not a replacement for precise memory retrieval
+
+The compaction result returns:
+- **environment**: environment variable context captured during prior sessions
+- **standing_orders**: persistent instructions the agent must continue to follow
+- **state**: active_tasks (work in progress), open_loops (unresolved threads), pending_results
+- **timeline**: a chronological narrative of agent activity (when available)
+- **workspace_changes**: recent file or system changes made by the agent
+- **continuation**: last_action (what the agent did last) and next_expected_action (what it should do next)
+- **messages**: a tail of recent conversation messages for continuity
+
+HOW TO USE THE RESULT:
+Treat the compaction result as the agent's resume state — use it to understand what environment the agent was operating in, which standing orders must continue to be followed, which tasks are active, what happened across the prior session window, and what the agent should do next.
+
+The compaction result should guide continuation, not override explicit user instructions. Before acting on operational details, verify any state that may have changed since compaction.
+
+Pay special attention to:
+- Standing orders
+- Hard constraints
+- Alerting rules
+- Expected response formats
+- Open loops
+- Staleness warnings
+- Next expected action
+
+If the compaction result contains a required output format, follow it exactly unless the user gives a newer instruction.`,
+        parameters: {
+            type: 'object',
+            required: ['projectId'],
+            properties: {
+                projectId: {
+                    type: 'string',
+                    description: 'The project to compact. REQUIRED — always pass the configured project ID. This scopes the compaction to the correct workspace.',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Scope the compaction to a specific agent session. Leave empty to compact across all sessions in the project. Cannot be used without projectId.',
+                },
+                numMessages: {
+                    type: 'number',
+                    description: 'Number of recent conversation messages to include in the result. Defaults to 5. Increase (up to ~20) only if the user explicitly asks for more conversation context.',
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            try {
+                // Config projectId is the fallback; an explicit LLM-provided value overrides it.
+                const finalParams = { projectId: config.projectId, ...params };
+                if (!finalParams.projectId) {
+                    const errorResult = { error: 'projectId is required but was not configured' };
+                    logger.warn(`memori_compaction rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                if (finalParams.sessionId && !finalParams.projectId) {
+                    const errorResult = { error: 'sessionId cannot be provided without projectId' };
+                    logger.warn(`memori_compaction rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.info(`memori_compaction params: ${JSON.stringify(finalParams)}`);
+                const client = createRecallClient(config.apiKey, config.entityId);
+                const result = await client.agentCompaction(finalParams);
+                if (result === null) {
+                    const errorResult = { error: 'Compaction failed' };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                if (e instanceof QuotaExceededError) {
+                    logger.warn('memori_compaction quota exceeded');
+                    const errorResult = {
+                        error: 'Quota exceeded: compaction costs 100 memory credits and your organization has exhausted its Recall Execution quota.',
+                    };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.warn(`memori_compaction failed: ${String(e)}`);
+                const errorResult = { error: 'Compaction failed' };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.14";
+export declare const SDK_VERSION = "0.0.16";

package/dist/version.js

@@ -1 +1 @@
-export const SDK_VERSION = '0.0.14';
+export const SDK_VERSION = '0.0.16';

package/openclaw.plugin.json

@@ -9,6 +9,7 @@
     "tools": [
       "memori_recall",
       "memori_recall_summary",
+      "memori_compaction",
       "memori_feedback",
       "memori_signup",
       "memori_quota"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorilabs/openclaw-memori",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Official MemoriLabs.ai long-term memory plugin for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",
@@ -67,6 +67,6 @@
     "@hono/node-server": "^1.19.10"
   },
   "dependencies": {
-    "@memorilabs/memori": "0.1.12-beta"
+    "@memorilabs/memori": "^0.1.23-beta"
   }
 }

package/skills/clawhub/SKILL.md

@@ -60,7 +60,8 @@ To maintain an efficient context window, Memori equips the agent with specific t
 
 1. **`memori_recall`**: Searches the structured memory graph for specific facts, constraints, and prior decisions.
 2. **`memori_recall_summary`**: Retrieves structured daily briefs and rolling summaries of prior sessions.
-3. **`memori_feedback`**: Reports on memory quality to improve extraction accuracy.
+3. **`memori_compaction`**: Retrieves structured post-compaction brief to continue task without interruption.
+4. **`memori_feedback`**: Reports on memory quality to improve extraction accuracy.
 
 ## Installation
 

package/skills/memori/SKILL.md

@@ -157,6 +157,84 @@ Treat this as the working state of the system.
 
 ---
 
+## Post-compaction brief behavior
+
+Post-compaction briefs are used to restore working state after context compaction.
+
+Use them when:
+
+- The agent resumes after compaction
+- A long-running workflow has lost conversational detail
+- The agent needs to continue operational work without replaying the full prior session
+- The agent needs durable state, standing instructions, environment details, open loops, or the next expected action
+
+Post-compaction briefs are not a replacement for precise memory retrieval.
+
+### Use:
+
+memori_compaction
+
+Supported parameters (post-compaction briefs)
+
+projectId (required)
+sessionId (optional)
+
+Post-compaction briefs do not support source or signal.
+
+### Default behavior (post-compaction briefs)
+
+Retrieve the most recent relevant post-compaction brief for the project or session.
+
+Expected post-compaction brief structure
+
+- Meta
+- Environment
+- Standing orders
+- State
+- Active tasks
+- Open loops
+- Pending results
+- Timeline
+- Workspace changes
+- Continuation
+- Last action
+- Next expected action
+
+### How to use a post-compaction brief
+
+Treat the post-compaction brief as the agent's resume state.
+
+Use it to understand:
+
+- What environment the agent was operating in
+- Which standing orders must continue to be followed
+- Which tasks are active
+- Which issues remain unresolved
+- What happened across the prior session window
+- What files, workspace state, or external systems may have changed
+- What the agent did last
+- What the agent should do next
+
+### Important behavior
+
+The post-compaction brief should guide continuation, not override explicit user instructions.
+
+Before acting on operational details, verify any state that may have changed since compaction.
+
+Pay special attention to:
+
+- Standing orders
+- Hard constraints
+- Alerting rules
+- Expected response formats
+- Open loops
+- Staleness warnings
+- Next expected action
+
+If the post-compaction brief contains a required output format, follow it exactly unless the user gives a newer instruction.
+
+---
+
 ## Safety and correctness
 
 - Do not invent memory