@memoryrelay/plugin-memoryrelay-ai 0.15.2 → 0.15.4

package/index.ts

@@ -1,6 +1,6 @@
 /**
  * OpenClaw Memory Plugin - MemoryRelay
- * Version: 0.15.2
+ * Version: 0.15.3
  *
  * Long-term memory with vector search using MemoryRelay API.
  * Provides auto-recall and auto-capture via lifecycle hooks.
@@ -711,7 +711,7 @@ class MemoryRelayClient {
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${this.apiKey}`,
-            "User-Agent": "openclaw-memory-memoryrelay/0.15.2",
+            "User-Agent": "openclaw-memory-memoryrelay/0.15.3",
           },
           body: body ? JSON.stringify(body) : undefined,
         },
@@ -1324,7 +1324,7 @@ class MemoryRelayClient {
   async stats(): Promise<Stats> {
     const response = await this.request<{ data: Stats }>(
       "GET",
-      `/v1/stats?agent_id=${encodeURIComponent(this.agentId)}`,
+      `/v1/agents/${encodeURIComponent(this.agentId)}/stats`,
     );
     return {
       total_memories: response.data?.total_memories ?? 0,
@@ -1967,7 +1967,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
             }
 
             const list = results
-              .map((r) => `- [${r.memory.id.slice(0, 8)}] ${r.memory.content.slice(0, 60)}...`)
+              .map((r) => `- [${r.memory.id}] ${r.memory.content.slice(0, 60)}...`)
               .join("\n");
 
             return {
@@ -2025,7 +2025,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
               };
             }
             const formatted = memories
-              .map((m) => `- [${m.id.slice(0, 8)}] ${m.content.slice(0, 120)}`)
+              .map((m) => `- [${m.id}] ${m.content.slice(0, 120)}`)
               .join("\n");
             return {
               content: [{ type: "text", text: `${memories.length} memories:\n${formatted}` }],
@@ -4459,14 +4459,30 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
       const outcome = event.outcome || "unknown";
       const summary = `Subagent ${event.targetSessionKey} ended: ${event.reason} (outcome: ${outcome})`;
 
-      await client.store(summary, {
-        category: "subagent-activity",
-        source: "subagent_ended_hook",
-        agent: agentId,
-        outcome,
-      });
+      // Only store subagent completions if autoCapture is enabled and content passes filters (#44)
+      if (autoCaptureConfig.enabled) {
+        if (isBlocklisted(summary, autoCaptureConfig.blocklist || [])) {
+          api.logger.debug?.(`memory-memoryrelay: subagent completion blocklisted, skipping storage`);
+          return;
+        }
 
-      api.logger.debug?.(`memory-memoryrelay: stored subagent completion: ${summary}`);
+        // Skip routine completion events — only store failures or unusual outcomes
+        if (outcome === "ok" || outcome === "success") {
+          api.logger.debug?.(`memory-memoryrelay: skipping routine subagent completion: ${summary}`);
+          return;
+        }
+
+        await client.store(summary, {
+          category: "subagent-activity",
+          source: "subagent_ended_hook",
+          agent: agentId,
+          outcome,
+        });
+
+        api.logger.debug?.(`memory-memoryrelay: stored subagent completion: ${summary}`);
+      } else {
+        api.logger.debug?.(`memory-memoryrelay: autoCapture disabled, skipping subagent completion storage`);
+      }
     } catch (err) {
       api.logger.warn?.(`memory-memoryrelay: subagent_ended hook failed: ${String(err)}`);
     }
@@ -4492,7 +4508,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
   });
 
   api.logger.info?.(
-    `memory-memoryrelay: plugin v0.15.2 loaded (${Object.values(TOOL_GROUPS).flat().length} tools, autoRecall: ${cfg?.autoRecall}, autoCapture: ${autoCaptureConfig.enabled ? autoCaptureConfig.tier : 'off'}, debug: ${debugEnabled})`,
+    `memory-memoryrelay: plugin v0.15.3 loaded (${Object.values(TOOL_GROUPS).flat().length} tools, autoRecall: ${cfg?.autoRecall}, autoCapture: ${autoCaptureConfig.enabled ? autoCaptureConfig.tier : 'off'}, debug: ${debugEnabled})`,
   );
 
   // ========================================================================
@@ -5588,7 +5604,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
     description: "Show how to update the MemoryRelay plugin to the latest version",
     requireAuth: true,
     handler: async (_ctx) => {
-      const currentVersion = "0.15.2";
+      const currentVersion = "0.15.3";
       const lines: string[] = [
         "MemoryRelay Plugin Update",
         "━".repeat(50),

package/openclaw.plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoryrelay/plugin-memoryrelay-ai",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "OpenClaw memory plugin for MemoryRelay API - 42 tools, 17 commands, V2 async, sessions, decisions, patterns, projects & semantic search",
   "type": "module",
   "main": "index.ts",

package/skills/decision-tracking/SKILL.md

@@ -5,27 +5,27 @@ description: "Use when making architectural choices, evaluating alternatives, re
 
 # Decision Tracking
 
-Decisions are **choices with rationale and alternatives considered**. Plain facts, findings, or information are memories — use `memory_store` for those.
+Decisions are **choices with rationale and alternatives considered**. Plain facts, findings, or information are memories — use `memory_store` for those (see `memory-workflow` skill).
 
 ## Decision Tools
 
 | Tool | Signature | Purpose |
 |------|-----------|---------|
-| `decision_record` | `decision_record(title, rationale, project)` | Record a new decision with reasoning |
-| `decision_list` | `decision_list(project)` | List all decisions for a project |
-| `decision_supersede` | `decision_supersede(old_id, new_title, new_rationale)` | Replace an outdated decision |
-| `decision_check` | `decision_check(query, project)` | Check for conflicting decisions before choosing |
+| `decision_record` | `decision_record(title, rationale, alternatives?, project?, tags?, status?)` | Record a new decision with reasoning |
+| `decision_list` | `decision_list(project?, status?, tags?, limit?)` | List decisions, optionally filtered |
+| `decision_supersede` | `decision_supersede(old_id, new_title, new_rationale, tags?)` | Replace an outdated decision |
+| `decision_check` | `decision_check(query, project?, limit?, threshold?)` | Semantic search for conflicting decisions |
 
 ## Workflow
 
 1. **Check first** — Always call `decision_check(query, project)` before making an architectural choice. This surfaces existing decisions that may conflict or already cover the topic.
-2. **Record with rationale** — Use `decision_record(title, rationale, project)`. The rationale should include why this option was chosen and what alternatives were rejected.
+2. **Record with rationale** — Use `decision_record(title, rationale, alternatives, project, tags)`. Include why this option was chosen, what alternatives were rejected, and tags for categorization.
 3. **Supersede, don't duplicate** — When a decision changes, call `decision_supersede(old_id, new_title, new_rationale)`. This preserves history while marking the old decision as replaced.
-4. **Review periodically** — Use `decision_list(project)` to audit active decisions during planning or refactoring.
+4. **Review periodically** — Use `decision_list(project, status)` to audit active decisions during planning or refactoring. Filter by `status: "active"` to see current decisions only.
 
 ## Project Scoping
 
-Decisions must be scoped to the relevant project:
+Decisions must be scoped to the relevant project (see `project-orchestration` skill for project setup):
 
 - Set `defaultProject` in plugin config to avoid passing `project` on every call.
 - Pass `project` explicitly when working across multiple projects.
@@ -48,3 +48,4 @@ Decisions must be scoped to the relevant project:
 | Adding a new decision when one already exists | Use `decision_supersede` to replace the old decision, preserving history |
 | Omitting the `project` parameter | Scope every decision to a project via parameter or `defaultProject` config |
 | Storing facts as decisions | Only choices with rationale belong in decisions; use `memory_store` for information |
+| Not using `tags` | Tags enable filtering with `decision_list(project, tags: "api,auth")` |

package/skills/entity-and-context/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: entity-and-context
-description: "Use when building relationship maps between people, systems, services, or concepts that appear across multiple memories, or when recalling information that benefits from entity connections rather than flat search."
+description: "Use when building relationship maps between people, organizations, projects, or concepts that appear across multiple memories, or when recalling information that benefits from entity connections rather than flat search."
 ---
 
 # Entity and Context
@@ -11,22 +11,22 @@ Entities turn flat memory storage into a connected knowledge graph. Create entit
 
 | Tool | Signature | Purpose |
 |------|-----------|---------|
-| `entity_create` | `entity_create(name, type, description)` | Create a new entity node |
-| `entity_link` | `entity_link(entity_id, memory_id)` | Connect an entity to a memory |
-| `entity_list` | `entity_list(type?)` | List entities, optionally filtered by type |
-| `entity_graph` | `entity_graph(entity_id)` | Visualize an entity's relationships |
-| `memory_context` | `memory_context(query)` | Enriched recall with entity connections (memory group tool) |
+| `entity_create` | `entity_create(name, type, metadata?)` | Create a new entity node |
+| `entity_link` | `entity_link(entity_id, memory_id, relationship?)` | Connect an entity to a memory |
+| `entity_list` | `entity_list(limit?, offset?)` | List entities with pagination |
+| `entity_graph` | `entity_graph(entity_id, depth?, max_neighbors?)` | Explore an entity's neighborhood |
+| `memory_context` | `memory_context(query, token_budget?)` | Enriched recall with entity connections (see `memory-workflow` skill) |
 
 ## Entity Types
 
 | Type | Examples |
 |------|----------|
-| `people` | Team members, stakeholders, external contacts |
-| `systems` | Databases, cloud platforms, internal tools |
-| `services` | APIs, microservices, third-party integrations |
-| `concepts` | Architecture patterns, business domains, protocols |
-| `teams` | Engineering squads, departments, working groups |
-| `repositories` | Codebases, monorepos, package libraries |
+| `person` | Team members, stakeholders, external contacts |
+| `place` | Data centers, offices, deployment regions |
+| `organization` | Companies, departments, vendors |
+| `project` | Codebases, initiatives, products |
+| `concept` | Architecture patterns, business domains, protocols |
+| `other` | Anything that doesn't fit the above |
 
 ## When to Create Entities
 
@@ -37,11 +37,11 @@ Create an entity when a named thing:
 
 ## Linking Workflow
 
-1. **Create the entity** — `entity_create("AuthService", "services", "Handles OAuth2 and JWT token management")`
-2. **Store related memories** — `memory_store(content, metadata)` as usual
-3. **Link them** — `entity_link(entity_id, memory_id)` to connect entity to each relevant memory
+1. **Create the entity** — `entity_create("AuthService", "concept", { "domain": "security" })`
+2. **Store related memories** — `memory_store(content, metadata)` as usual (see `memory-workflow` skill)
+3. **Link them** — `entity_link(entity_id, memory_id, "mentioned_in")` to connect entity to each relevant memory
 4. **Query with context** — `memory_context("authentication flow")` returns memories enriched with linked entity data
-5. **Explore connections** — `entity_graph(entity_id)` to see all related memories and co-linked entities
+5. **Explore connections** — `entity_graph(entity_id, 2, 10)` to see related memories and co-linked entities up to 2 hops away
 
 ## memory_context vs memory_recall
 
@@ -58,5 +58,5 @@ Create an entity when a named thing:
 | Creating entities for one-off mentions | Only create entities for things referenced across multiple memories |
 | Not linking entities to memories | An unlinked entity is invisible to `memory_context`; always link after creating |
 | Using `memory_recall` when entities exist | Switch to `memory_context` for richer results that include entity connections |
-| Creating duplicate entities | Call `entity_list(type)` first to check if the entity already exists |
+| Creating duplicate entities | Call `entity_list()` first to check if the entity already exists |
 | Linking everything to one entity | Keep links specific; an entity should connect only to directly relevant memories |

package/skills/memory-workflow/SKILL.md

@@ -13,23 +13,27 @@ Follow this order every time. Skipping steps causes orphaned memories.
 |------|------|---------|
 | 1 | `project_context(project)` | Load hot-tier memories, active decisions, adopted patterns |
 | 2 | `session_start(title, project)` | Begin tracking work (returns `session_id`) |
-| 3 | `decision_check(query, project)` | Check existing decisions before architectural choices |
-| 4 | `pattern_search(query)` | Find established conventions |
+| 3 | `decision_check(query, project)` | Check existing decisions before architectural choices (see `decision-tracking` skill) |
+| 4 | `pattern_search(query)` | Find established conventions (see `pattern-management` skill) |
 
 ## During Work
 
 | Action | Tool | Notes |
 |--------|------|-------|
 | Save info | `memory_store(content, metadata)` | Always set `deduplicate=true` |
-| Search | `memory_recall(query)` | Semantic search across memories |
+| Search | `memory_recall(query, limit?, threshold?)` | Semantic search across memories |
 | Delete | `memory_forget(id_or_query)` | By ID or fuzzy search |
 | Browse | `memory_list(limit, offset)` | Chronological listing |
 | Read one | `memory_get(id)` | Fetch by exact ID |
 | Edit | `memory_update(id, content)` | Correct or expand existing |
 | Bulk save | `memory_batch_store(memories[])` | Efficient for multiple items |
-| Build prompt | `memory_context(query, token_budget)` | Token-aware context window |
+| Build prompt | `memory_context(query, token_budget)` | Token-aware context window (see `entity-and-context` skill) |
 | Upgrade | `memory_promote(id, importance, tier)` | Move temporary to long-term |
 
+**For architectural choices**, use `decision_record` instead of `memory_store` — see the `decision-tracking` skill.
+
+**For reusable conventions**, use `pattern_create` instead of `memory_store` — see the `pattern-management` skill.
+
 ## Ending a Session
 
 Call `session_end(session_id, summary)` with a meaningful summary. This becomes the historical record.
@@ -58,27 +62,13 @@ Categories: `technical`, `preference`, `credential`, `decision`. Consistent meta
 
 Use `memory_promote(id, importance, tier)` to upgrade a memory. Set `importance` near 1.0 for critical items.
 
-## Auto-Capture Tiers
-
-Configured per-plugin, not per-call. Know what mode is active:
-
-| Tier | Behavior |
-|------|----------|
-| `off` | No automatic capture |
-| `conservative` | Only credentials and explicit preferences |
-| `smart` (default) | Technical facts, preferences, patterns |
-| `aggressive` | Captures most exchanged information |
-
-## Privacy Blocklist
-
-Auto-filtered (never stored): passwords, credit card numbers, SSNs, API keys/tokens. The blocklist regex rejects these even on manual `memory_store` calls.
-
 ## Common Mistakes
 
 | Mistake | Fix |
 |---------|-----|
 | Storing without a session | Always call `session_start` first |
 | Skipping `deduplicate=true` | Set it on every `memory_store` call |
-| Using `memory_store` for decisions | Use `decision_record` instead |
+| Using `memory_store` for decisions | Use `decision_record` instead (see `decision-tracking` skill) |
+| Using `memory_store` for conventions | Use `pattern_create` instead (see `pattern-management` skill) |
 | No category/tags in metadata | Always include both for searchability |
-| Storing API keys or passwords | Blocklist rejects them; use a secrets manager |
+| Storing API keys or passwords | Blocklist auto-rejects these; use a secrets manager |

package/skills/pattern-management/SKILL.md

@@ -5,22 +5,22 @@ description: "Use when establishing reusable conventions, looking up existing pa
 
 # Pattern Management
 
-Patterns are **reusable solutions with problem context**. Plain implementation notes are memories — use `memory_store` for those.
+Patterns are **reusable solutions with problem context**. Plain implementation notes are memories — use `memory_store` for those (see `memory-workflow` skill).
 
 ## Pattern Tools
 
 | Tool | Signature | Purpose |
 |------|-----------|---------|
-| `pattern_create` | `pattern_create(title, description)` | Create a reusable pattern |
-| `pattern_search` | `pattern_search(query)` | Find existing patterns before creating new ones |
+| `pattern_create` | `pattern_create(title, description, category?, example_code?, scope?, tags?, source_project?)` | Create a reusable pattern |
+| `pattern_search` | `pattern_search(query, category?, project?, limit?, threshold?)` | Find existing patterns |
 | `pattern_adopt` | `pattern_adopt(pattern_id, project)` | Track which projects use which patterns |
-| `pattern_suggest` | `pattern_suggest(project)` | Get pattern recommendations for a project |
+| `pattern_suggest` | `pattern_suggest(project, limit?)` | Get pattern recommendations for a project |
 
 ## Workflow
 
 1. **Search first** — Always call `pattern_search(query)` before `pattern_create`. Duplicate patterns fragment conventions and confuse future lookups.
-2. **Create with structure** — If no match exists, call `pattern_create(title, description)`. The description must follow the structure below.
-3. **Adopt to projects** — Call `pattern_adopt(pattern_id, project)` so the pattern appears in `project_context` results and `pattern_suggest` recommendations.
+2. **Create with structure** — If no match exists, call `pattern_create(title, description, category, example_code)`. Include `example_code` for maximum usefulness. Set `scope` to `"global"` for cross-project or `"project"` for project-specific patterns.
+3. **Adopt to projects** — Call `pattern_adopt(pattern_id, project)` so the pattern appears in `project_context` results and `pattern_suggest` recommendations (see `project-orchestration` skill).
 4. **Review suggestions** — Use `pattern_suggest(project)` when starting work on a project to discover applicable conventions.
 
 ## Pattern Structure
@@ -35,10 +35,14 @@ Every `description` in `pattern_create` should include:
 | **Examples** | Concrete usage showing the pattern in action |
 
 ```
-description: "Problem: Inconsistent error responses across API endpoints.
-Solution: Return { error: string, code: string, details?: object } on all 4xx/5xx.
-Context: REST APIs with multiple consumers. Not needed for internal RPC.
-Examples: 400 → { error: 'Invalid email', code: 'VALIDATION_ERROR' }"
+pattern_create(
+  "RFC 7807 Error Responses",
+  "Problem: Inconsistent error responses across API endpoints.\nSolution: Return { error, code, details? } on all 4xx/5xx.\nContext: REST APIs with multiple consumers. Not needed for internal RPC.",
+  "error-handling",
+  '{ error: "Invalid email", code: "VALIDATION_ERROR", details: { field: "email" } }',
+  "global",
+  ["api", "rest", "validation"]
+)
 ```
 
 ## Cross-Project Consistency
@@ -53,5 +57,6 @@ Examples: 400 → { error: 'Invalid email', code: 'VALIDATION_ERROR' }"
 |---------|-----|
 | Creating without searching first | Always `pattern_search` before `pattern_create` — duplicates fragment conventions |
 | Vague descriptions | Follow the Problem/Solution/Context/Examples structure; be specific and actionable |
+| Omitting `example_code` | Always include a concrete code example — patterns without examples are hard to apply |
 | Not adopting to projects | Call `pattern_adopt` after creating; unadopted patterns are invisible to `project_context` |
 | Patterns too specific | Patterns should generalize across contexts; one-off solutions belong in memories or decisions |

package/skills/project-orchestration/SKILL.md

@@ -5,22 +5,22 @@ description: "Use when registering a new project, loading project context before
 
 # Project Orchestration
 
-Projects are the top-level organizer. Every session, memory, decision, and pattern ties back to a project slug.
+Projects are the top-level organizer. Every session, memory, decision, and pattern ties back to a project slug. See related skills: `memory-workflow`, `decision-tracking`, `pattern-management`.
 
 ## Project Tools
 
 | Tool | Signature | Purpose |
 |------|-----------|---------|
-| `project_register` | `project_register(slug, name, description, stack)` | Register a new project |
-| `project_list` | `project_list()` | List all registered projects |
+| `project_register` | `project_register(slug, name, description?, stack?, repo_url?)` | Register a new project |
+| `project_list` | `project_list(limit?)` | List all registered projects |
 | `project_info` | `project_info(slug)` | Get project details |
+| `project_context` | `project_context(slug)` | Full overview: hot-tier memories, active decisions, adopted patterns |
 | `project_add_relationship` | `project_add_relationship(from, to, type)` | Link related projects |
 | `project_dependencies` | `project_dependencies(slug)` | What this project depends on |
 | `project_dependents` | `project_dependents(slug)` | What depends on this project |
 | `project_related` | `project_related(slug)` | All related projects (any direction) |
-| `project_impact` | `project_impact(slug)` | Impact analysis before breaking changes |
-| `project_shared_patterns` | `project_shared_patterns(slug)` | Patterns shared across related projects |
-| `project_context` | `project_context(slug)` | Full overview: hot-tier memories, active decisions, adopted patterns |
+| `project_impact` | `project_impact(project, change_description)` | Impact analysis before breaking changes |
+| `project_shared_patterns` | `project_shared_patterns(project_a, project_b)` | Patterns shared between two projects |
 
 ## First-Time Setup
 
@@ -37,14 +37,14 @@ When `defaultProject` is set in plugin configuration, the project slug is **auto
 Always call `project_context(slug)` as the **first step** when beginning work on a project. It returns:
 
 - **Hot-tier memories** — critical facts always surfaced
-- **Active decisions** — current architectural choices
-- **Adopted patterns** — conventions in use
+- **Active decisions** — current architectural choices (see `decision-tracking` skill)
+- **Adopted patterns** — conventions in use (see `pattern-management` skill)
 
 This replaces manual searching. Start here, then drill into specifics with other tools.
 
 ## Impact Analysis
 
-Before making **any breaking change**, call `project_impact(slug)`. It checks:
+Before making **any breaking change**, call `project_impact(project, change_description)` with a clear description of the proposed change. It checks:
 
 - Downstream dependents that will be affected
 - Shared patterns that may need updating
@@ -54,12 +54,12 @@ Never skip this step. Breaking a dependency without checking impact creates casc
 
 ## Managing Relationships
 
-Use `project_add_relationship(from, to, type)` to declare how projects relate. Relationship types include dependencies, shared ownership, and related context. Once linked:
+Use `project_add_relationship(from, to, type)` to declare how projects relate. Relationship types: `depends_on`, `api_consumer`, `shares_schema`, `shares_infra`, `pattern_source`, `forked_from`. Once linked:
 
 - `project_dependencies(slug)` — upstream projects this one relies on
 - `project_dependents(slug)` — downstream projects relying on this one
 - `project_related(slug)` — all connections regardless of direction
-- `project_shared_patterns(slug)` — patterns adopted by both this project and its related projects
+- `project_shared_patterns(project_a, project_b)` — patterns adopted by both projects
 
 ## Common Mistakes
 
@@ -68,5 +68,5 @@ Use `project_add_relationship(from, to, type)` to declare how projects relate. R
 | Working without project context | Always `project_context` first — it loads everything you need |
 | Registering duplicate projects | Call `project_list` before `project_register`; check if slug exists |
 | Not using relationships | Call `project_add_relationship` when projects share code, APIs, or conventions |
-| Breaking changes without impact check | Always `project_impact` before modifying shared interfaces or dependencies |
+| Breaking changes without impact check | Always `project_impact(project, change_description)` before modifying shared interfaces |
 | Passing project on every call when `defaultProject` is set | Unnecessary — the config injects it automatically |