npm - @memoryrelay/plugin-memoryrelay-ai - Versions diffs - 0.6.0 → 0.7.0 - Mend

@memoryrelay/plugin-memoryrelay-ai 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md CHANGED Viewed

@@ -1,634 +1,288 @@
-# OpenClaw Plugin for MemoryRelay AI
+# MemoryRelay AI - OpenClaw Memory Plugin
-[![npm version](https://img.shields.io/npm/v/@memoryrelay/plugin-memoryrelay-ai)](https://www.npmjs.com/package/@memoryrelay/plugin-memoryrelay-ai)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/@memoryrelay/plugin-memoryrelay-ai.svg)](https://www.npmjs.com/package/@memoryrelay/plugin-memoryrelay-ai)
+[![OpenClaw Compatible](https://img.shields.io/badge/OpenClaw-2026.2.26+-blue.svg)](https://openclaw.ai)
-Long-term memory plugin for OpenClaw agents using [MemoryRelay API](https://api.memoryrelay.net).
+AI-powered long-term memory for OpenClaw agents. Gives your AI assistant persistent memory, project context, architectural decision records, reusable patterns, and session tracking across conversations.
 ## Features
-- 🧠 **Semantic Search** — Natural language memory retrieval with vector embeddings
-- 🔄 **Auto-Recall** — Automatically inject relevant memories into agent context
-- 📝 **Auto-Capture** — Intelligently detect and store important information
-- 🤖 **Multi-Agent** — Isolated memory namespaces per agent
-- 🛠️ **CLI Tools** — Manage memories via `openclaw memoryrelay` commands
-- 🔌 **Tool Integration** — Three memory tools for AI agents
-- 🔗 **Works Alongside Built-in Memory** — Extends OpenClaw's local memory with cloud-backed persistence
+- **39 Tools** covering memories, entities, sessions, decisions, patterns, and projects
+- **Semantic Search** - Vector-based retrieval finds relevant context by meaning
+- **Auto-Recall** - Automatically injects relevant memories into agent context
+- **Project-First Workflow** - Agents receive workflow instructions to start with project context
+- **Decision Records** - Track and check architectural decisions before making new ones
+- **Pattern Library** - Create, search, and adopt reusable conventions across projects
+- **Session Tracking** - Track work sessions with summaries for continuity
+- **Tool Group Filtering** - Enable only the tool groups you need
 ## Installation
-```bash
-openclaw plugins install @memoryrelay/plugin-memoryrelay-ai
-```
-Or via npm:
-```bash
-npm install -g @memoryrelay/plugin-memoryrelay-ai
-```
+### Requirements
-## Quick Start
+- OpenClaw >= 2026.2.26
+- Node.js >= 18.0.0
+- MemoryRelay API key ([get one at memoryrelay.ai](https://memoryrelay.ai))
-### 1. Install the plugin
+### Install via OpenClaw CLI
 ```bash
 openclaw plugins install @memoryrelay/plugin-memoryrelay-ai
 ```
-### 2. Configure API credentials
+### Configuration
-**Option A: Config file** (recommended)
 ```bash
-cat ~/.openclaw/openclaw.json | jq '.plugins.entries."plugin-memoryrelay-ai".config = {
-  "apiKey": "YOUR_API_KEY",
-  "agentId": "YOUR_AGENT_ID",
+openclaw config set plugins.entries.plugin-memoryrelay-ai.config '{
+  "apiKey": "mem_prod_your_key_here",
+  "agentId": "your-agent-name",
+  "defaultProject": "my-project",
   "autoRecall": true,
   "autoCapture": false
-}' > /tmp/config.json && \
-mv /tmp/config.json ~/.openclaw/openclaw.json && \
-chmod 600 ~/.openclaw/openclaw.json
-```
+}'
-**Option B: Environment variables**
-```bash
-export MEMORYRELAY_API_KEY="YOUR_API_KEY"
-export MEMORYRELAY_AGENT_ID="YOUR_AGENT_ID"
-```
+# Or use environment variables
+export MEMORYRELAY_API_KEY="mem_prod_your_key_here"
+export MEMORYRELAY_AGENT_ID="your-agent-name"
+export MEMORYRELAY_DEFAULT_PROJECT="my-project"
-### 3. Restart the gateway
-```bash
+# Restart gateway
 openclaw gateway restart
 ```
-### 4. Verify it's working
-```bash
-# Test memory storage
-openclaw agents <your-agent> --one-shot "Store a test memory: Plugin verification successful"
-# Search for it
-openclaw memoryrelay search "plugin verification"
-# Check plugin status
-openclaw plugins info plugin-memoryrelay-ai
-# Should show: Status: loaded
-# Check logs
-journalctl -u openclaw-gateway --since '1 minute ago' | grep memory-memoryrelay
-# Should show: "memory-memoryrelay: connected to https://api.memoryrelay.net"
-```
-**Note**: `openclaw status` may show "unavailable" due to an OpenClaw display bug (see [Known Limitations](#known-limitations)). This is cosmetic only - if the plugin shows "loaded" and logs show "connected", the plugin is working correctly.
-### 1. Get API Key
-Sign up at [memoryrelay.io](https://memoryrelay.io) or use the public demo API.
-### 2. Configure
-Add to your `~/.openclaw/openclaw.json`:
-```json
-{
-  "plugins": {
-    "slots": {
-      "memory": "plugin-memoryrelay-ai"
-    },
-    "entries": {
-      "plugin-memoryrelay-ai": {
-        "enabled": true,
-        "config": {
-          "apiKey": "mem_prod_...",
-          "agentId": "my-agent",
-          "apiUrl": "https://api.memoryrelay.net",
-          "autoRecall": true,
-          "autoCapture": false
-        }
-      }
-    }
-  }
-}
-```
-### 3. Restart Gateway
-```bash
-openclaw gateway restart
-```
-### 4. Test Connection
-```bash
-openclaw memoryrelay status
-```
-## Usage
-### AI Agent Tools
-The plugin provides three tools your AI agent can use:
-#### `memory_store`
-Store a new memory with optional metadata.
-> **Note**: The `agent_id` parameter is automatically injected from your config. You don't need to include it.
-**Parameters:**
-- `content` (string, required) - Memory content (1-50,000 characters)
-- `metadata` (object, optional) - Key-value metadata (max 10KB when serialized)
-**Example:**
-```typescript
-memory_store({
-  content: "User prefers concise bullet-point responses",
-  metadata: { category: "preferences", importance: "high" }
-})
-```
-**Returns:** Memory object with `id`, `content`, `agent_id`, `metadata`, `created_at`, `updated_at`
+## Configuration Options
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | string | — | MemoryRelay API key (or `MEMORYRELAY_API_KEY` env var) |
+| `agentId` | string | — | Unique agent identifier (or `MEMORYRELAY_AGENT_ID` env var, or agent name) |
+| `apiUrl` | string | `https://api.memoryrelay.net` | API endpoint (or `MEMORYRELAY_API_URL` env var) |
+| `defaultProject` | string | — | Default project slug applied to sessions, decisions, and memories |
+| `enabledTools` | string | `all` | Comma-separated tool groups: `memory`, `entity`, `agent`, `session`, `decision`, `pattern`, `project`, `health` |
+| `autoRecall` | boolean | `true` | Inject relevant memories into context each turn |
+| `autoCapture` | boolean | `false` | Auto-capture important information from conversations |
+| `recallLimit` | number | `5` | Max memories to inject per turn (1-20) |
+| `recallThreshold` | number | `0.3` | Minimum similarity score for recall (0-1) |
+| `excludeChannels` | string[] | `[]` | Channel IDs to skip auto-recall |
+## Agent Workflow
+The plugin injects workflow instructions into every agent conversation via the `before_agent_start` hook, guiding the AI to follow a project-first approach:
+1. **Load context** — `project_context(project)` loads hot-tier memories, active decisions, and adopted patterns
+2. **Start session** — `session_start(title, project)` begins tracking work
+3. **Check decisions** — `decision_check(query, project)` before architectural choices
+4. **Find patterns** — `pattern_search(query)` to find established conventions
+5. **Store findings** — `memory_store(content)` for important information
+6. **Record decisions** — `decision_record(title, rationale)` for significant choices
+7. **End session** — `session_end(session_id, summary)` with accomplishment summary
+For new projects, the agent is guided to call `project_register()` first.
+## Tool Reference
+### Memory Tools (9 tools) — group: `memory`
+| Tool | Description |
+|------|-------------|
+| `memory_store` | Store a memory with optional project scoping, deduplication, importance, and tier |
+| `memory_recall` | Semantic search across memories with project/tier/importance filters |
+| `memory_forget` | Delete a memory by ID or search query |
+| `memory_list` | List recent memories with pagination |
+| `memory_get` | Retrieve a specific memory by ID |
+| `memory_update` | Update content of an existing memory |
+| `memory_batch_store` | Store multiple memories in one call |
+| `memory_context` | Build a token-budget-aware context window from relevant memories |
+| `memory_promote` | Update a memory's importance score and tier |
+### Entity Tools (4 tools) — group: `entity`
+| Tool | Description |
+|------|-------------|
+| `entity_create` | Create a knowledge graph node (person, place, org, project, concept) |
+| `entity_link` | Link an entity to a memory with a relationship label |
+| `entity_list` | List entities with pagination |
+| `entity_graph` | Explore an entity's neighborhood in the knowledge graph |
+### Agent Tools (3 tools) — group: `agent`
+| Tool | Description |
+|------|-------------|
+| `agent_list` | List available agents |
+| `agent_create` | Create a new agent (memory namespace) |
+| `agent_get` | Get agent details by ID |
+### Session Tools (4 tools) — group: `session`
+| Tool | Description |
+|------|-------------|
+| `session_start` | Start a work session with title and project |
+| `session_end` | End a session with a summary |
+| `session_recall` | Get session details and timeline |
+| `session_list` | List sessions filtered by project or status |
+### Decision Tools (4 tools) — group: `decision`
+| Tool | Description |
+|------|-------------|
+| `decision_record` | Record an architectural decision with rationale and alternatives |
+| `decision_list` | List decisions filtered by project, status, or tags |
+| `decision_supersede` | Replace a decision with a new one (old is marked superseded) |
+| `decision_check` | Semantic search for existing decisions before making new ones |
+### Pattern Tools (4 tools) — group: `pattern`
+| Tool | Description |
+|------|-------------|
+| `pattern_create` | Create a reusable convention with example code |
+| `pattern_search` | Semantic search for established patterns |
+| `pattern_adopt` | Adopt an existing pattern for a project |
+| `pattern_suggest` | Get pattern suggestions based on project stack |
+### Project Tools (10 tools) — group: `project`
+| Tool | Description |
+|------|-------------|
+| `project_register` | Register a project with slug, name, stack, and repo URL |
+| `project_list` | List all registered projects |
+| `project_info` | Get project details |
+| `project_add_relationship` | Add relationship between projects (depends_on, extends, etc.) |
+| `project_dependencies` | List projects that a project depends on |
+| `project_dependents` | List projects that depend on a project |
+| `project_related` | List all related projects (any direction) |
+| `project_impact` | Analyze blast radius of a proposed change |
+| `project_shared_patterns` | Find patterns shared between two projects |
+| `project_context` | Load full project context (memories, decisions, patterns, sessions) |
+### Health Tools (1 tool) — group: `health`
+| Tool | Description |
+|------|-------------|
+| `memory_health` | Check API connectivity and health status |
+## Tool Group Filtering
+Only enable the groups you need:
-**Rate Limit**: 30 requests per minute
-#### `memory_recall`
-Search memories using semantic similarity.
-**Parameters:**
-- `query` (string, required) - Natural language search query
-- `limit` (number, optional, default: 10) - Maximum results (1-50)
-- `threshold` (number, optional, default: 0.5) - Minimum similarity score (0-1)
-**Example:**
-```typescript
-memory_recall({
-  query: "user communication preferences",
-  limit: 5,
-  threshold: 0.7
-})
-```
-**Returns:** Array of search results with `memory` object and `score` (0-1):
 ```json
 {
-  "results": [
-    {
-      "memory": {
-        "id": "550e8400-...",
-        "content": "User prefers concise bullet-point responses",
-        "metadata": { "category": "preferences" },
-        "created_at": 1707649200
-      },
-      "score": 0.89
-    }
-  ]
+  "enabledTools": "memory,session,decision"
 }
 ```
-#### `memory_forget`
+This enables only the memory (9), session (4), and decision (4) tools — 17 tools instead of 39. Useful for reducing tool clutter when you don't need project graphs or pattern management.
-Delete a memory by ID or search query.
+Available groups: `memory`, `entity`, `agent`, `session`, `decision`, `pattern`, `project`, `health`
-**Parameters:**
-- `memoryId` (string, optional) - Memory UUID to delete
-- `query` (string, optional) - Search query (shows candidates if multiple matches)
+Set to `all` (or omit) to enable everything.
-**Examples:**
-```typescript
-// By ID
-memory_forget({ memoryId: "550e8400-..." })
-// By query (interactive if multiple matches)
-memory_forget({ query: "outdated preference" })
-```
+## Auto-Recall
-**Returns:** Success confirmation
+When `autoRecall: true`, relevant memories are automatically injected into agent context each turn:
-### Status Monitoring
-Check plugin status directly (don't rely on `openclaw status` - see [Known Limitations](#known-limitations)):
-```bash
-# Check plugin loaded
-openclaw plugins info plugin-memoryrelay-ai
-# Check connection via logs
-journalctl -u openclaw-gateway -f | grep memory-memoryrelay
-# Test tools directly
-openclaw memoryrelay search "test query"
-```
-### CLI Commands
-```bash
-# Check status
-openclaw memoryrelay status
-# List recent memories
-openclaw memoryrelay list --limit 10
-# Search memories
-openclaw memoryrelay search "API configuration"
 ```
+User: "How should I handle authentication in this project?"
-### Auto-Recall
-When `autoRecall: true`, relevant memories are automatically injected before each agent turn:
-```xml
-<relevant-memories>
-The following memories from MemoryRelay may be relevant:
-- User prefers concise responses
-- Project uses TypeScript with strict mode
-- ...
-</relevant-memories>
+[Plugin searches memories for "authentication"]
+[Injects workflow instructions + top 5 relevant memories into context]
+Agent uses past decisions and patterns to inform its response
 ```
-**Config:**
-- `recallLimit`: Max memories (default: 5)
-- `recallThreshold`: Min similarity score (default: 0.3)
-### Auto-Capture
-When `autoCapture: true`, the plugin detects and stores important information automatically.
-**Patterns detected:**
-- "remember that..."
-- "my name/email/phone is..."
-- "important: ..."
-- API keys, SSH configs, preferences
-**Note:** Disabled by default for privacy.
-## Configuration
+## Channel Exclusions
-| Field | Type | Required | Default | Description |
-|-------|------|----------|---------|-------------|
-| `apiKey` | string | ✅ | - | MemoryRelay API key |
-| `agentId` | string | ✅ | - | Unique agent identifier |
-| `apiUrl` | string | No | `api.memoryrelay.net` | API endpoint |
-| `autoRecall` | boolean | No | `true` | Auto-inject memories |
-| `autoCapture` | boolean | No | `false` | Auto-store information |
-| `recallLimit` | number | No | `5` | Max memories to inject |
-| `recallThreshold` | number | No | `0.3` | Similarity threshold (0-1) |
+Exclude specific channels from auto-recall and workflow injection:
-### Environment Variables
-Alternatively, use environment variables:
-```bash
-export MEMORYRELAY_API_KEY="mem_prod_..."
-export MEMORYRELAY_AGENT_ID="my-agent"
-```
-Then reference in config:
 ```json
 {
-  "apiKey": "${MEMORYRELAY_API_KEY}",
-  "agentId": "${MEMORYRELAY_AGENT_ID}"
+  "excludeChannels": [
+    "telegram:group_123456",
+    "discord:channel_789012"
+  ]
 }
 ```
-## Architecture
-MemoryRelay works **alongside** OpenClaw's built-in memory system (not as a replacement):
-**OpenClaw Built-in Memory** (local):
-- Workspace files (`MEMORY.md`, `memory/*.md`)
-- Fast local access, version control friendly
-- Tools: `memory_search`, `memory_get`
-- Scope: Per-agent, stays on disk
-**MemoryRelay Plugin** (cloud):
-- Cloud-backed API storage
-- Cross-agent sharing, persistent
-- Tools: `memory_store`, `memory_recall`, `memory_forget`
-- Scope: Shared across agents, 900+ memories
-**Both systems run together** - use built-in for local context, MemoryRelay for long-term cross-agent knowledge.
-```
-┌─────────────────────┐       ┌─────────────────────┐
-│ Built-in Memory     │       │ MemoryRelay Plugin  │
-│ (Local Files)       │       │ (Cloud API)         │
-├─────────────────────┤       ├─────────────────────┤
-│ memory_search       │       │ memory_store        │
-│ memory_get          │       │ memory_recall       │
-│                     │       │ memory_forget       │
-└──────────┬──────────┘       └──────────┬──────────┘
-           │                             │
-           └─────────────┬───────────────┘
-                         │
-                         ↓
-                ┌─────────────────┐
-                │  OpenClaw Agent │
-                └─────────────────┘
-```
-## Known Limitations
-### Status Display Issue
-**Symptom**: `openclaw status` shows "Memory: unavailable" even when plugin is working.
-**Root Cause**: OpenClaw's status command checks the built-in MemoryIndexManager, not plugin tools. This is an OpenClaw architecture limitation, not a bug in this plugin.
-**Impact**: Cosmetic only - all plugin functionality works perfectly:
-- ✅ memory_store, memory_recall, memory_forget tools work
-- ✅ AutoRecall and AutoCapture work
-- ✅ API connectivity works (921 memories stored)
-- ❌ Status display shows wrong system
-**Workaround**: Verify plugin functionality directly instead of relying on status:
+## CLI Commands
 ```bash
-# 1. Check plugin loaded
-openclaw plugins info plugin-memoryrelay-ai
-# Should show: Status: loaded
-# 2. Check logs for connection
-journalctl -u openclaw-gateway --since '1 minute ago' | grep memory-memoryrelay
-# Should show: "memory-memoryrelay: connected to https://api.memoryrelay.net"
-# 3. Test memory_store tool
-openclaw agents <your-agent> --one-shot "Store test: Plugin works"
-# 4. Test memory_recall tool
-openclaw memoryrelay search "plugin works"
-# 5. Check API directly
-curl -H "X-API-Key: YOUR_KEY" https://api.memoryrelay.net/v1/memories?agent_id=YOUR_AGENT&limit=1
+openclaw memoryrelay status   # Check connection and stats
+openclaw memoryrelay stats    # Show memory count
+openclaw memoryrelay list     # List recent memories
+openclaw memoryrelay search "query"  # Search memories
+openclaw memoryrelay delete <id>     # Delete a memory
+openclaw memoryrelay export          # Export all memories to JSON
 ```
-**Why This Happens**: OpenClaw has two separate memory systems:
-1. `memory.backend` (top-level, status checks this)
-2. `plugins.slots.memory` (plugin tools, status ignores this)
-Our plugin provides tools (#2), but status checks the backend (#1). Fixing this requires OpenClaw core changes to check plugin status when a memory slot is configured.
+## Privacy & Security
-**Upstream Issue**: Tracked in [openclaw/openclaw#TBD](https://github.com/openclaw/openclaw/issues) (pending)
+- **Cloud-Backed** — Memories stored on MemoryRelay servers (HTTPS-encrypted in transit)
+- **API Key Auth** — Bearer token authentication
+- **Agent Isolation** — Memories scoped per agent ID
+- **Channel Filtering** — Exclude sensitive channels from auto-recall
+- **No Auto-Capture by Default** — Manual storage gives you full control
+- **Never store secrets** — Do not store API keys, passwords, or tokens as memories. Use encrypted local files or secret managers instead.
 ## Troubleshooting
 ### Plugin Not Loading
 ```bash
-# Check plugin status
 openclaw plugins list | grep memoryrelay
-# View config validation
-openclaw doctor
-# Check logs
-journalctl -u openclaw-gateway -f
-```
-### Connection Failed
-```bash
-# Test API directly
-curl https://api.memoryrelay.net/v1/health
-# Check API key
-openclaw memoryrelay status
-```
-### No Memories Returned
-- Check `recallThreshold` (lower = more results)
-- Verify `agentId` matches your API agent
-- Try broader search queries
-## Security
-- API keys stored in `openclaw.json` (not committed to git)
-- Supports environment variable substitution
-- Auto-capture disabled by default (privacy)
-- No hardcoded credentials
-**Best Practices:**
-- Use environment variables in production
-- Never commit `openclaw.json` with real keys
-- Rotate API keys regularly
-- Review auto-captured memories periodically
-## Development
-### File Structure
-```
-openclaw-plugin/
-├── index.ts                  # Plugin implementation
-├── openclaw.plugin.json      # Plugin manifest
-├── package.json              # NPM metadata
-├── LICENSE                   # MIT license
-└── README.md                 # This file
+openclaw config get plugins.entries.plugin-memoryrelay-ai
+openclaw logs --tail 100 | grep memory
 ```
-### Testing
+### API Connection Issues
 ```bash
-# Install locally
-openclaw plugins install --link .
-# Test tools
-# (via agent conversation or CLI)
-# View logs
-tail -f ~/.openclaw/logs/gateway.log
+curl -H "Authorization: Bearer YOUR_API_KEY" \
+  https://api.memoryrelay.net/v1/health
 ```
-## Related Projects
-- **MemoryRelay API** — REST API backend (FastAPI + PostgreSQL)
-- **MCP Server** — [`memoryrelay-mcp-server`](https://www.npmjs.com/package/memoryrelay-mcp-server) for Claude Desktop
-- **Python SDK** — `memoryrelay` on PyPI (coming soon)
-## Contributing
-Contributions welcome! Please:
-1. Fork the repository
-2. Create a feature branch
-3. Add tests (if applicable)
-4. Update documentation
-5. Submit a pull request
-## Support
-- **Issues**: [GitHub Issues](https://github.com/memoryrelay/openclaw-plugin/issues)
-- **Docs**: [memoryrelay.io](https://memoryrelay.io)
-- **Discord**: [OpenClaw Community](https://discord.gg/clawd)
-## License
-MIT © 2026 MemoryRelay
----
 ## Changelog
-### v0.5.3 (2026-02-14) - Documentation Update
-**Clarifications:**
-- ✅ Documented that plugin works ALONGSIDE built-in memory (not as replacement)
-- ✅ Added "Known Limitations" section explaining status display issue
-- ✅ Provided verification steps for users (don't rely on `openclaw status`)
-- ✅ Clarified architecture: two memory systems working together
-- ✅ Explained Voyage comparison (embedding provider vs storage provider)
-**No Code Changes:**
-- Plugin functionality unchanged (already working perfectly)
-- Tools work: memory_store, memory_recall, memory_forget ✅
-- AutoRecall/AutoCapture work ✅
-- 921 memories stored in production ✅
-**Key Finding:**
-- Status shows "unavailable" because OpenClaw checks built-in MemoryIndexManager, not plugin tools
-- This is an OpenClaw architecture limitation requiring upstream fix
-- All plugin functionality verified working despite status display
-### v0.4.0 (2026-02-13) - Status Reporting
-**New Features:**
-- ✅ Status reporting via `memory.status` gateway RPC method
-- ✅ Plugin now reports "available" in `openclaw status` when API is reachable
-- ✅ Memory count reporting (via optional `/v1/stats` API endpoint)
-- ✅ Vector availability reporting for semantic search
-- ✅ Detailed status information: connected state, endpoint, agent ID, memory count
-**Fixes:**
-- ✅ Plugin no longer shows as "unavailable" in `openclaw status` when functional
-- ✅ Status accurately reflects API connection state
-**Technical Improvements:**
-- ✅ Extracted constants for maintainability (`DEFAULT_API_URL`, `VALID_HEALTH_STATUSES`)
-- ✅ Case-insensitive health status validation
-- ✅ Proper type safety with nullish coalescing operators
-- ✅ Graceful handling of missing stats endpoint (backwards compatible)
-**Backwards Compatibility:**
-- Fully compatible with older OpenClaw versions (uses optional chaining)
-- Gracefully handles missing `/v1/stats` endpoint
-### v0.3.0 (2026-02-13) - Better Installation UX
-**Improved Installation Experience:**
-- ✅ API key can now come from `MEMORYRELAY_API_KEY` env var
-- ✅ Agent ID can come from `MEMORYRELAY_AGENT_ID` env var or defaults to "default"
-- ✅ Clear error message with setup instructions when config is missing
-- ✅ Comprehensive installation guide in README
-- ✅ No more silent failures - helpful error messages
-**Breaking Change:**
-- Debug logging removed (replaced with helpful error messages)
-**Migration:**
-Works out of the box with env vars, or add config after install:
-```bash
-cat ~/.openclaw/openclaw.json | jq '.plugins.entries."plugin-memoryrelay-ai".config = {"apiKey": "YOUR_KEY", "agentId": "YOUR_AGENT"}' > /tmp/config.json && mv /tmp/config.json ~/.openclaw/openclaw.json
-```
-### v0.2.4 (2026-02-13)
-**Debug Logging:**
-- Added detailed logging to diagnose config loading issues
-- Logs pluginConfig type, keys, and specific missing fields
-- Helps identify why apiKey/agentId aren't being read
-- Better error messages for troubleshooting
-### v0.2.3 (2026-02-13)
-**Critical Fix:**
-- Fixed API endpoint paths - removed duplicate `/memories` segment
-- Changed `/v1/memories/memories` → `/v1/memories`
-- Changed `/v1/memories/memories/{id}` → `/v1/memories/{id}`
-- Fixed 405 Method Not Allowed errors
-- All CRUD operations now work correctly
+### v0.7.0 (2026-03-05)
-### v0.2.2 (2026-02-13)
+- **NEW**: 39 tools (up from 3) covering full MemoryRelay API surface
+- **NEW**: Session tracking — `session_start`, `session_end`, `session_recall`, `session_list`
+- **NEW**: Decision records — `decision_record`, `decision_list`, `decision_supersede`, `decision_check`
+- **NEW**: Pattern library — `pattern_create`, `pattern_search`, `pattern_adopt`, `pattern_suggest`
+- **NEW**: Project management — `project_register`, `project_list`, `project_info`, relationships, impact analysis, shared patterns, full context loading
+- **NEW**: Enhanced memory tools — project scoping, deduplication, importance scores, three-tier storage, batch store, context building, promotion
+- **NEW**: Agent workflow instructions injected via `before_agent_start` hook
+- **NEW**: Tool group filtering via `enabledTools` config
+- **NEW**: `defaultProject` config for automatic project scoping
+- **FIX**: Workflow instructions now injected regardless of autoRecall setting
-**Critical Fix:**
-- Fixed tool registration API - changed `inputSchema` to `parameters`
-- Fixed handler signature - changed `handler` to `execute` with `_id` parameter
-- Tools now register correctly with OpenClaw
-- Memory storage/recall/forget now functional
-- Plugin shows as "available" instead of "unavailable"
+### v0.6.2 (2026-03-01)
-### v0.2.1 (2026-02-13)
+- **FIX**: OpenClaw 2026.2.26 compatibility — Changed `extensions` from `["./"]` to `["./index.ts"]`
+- **DOCS**: Added comprehensive README and migration guide
-**Bug Fix:**
-- Made `apiKey` and `agentId` optional in config schema
-- Allows installation without pre-configuring credentials
-- Plugin auto-detects agentId and supports MEMORYRELAY_API_KEY env var
-- Fixes "must have required property" errors during installation
+### v0.6.0 (2026-02-18)
-### v0.2.0 (2026-02-13) - BREAKING CHANGE
+- **NEW**: Retry logic with exponential backoff (3 attempts)
+- **NEW**: Request timeout (30 seconds)
+- **NEW**: Environment variable fallback support
+- **NEW**: Channel filtering (`excludeChannels` config)
-**Package Renamed to Fix Warnings:**
-- Old: `@memoryrelay/openclaw-plugin`
-- New: `@memoryrelay/plugin-memoryrelay-ai`
-- Plugin ID remains: `plugin-memoryrelay-ai`
-- **Why**: Package name must match plugin ID to avoid config warnings
-- **Impact**: No code changes, just package name alignment
+## Development
-**Migration**:
 ```bash
-# Uninstall old package
-openclaw plugins uninstall @memoryrelay/openclaw-plugin
-# Install new package
-openclaw plugins install @memoryrelay/plugin-memoryrelay-ai
-```
-### v0.1.2 (2026-02-13)
-**Bug Fix:**
-- Fixed installation directory mismatch by adding `openclaw.id` to package.json
-- Plugin now correctly installs to `plugin-memoryrelay-ai` directory
-- Resolves "plugin not found" error during `openclaw plugins install`
-### v0.1.1 (2026-02-13)
-**Breaking Changes:**
-- Plugin ID changed: `memory-memoryrelay` → `plugin-memoryrelay-ai`
-- Update your `openclaw.json` to use new ID in `plugins.slots.memory` and `plugins.entries`
-**Documentation Improvements:**
-- ✅ Added agent_id auto-injection documentation
-- ✅ Added size limits (content 1-50K chars, metadata 10KB)
-- ✅ Added rate limit info (30 req/min)
-- ✅ Enhanced tool documentation with return formats
-- ✅ Added response format examples for memory_recall
-**Migration Guide:**
-```json
-{
-  "plugins": {
-    "slots": {
-      "memory": "plugin-memoryrelay-ai"  // Changed
-    },
-    "entries": {
-      "plugin-memoryrelay-ai": {  // Changed
-        "enabled": true,
-        "config": { ... }
-      }
-    }
-  }
-}
+git clone https://github.com/memoryrelay/openclaw-plugin.git
+cd openclaw-plugin
+npm install
+npm test              # Run once (50 tests)
+npm run test:watch    # Watch mode
+npm run test:coverage # With coverage
 ```
-### v0.1.0 (2026-02-12)
+## License
-- Initial release
-- Three tools: memory_store, memory_recall, memory_forget
-- Auto-recall and auto-capture features
-- CLI commands
-- Production deployment on 3 agents
+MIT License - see [LICENSE](./LICENSE) file
----
+## Links
-**Homepage**: https://memoryrelay.io
-**API**: https://api.memoryrelay.net
-**Source**: https://github.com/memoryrelay/openclaw-plugin
+- **MemoryRelay**: https://memoryrelay.ai
+- **OpenClaw**: https://docs.openclaw.ai
+- **Repository**: https://github.com/memoryrelay/openclaw-plugin
+- **Issues**: https://github.com/memoryrelay/openclaw-plugin/issues