@memoryrelay/plugin-memoryrelay-ai 0.6.2 → 0.8.0

package/README.md

@@ -3,17 +3,20 @@
 [![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)
 
-AI-powered long-term memory with semantic search for OpenClaw agents. Store memories, recall relevant context automatically, and give your AI assistant true continuity across sessions.
+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** - Vector-based memory retrieval finds relevant context by meaning, not keywords
-- 🔄 **Auto-Recall** - Automatically injects relevant memories into context on every turn
-- 📝 **Manual Storage** - Store important facts, preferences, and context via `memory_store` tool
-- 🔍 **Smart Filtering** - Channel exclusions to keep memories private (skip group chats)
-- 🛡️ **Retry Logic** - Exponential backoff with 3 attempts for network resilience
-- ⚡ **Fast** - 50-150ms latency for semantic search
-- 🌐 **Cloud-Backed** - Memories persist across devices and sessions
+- **39 Tools** covering memories, entities, sessions, decisions, patterns, and projects
+- **Debug & Monitoring** - Comprehensive logging, health checks, and performance metrics (v0.8.0+)
+- **CLI Commands** - 4 commands for debugging and diagnostics (v0.8.0+)
+- **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
 
@@ -26,28 +29,24 @@ AI-powered long-term memory with semantic search for OpenClaw agents. Store memo
 ### Install via OpenClaw CLI
 
 ```bash
-# Install from npm
 openclaw plugins install @memoryrelay/plugin-memoryrelay-ai
-
-# Or install from local directory (development)
-openclaw plugins install --link /path/to/plugin-improvements
 ```
 
 ### Configuration
 
 ```bash
-# Set configuration
 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,
-  "recallLimit": 5
+  "autoCapture": false
 }'
 
 # 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"
 
 # Restart gateway
 openclaw gateway restart
@@ -57,249 +56,506 @@ openclaw gateway restart
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `apiKey` | string | (required) | MemoryRelay API key (or use `MEMORYRELAY_API_KEY` env var) |
-| `agentId` | string | (required) | Unique agent identifier (or use `MEMORYRELAY_AGENT_ID` env var) |
-| `apiUrl` | string | `https://api.memoryrelay.net` | MemoryRelay API endpoint |
-| `autoRecall` | boolean | `true` | Automatically inject relevant memories into context |
-| `autoCapture` | boolean | `false` | Automatically capture important information (privacy sensitive) |
-| `recallLimit` | number | `5` | Maximum memories to inject per turn (1-20) |
+| `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 (e.g., `["telegram:group_123"]`) |
+| `excludeChannels` | string[] | `[]` | Channel IDs to skip auto-recall |
+| `debug` | boolean | `false` | Enable debug logging of API calls (v0.8.0+) |
+| `verbose` | boolean | `false` | Include request/response bodies in debug logs (v0.8.0+) |
+| `logFile` | string | — | Optional file path for persistent debug logs (v0.8.0+) |
+| `maxLogEntries` | number | `100` | Circular buffer size for in-memory logs (v0.8.0+) |
+
+## Debug & Monitoring (v0.8.0+)
+
+### Enable Debug Mode
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "plugin-memoryrelay-ai": {
+        "enabled": true,
+        "config": {
+          "apiKey": "mem_prod_xxxxx",
+          "agentId": "your-agent",
+          "debug": true,
+          "verbose": false,
+          "maxLogEntries": 1000
+        }
+      }
+    }
+  }
+}
+```
+
+### CLI Commands
+
+The plugin provides four CLI commands for debugging and monitoring:
+
+#### View Debug Logs
+```bash
+# Last 20 logs
+memoryrelay-logs
+
+# Last 50 logs
+memoryrelay-logs --limit=50
+
+# Filter by tool
+memoryrelay-logs --tool=memory_store --limit=20
+
+# Show errors only
+memoryrelay-logs --errors-only
+```
+
+#### Health Check
+```bash
+# Run comprehensive health check
+memoryrelay-health
 
-## Usage
+# Tests API connectivity, authentication, and core tools
+```
 
-### Memory Tools (Manual Storage)
+#### Test Individual Tools
+```bash
+# Test specific tool
+memoryrelay-test --tool=memory_store
+memoryrelay-test --tool=memory_recall
+memoryrelay-test --tool=project_list
+```
 
-When auto-capture is disabled (recommended), use these tools to store memories:
+#### View Performance Metrics
+```bash
+# Show performance statistics
+memoryrelay-metrics
+
+# Displays per-tool metrics:
+# - Call count
+# - Success rate
+# - Average duration
+# - p95/p99 latencies
+```
 
-```typescript
-// Store a memory
-memory_store({
-  content: "User prefers concise responses over long explanations",
-  metadata: { category: "preference", topic: "communication" }
-})
+### Gateway Method Calls
 
-// Search memories
-memory_recall({
-  query: "communication preferences",
-  limit: 5
-})
+You can also call these commands via the OpenClaw gateway:
 
-// Delete a memory
-memory_forget({
-  memoryId: "mem_abc123"
-})
+```bash
+openclaw gateway call memoryrelay.logs '{"limit": 20}'
+openclaw gateway call memoryrelay.health
+openclaw gateway call memoryrelay.test '{"tool": "memory_store"}'
+openclaw gateway call memoryrelay.metrics
 ```
 
-### Auto-Recall (Automatic Context Injection)
+### Enhanced Status Reporting
+
+The `memory.status` gateway method now provides comprehensive reports including:
 
-When `autoRecall: true`, the plugin automatically searches and injects relevant memories on every turn:
+- Connection status with response time
+- Tool breakdown by category (39 tools across 8 groups)
+- Recent API call history
+- Known issues with affected tools
+- Debug/verbose mode status
 
+```bash
+openclaw gateway call memory.status
 ```
-User: "What's my API key for NorthRelay?"
 
-[Plugin searches memories for "API key NorthRelay"]
-[Injects top 5 relevant memories into context]
-Agent: "Your NorthRelay API key is nr_live_..."
+### Debug Log Format
+
+When debug mode is enabled, each API call is logged with:
+
+```
+TIMESTAMP          TOOL                    DURATION  STATUS  ERROR
+━━━━━━━━━━━━━━━━━  ━━━━━━━━━━━━━━━━━━━━━  ━━━━━━━━  ━━━━━━  ━━━━━━━━━━━━━━━━━━━
+7:35:15 PM        memory_store              142ms  ✓      
+7:35:10 PM        memory_recall              78ms  ✓      
+7:35:05 PM        memory_batch_store        245ms  ✗      500 Internal Server Error
 ```
 
-### Channel Exclusions (Privacy)
+Verbose mode additionally captures request/response bodies for deep troubleshooting.
+
+### Performance Impact
+
+- **Debug disabled**: ~0ms overhead (no-op checks)
+- **Debug enabled**: ~1-2ms per call (logging only)
+- **Verbose enabled**: ~2-5ms per call (includes JSON serialization)
+- **Memory usage**: ~10KB (default 100 entries) to ~100KB (1000 entries)
+
+## Agent Workflow
 
-Exclude specific channels from auto-recall to keep memories private:
+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:
 
 ```json
 {
-  "excludeChannels": [
-    "telegram:group_123456",
-    "discord:channel_789012",
-    "whatsapp:group_345678@g.us"
-  ]
+  "enabledTools": "memory,session,decision"
 }
 ```
 
-## What to Store
+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.
 
-### ✅ Good Candidates for Memory Storage
+Available groups: `memory`, `entity`, `agent`, `session`, `decision`, `pattern`, `project`, `health`
 
-- **API Keys & Credentials** - `"NorthRelay API key: nr_live_..."`
-- **Infrastructure** - `"Production server: 51.161.10.58, SSH port 2222"`
-- **Commands** - `"Deploy command: cd /opt/app && docker compose up -d"`
-- **Preferences** - `"User prefers Python over JavaScript for data analysis"`
-- **Project Context** - `"NorthRelay uses Next.js 16, Prisma 6, PostgreSQL 15"`
-- **Lessons Learned** - `"Always run git pull before deploying to avoid conflicts"`
+Set to `all` (or omit) to enable everything.
 
-### ❌ Don't Store
+## Auto-Recall
 
-- Routine conversation (`"how are you?"`)
-- Temporary context (one-time questions)
-- Already well-documented info (in README, docs)
-- Personal secrets user explicitly says not to store
+When `autoRecall: true`, relevant memories are automatically injected into agent context each turn:
 
-## Memory Lifecycle
+```
+User: "How should I handle authentication in this project?"
 
-1. **Store** - Call `memory_store` with content + metadata
-2. **Recall** - MemoryRelay auto-injects on relevant turns (or manual `memory_recall`)
-3. **Update** - Store again with same key to update
-4. **Forget** - Call `memory_forget` to delete
+[Plugin searches memories for "authentication"]
+[Injects workflow instructions + top 5 relevant memories into context]
+Agent uses past decisions and patterns to inform its response
+```
+
+## Channel Exclusions
 
-## Architecture
+Exclude specific channels from auto-recall and workflow injection:
 
+```json
+{
+  "excludeChannels": [
+    "telegram:group_123456",
+    "discord:channel_789012"
+  ]
+}
 ```
-┌─────────────────┐
-│   OpenClaw      │
-│   Agent         │
-└────────┬────────┘
-         │
-    ┌────┴─────┐
-    │  Plugin  │ ← This plugin
-    └────┬─────┘
-         │
-         │ HTTPS (Bearer auth)
-         ↓
-┌─────────────────┐
-│  MemoryRelay    │
-│  API            │
-│ (Vector Search) │
-└─────────────────┘
+
+## CLI Commands
+
+```bash
+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
 ```
 
 ## Privacy & Security
 
-- **Cloud-Backed** - Memories stored on MemoryRelay servers (HTTPS-encrypted)
-- **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
+- **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.
 
-**Privacy Tip:** For ultra-sensitive data (private keys, passwords), use encrypted local files instead of cloud memory.
+## Troubleshooting
 
-## CLI Commands
+### Plugin Not Loading
 
+**Symptoms**: Plugin doesn't appear in `openclaw plugins list` or shows as "unavailable"
+
+**Solutions**:
 ```bash
-# Check plugin status
-openclaw plugins info plugin-memoryrelay-ai
+# Check if installed
+npm list -g @memoryrelay/plugin-memoryrelay-ai
+
+# Reinstall if needed
+openclaw plugins install @memoryrelay/plugin-memoryrelay-ai --force
 
-# List all plugins
-openclaw plugins list
+# Check config syntax
+cat ~/.openclaw/openclaw.json | jq '.plugins.entries."plugin-memoryrelay-ai"'
 
-# Enable/disable
-openclaw plugins enable plugin-memoryrelay-ai
-openclaw plugins disable plugin-memoryrelay-ai
+# Restart gateway
+openclaw gateway restart
 
-# Uninstall
-openclaw plugins uninstall plugin-memoryrelay-ai
+# Check logs for errors
+openclaw gateway logs | grep memoryrelay
 ```
 
-## Troubleshooting
+### API Connection Issues
 
-### Plugin Not Loading
+**Symptoms**: "Failed to connect" errors, timeouts, or "unhealthy" status
 
+**Solutions**:
 ```bash
-# Check if plugin is discovered
-openclaw plugins list | grep memoryrelay
+# Test API directly
+curl -H "X-API-Key: YOUR_KEY" https://api.memoryrelay.net/v1/health
 
-# Verify config
-openclaw config get plugins.entries.plugin-memoryrelay-ai
+# Check gateway logs
+openclaw gateway logs -f | grep memory-memoryrelay
 
-# Check logs
-openclaw logs --tail 100 | grep memory
+# Verify API key format (should be mem_prod_xxxxx with 32 chars after prefix)
+openclaw config get plugins.entries.plugin-memoryrelay-ai.config.apiKey
+
+# Run health check
+memoryrelay-health
 ```
 
-### API Connection Issues
+### Auto-Recall Not Working
+
+**Symptoms**: Memories not appearing in agent context
+
+**Checks**:
+1. Verify `autoRecall: true` in config
+2. Check memories exist: `openclaw gateway call memory_list '{"limit": 10}'`
+3. Lower `recallThreshold` (try 0.1) for more results
+4. Review logs: `openclaw gateway logs | grep "injecting.*memories"`
+5. Check channel not in `excludeChannels`
+
+### Debug Mode Not Working
+
+**Symptoms**: `memoryrelay-logs` shows "No logs" or debug commands fail
+
+**Solutions**:
+1. Verify `debug: true` in config
+2. Restart gateway after config change: `openclaw gateway restart`
+3. Use the plugin to generate logs
+4. Check `maxLogEntries` isn't set too low (default: 100)
+
+### Tool Not Found Errors
 
+**Symptoms**: "Tool xxx not found" or "Tool not enabled"
+
+**Solutions**:
+1. Check `enabledTools` config (should be `"all"` or include the tool's group)
+2. Verify tool name spelling matches exactly (e.g., `memory_store` not `memoryStore`)
+3. Check plugin version: `npm list -g @memoryrelay/plugin-memoryrelay-ai`
+4. Update to latest: `openclaw plugins install @memoryrelay/plugin-memoryrelay-ai@latest`
+
+### Performance Issues
+
+**Symptoms**: Slow API calls, timeouts, high latency
+
+**Diagnosis**:
 ```bash
-# Test API connection
-curl -H "Authorization: Bearer YOUR_API_KEY" \
-  https://api.memoryrelay.net/v1/memories
+# Enable debug mode
+openclaw config set plugins.entries.plugin-memoryrelay-ai.config.debug true
+openclaw gateway restart
+
+# View metrics
+memoryrelay-metrics
+
+# Check for slow tools (high avgDuration or p99)
+# Check for failures (low successRate)
 ```
 
-### OpenClaw 2026.2.26 Compatibility
+**Solutions**:
+1. Check network latency to api.memoryrelay.net
+2. Reduce `recallLimit` (fewer memories = faster)
+3. Lower `recallThreshold` (fewer vector comparisons)
+4. Check MemoryRelay API status at status.memoryrelay.ai
 
-If you see `extension entry escapes package directory`, you're using an older plugin version. Update to v0.6.2+:
+### Memory Storage Failures
 
+**Symptoms**: `memory_store` returns 422 validation errors or 500 errors
+
+**Common Causes**:
+1. Content too long (max 50,000 characters)
+2. Metadata too large (max 10KB when serialized)
+3. Invalid project slug (use `project_list` to verify)
+4. API rate limits exceeded (30 req/min for memory_store)
+
+**Solutions**:
 ```bash
-openclaw plugins uninstall plugin-memoryrelay-ai
-openclaw plugins install @memoryrelay/plugin-memoryrelay-ai
+# Test with minimal memory
+openclaw gateway call memory_store '{"content": "Test memory"}'
+
+# Check recent errors
+memoryrelay-logs --errors-only --limit=10
+
+# Verify API key has write permissions
+curl -X POST https://api.memoryrelay.net/v1/memories \
+  -H "X-API-Key: YOUR_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"content": "Test"}'
 ```
 
-See [OPENCLAW-2026.2.26-MIGRATION.md](./OPENCLAW-2026.2.26-MIGRATION.md) for details.
+### Session Tracking Issues
+
+**Symptoms**: `session_start` fails or `session_end` can't find session
+
+**Solutions**:
+1. Save session ID from `session_start` response
+2. Verify project exists: `openclaw gateway call project_list`
+3. Check for API validation errors in logs
+4. Use `session_list` to find active sessions
+
+### Known Limitations
+
+**API Issues** (reported to MemoryRelay team):
+- `memory_batch_store`: May return 500 errors (use individual `memory_store` as workaround)
+- `memory_context`: Returns 405 Method Not Allowed (use `memory_recall` instead)
+- `entity_create`: May fail with 422 validation errors
+- `decision_record`: May fail with 422 validation errors
+- `session_start`: May fail with 422 validation errors
+
+**Workarounds**:
+- Use alternative tools where available
+- Check GitHub Issues for latest status
+- Enable debug mode to capture full error details
 
 ## Changelog
 
+### v0.8.0 (2026-03-05)
+
+**🚀 Debug & Monitoring Release**
+
+- **NEW**: Debug logging system with circular buffer (configurable maxLogEntries)
+- **NEW**: DebugLogger class tracks all API calls with timing, status, errors
+- **NEW**: StatusReporter class provides enhanced status reports
+- **NEW**: 4 CLI commands: `memoryrelay-logs`, `memoryrelay-health`, `memoryrelay-test`, `memoryrelay-metrics`
+- **NEW**: 4 gateway methods: `memoryrelay.logs`, `memoryrelay.health`, `memoryrelay.test`, `memoryrelay.metrics`
+- **NEW**: Performance metrics with p95/p99 latency tracking
+- **NEW**: Enhanced `memory.status` handler with comprehensive reports
+- **NEW**: Debug config options: `debug`, `verbose`, `logFile`, `maxLogEntries`
+- **NEW**: Tool failure tracking and recovery monitoring
+- **NEW**: Request/response capture in verbose mode
+- **NEW**: Persistent file logging option
+- **TESTS**: 92 tests total (73 existing + 19 new for DebugLogger and StatusReporter)
+- **DOCS**: CLI_COMMANDS.md with complete usage guide
+- **DOCS**: Enhanced README with Debug & Monitoring section
+- **DOCS**: Comprehensive troubleshooting guide
+
+**Performance**: Minimal overhead when disabled (~0ms), 1-2ms when enabled, 2-5ms in verbose mode
+
+### v0.7.0 (2026-03-05)
+
+- **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
+
 ### v0.6.2 (2026-03-01)
 
-- **FIX**: OpenClaw 2026.2.26 compatibility - Changed `extensions` from `["./"]` to `["./index.ts"]`
-- **FIX**: Plugin now installs via `openclaw plugins install` (not npm global)
+- **FIX**: OpenClaw 2026.2.26 compatibility — Changed `extensions` from `["./"]` to `["./index.ts"]`
 - **DOCS**: Added comprehensive README and migration guide
 
-### v0.6.1 (2026-02-18)
-
-- Removed `extensions` field (attempted fix) - **FAILED**
-
 ### v0.6.0 (2026-02-18)
 
 - **NEW**: Retry logic with exponential backoff (3 attempts)
 - **NEW**: Request timeout (30 seconds)
-- **NEW**: Environment variable fallback support (`MEMORYRELAY_API_KEY`, `MEMORYRELAY_AGENT_ID`)
+- **NEW**: Environment variable fallback support
 - **NEW**: Channel filtering (`excludeChannels` config)
-- **NEW**: Additional error handling and logging
-
-See [CHANGELOG-v0.6.0.md](./CHANGELOG-v0.6.0.md) for details.
 
 ## Development
 
-### Local Testing
-
 ```bash
-# Clone repository
 git clone https://github.com/memoryrelay/openclaw-plugin.git
 cd openclaw-plugin
-
-# Install dev dependencies
 npm install
-
-# Run tests
-npm test
-
-# Link for local testing
-openclaw plugins install --link .
-```
-
-### Running Tests
-
-```bash
-npm test              # Run once
+npm test              # Run once (50 tests)
 npm run test:watch    # Watch mode
 npm run test:coverage # With coverage
 ```
 
-## Contributing
-
-Contributions welcome! Please:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit changes (`git commit -m 'Add amazing feature'`)
-4. Push to branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
 ## License
 
 MIT License - see [LICENSE](./LICENSE) file
 
 ## Links
 
-- **MemoryRelay API**: https://memoryrelay.ai
-- **OpenClaw Docs**: https://docs.openclaw.ai
-- **Plugin Repository**: 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
-
-## Support
-
-- **Documentation**: https://docs.memoryrelay.ai
-- **Discord**: https://discord.com/invite/clawd (OpenClaw community)
-- **Email**: support@memoryrelay.ai
-
----
-
-Built with ❤️ for the OpenClaw community