@memoryrelay/plugin-memoryrelay-ai 0.15.1 → 0.15.3

package/README.md

@@ -314,10 +314,13 @@ The plugin registers 14 lifecycle hooks:
 
 ### Skills
 
-The plugin ships with 9 skills providing guided workflows on top of the raw tools:
+The plugin ships with 5 skills providing guided workflows on top of the raw tools:
 
-- **Agent-facing**: `memory-workflow`, `decision-tracking`, `pattern-management`, `project-orchestration`, `entity-and-context`
-- **Developer-facing**: `codebase-navigation`, `testing-memoryrelay`, `release-process`
+- `memory-workflow` — Session lifecycle, storing/retrieving memories
+- `decision-tracking` — ADR management, checking before deciding
+- `pattern-management` — Reusable conventions, search before create
+- `project-orchestration` — Multi-project context loading and impact analysis
+- `entity-and-context` — Knowledge graph, linking entities to memories
 
 ## Updating
 

package/index.ts

@@ -1,10 +1,11 @@
 /**
  * OpenClaw Memory Plugin - MemoryRelay
- * Version: 0.13.0 (SDK Enhancements)
+ * Version: 0.15.3
  *
  * Long-term memory with vector search using MemoryRelay API.
  * Provides auto-recall and auto-capture via lifecycle hooks.
  * Includes: memories, entities, agents, sessions, decisions, patterns, projects.
+ * New in v0.15.0: V2 async API, context_build with AI-enhanced search modes
  * New in v0.13.0: External session IDs, get-or-create sessions, multi-agent collaboration
  * New in v0.12.7: OpenClaw session context integration for session tracking
  * New in v0.12.0: Smart auto-capture, daily stats, CLI commands, onboarding
@@ -67,6 +68,7 @@ interface DebugLoggerConfig {
   enabled: boolean;
   verbose: boolean;
   maxEntries: number;
+  logFile?: string; // Deprecated: File logging removed for security compliance
 }
 
 class DebugLogger {
@@ -709,7 +711,7 @@ class MemoryRelayClient {
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${this.apiKey}`,
-            "User-Agent": "openclaw-memory-memoryrelay/0.15.1",
+            "User-Agent": "openclaw-memory-memoryrelay/0.15.3",
           },
           body: body ? JSON.stringify(body) : undefined,
         },
@@ -1666,7 +1668,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
   }
 
   // ========================================================================
-  // Tools (39 total)
+  // Tools (42 total)
   // ========================================================================
 
   // --------------------------------------------------------------------------
@@ -1965,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 {
@@ -2023,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}` }],
@@ -4457,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)}`);
     }
@@ -4490,7 +4508,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
   });
 
   api.logger.info?.(
-    `memory-memoryrelay: plugin v0.15.1 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})`,
   );
 
   // ========================================================================
@@ -4551,7 +4569,7 @@ export default async function plugin(api: OpenClawPluginApi): Promise<void> {
         }
 
         const formatted = logs.map((l) =>
-          `[${new Date(l.timestamp).toISOString()}] ${l.level.toUpperCase()} ${l.tool ?? "-"}: ${l.message}`
+          `[${new Date(l.timestamp).toISOString()}] ${l.status.toUpperCase()} ${l.tool ?? "-"}: ${l.method} ${l.path} (${l.duration}ms)${l.error ? ` - ${l.error}` : ""}`
         ).join("\n");
         respond(true, {
           logs,
@@ -5586,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.1";
+      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.1 - Long-term memory with 42 tools, 17 commands, V2 async, sessions, decisions, patterns & projects (api.memoryrelay.net)",
-  "version": "0.15.1",
+  "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.1",
+  "version": "0.15.3",
   "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 |

package/src/status-reporter.ts

@@ -34,10 +34,25 @@ export interface MemoryStats {
   search_count_24h?: number;
 }
 
+export type AutoCaptureTier = "off" | "conservative" | "smart" | "aggressive";
+
+export interface AutoCaptureConfig {
+  enabled: boolean;
+  tier: AutoCaptureTier;
+  confirmFirst?: number;
+  categories?: {
+    credentials?: boolean;
+    preferences?: boolean;
+    technical?: boolean;
+    personal?: boolean;
+  };
+  blocklist?: string[];
+}
+
 export interface PluginConfig {
   agentId: string;
   autoRecall: boolean;
-  autoCapture: boolean;
+  autoCapture: AutoCaptureConfig;
   recallLimit: number;
   recallThreshold: number;
   excludeChannels: string[];
@@ -189,7 +204,10 @@ export class StatusReporter {
       ? `✓ Enabled (limit: ${report.config.recallLimit}, threshold: ${report.config.recallThreshold})`
       : "✗ Disabled";
     lines.push(`  Auto-Recall:   ${recallStatus}`);
-    lines.push(`  Auto-Capture:  ${report.config.autoCapture ? "✓ Enabled" : "✗ Disabled"}`);
+    const captureStatus = report.config.autoCapture.enabled
+      ? `✓ Enabled (tier: ${report.config.autoCapture.tier})`
+      : "✗ Disabled";
+    lines.push(`  Auto-Capture:  ${captureStatus}`);
     if (report.config.defaultProject) {
       lines.push(`  Default Project: ${report.config.defaultProject}`);
     }

package/skills/codebase-navigation/SKILL.md

@@ -1,105 +0,0 @@
----
-name: codebase-navigation
-description: "Use when navigating the openclaw-plugin codebase for the first time, looking for where a tool is registered, understanding the monolithic index.ts structure, or adding a new tool or hook."
----
-
-# Codebase Navigation
-
-The plugin is a single monolithic `index.ts` (4839 lines) plus a few extracted modules.
-
-## index.ts File Map
-
-| Lines | Section |
-|-------|---------|
-| 1--14 | Header comments and version info |
-| 16--36 | Imports (plugin SDK, heartbeat, CLI stats, onboarding) |
-| 38--47 | Constants (`DEFAULT_API_URL`, `REQUEST_TIMEOUT_MS`, `MAX_RETRIES`) |
-| 48--121 | `DebugLogger` class (inlined) with `LogEntry`, `DebugLoggerConfig` |
-| 123--404 | `StatusReporter` class (inlined) with `ToolStatus`, `ConnectionStatus`, `MemoryStats` |
-| 406--461 | Types: `AutoCaptureConfig`, `MemoryRelayConfig`, `Memory`, `SearchResult`, `Stats` |
-| 463--648 | Utility functions: `sleep`, `isRetryableError`, `fetchWithTimeout`, auto-capture helpers, `redactSensitive`, `extractRescueContent` |
-| 650--1294 | `MemoryRelayClient` class (API client with retry logic, all endpoints) |
-| 1296--1315 | Pattern detection for auto-capture (`CAPTURE_PATTERNS`, `shouldCapture`) |
-| 1317--1562 | Plugin entry: `export default async function plugin(api)`, config resolution, client init, session cache, `touchSession` |
-| 1564--1613 | `TOOL_GROUPS` map and `isToolEnabled()` |
-| 1615--3747 | 39 tool registrations |
-| 3749--3853 | CLI commands (`memoryrelay status/stats/list/export`) |
-| 3855--4240 | 14 lifecycle hooks (`before_agent_start`, `agent_end`, `session_start`, `session_end`, `before_tool_call`, `after_tool_call`, `before_compaction`, `before_reset`, `message_received`, `message_sending`, `before_message_write`, `subagent_spawned`, `subagent_ended`, `tool_result_persist`) |
-| 4242--4274 | First-run onboarding |
-| 4276--4586 | Gateway methods (`memoryrelay.logs`, `.health`, `.metrics`, `.heartbeat`, `.onboarding`, `.stats`, `.test`) |
-| 4588--4790 | Direct commands: `/memory-status`, `/memory-stats`, `/memory-health`, `/memory-logs`, `/memory-metrics` |
-| 4792--4839 | Stale session cleanup service (`memoryrelay-session-cleanup` via `api.registerService`) |
-
-## Tool Registration Pattern
-
-Every tool follows this pattern:
-
-```typescript
-if (isToolEnabled("tool_name")) {
-  api.registerTool((ctx) => ({
-    name: "tool_name",
-    description: "...",
-    parameters: { /* JSON schema */ },
-    execute: async (_id, args) => { /* impl */ }
-  }), { name: "tool_name" });
-}
-```
-
-Tools are numbered 1--39 with comment markers (e.g., `// 1. memory_store`). Search for `// N.` to jump to a specific tool.
-
-## TOOL_GROUPS (line 1569)
-
-| Group | Count | Tools |
-|-------|-------|-------|
-| memory | 9 | `memory_store`, `memory_recall`, `memory_forget`, `memory_list`, `memory_get`, `memory_update`, `memory_batch_store`, `memory_context`, `memory_promote` |
-| entity | 4 | `entity_create`, `entity_link`, `entity_list`, `entity_graph` |
-| agent | 3 | `agent_list`, `agent_create`, `agent_get` |
-| session | 4 | `session_start`, `session_end`, `session_recall`, `session_list` |
-| decision | 4 | `decision_record`, `decision_list`, `decision_supersede`, `decision_check` |
-| pattern | 4 | `pattern_create`, `pattern_search`, `pattern_adopt`, `pattern_suggest` |
-| project | 10 | `project_register`, `project_list`, `project_info`, `project_add_relationship`, `project_dependencies`, `project_dependents`, `project_related`, `project_impact`, `project_shared_patterns`, `project_context` |
-| health | 1 | `memory_health` |
-
-The `enabledTools` config option accepts a comma-separated list of group names (or `"all"`).
-
-## Supporting Modules
-
-| File | Purpose |
-|------|---------|
-| `src/debug-logger.ts` | `DebugLogger` class (source of the inlined copy) |
-| `src/status-reporter.ts` | `StatusReporter` class (source of the inlined copy) |
-| `src/heartbeat/daily-stats.ts` | Morning/evening summaries, `calculateStats`, `formatStatsForDisplay` |
-| `src/onboarding/first-run.ts` | Onboarding wizard: `checkFirstRun`, `runSimpleOnboarding` |
-| `src/cli/stats-command.ts` | CLI `stats` command handler |
-
-## Configuration Fallback Chain
-
-```
-Plugin config (openclaw.json) -> Env vars -> Defaults
-```
-
-- `apiKey`: `cfg.apiKey` -> `MEMORYRELAY_API_KEY` (required, no default)
-- `agentId`: `cfg.agentId` -> `MEMORYRELAY_AGENT_ID` -> `api.agentName`
-- `apiUrl`: `cfg.apiUrl` -> `MEMORYRELAY_API_URL` -> `https://api.memoryrelay.net`
-
-## Key Types
-
-| Type | Location | Purpose |
-|------|----------|---------|
-| `Memory` | L442 | Core memory record (`id`, `content`, `agent_id`, `metadata`, `entities`) |
-| `SearchResult` | L453 | Vector search hit (`memory`, `score`) |
-| `Stats` | L458 | Agent statistics (`total_memories`, `last_updated`) |
-| `LogEntry` | L52 | Debug log entry (tool, method, path, duration, status) |
-| `DebugLoggerConfig` | L66 | Logger settings (enabled, verbose, maxEntries) |
-| `ConnectionStatus` | L140 | API connection state (status, endpoint, responseTime) |
-| `ToolStatus` | L127 | Per-group tool health (enabled, available, failed) |
-
-## Key Helpers
-
-| Function | Location | Purpose |
-|----------|----------|---------|
-| `redactSensitive` | L591 | Replace blocklist patterns with `[REDACTED]` |
-| `extractRescueContent` | L608 | Salvage assistant messages before compaction/reset |
-| `touchSession` | L1444 | Update `lastActivityAt` timestamp in session cache |
-| `isToolEnabled` | L1605 | Check if a tool's group is in the enabled set |
-| `shouldCapture` | L1310 | Test text against `CAPTURE_PATTERNS` for auto-capture |

package/skills/release-process/SKILL.md

@@ -1,83 +0,0 @@
----
-name: release-process
-description: "Use when bumping the plugin version, preparing a release, updating the CHANGELOG, creating a pre-release audit branch, or triggering the NPM publish workflow."
----
-
-# Release Process
-
-## Semantic Versioning (0.x series)
-
-| Bump | When | Example |
-|------|------|---------|
-| **Patch** (0.x.Y) | Bug fixes, version string updates, doc fixes | 0.12.10 → 0.12.11 |
-| **Minor** (0.X.0) | New tools, new features, new config options | 0.12.11 → 0.13.0 |
-| **Major** (X.0.0) | Breaking API changes (not used yet) | 0.13.0 → 1.0.0 |
-
-## Version Bump Locations
-
-All three files must match the same version string:
-
-| File | Field |
-|------|-------|
-| `package.json` | `"version": "X.Y.Z"` |
-| `openclaw.plugin.json` | `"version": "X.Y.Z"` and description string |
-| `index.ts` | Header comment `Version: X.Y.Z` |
-
-## CHANGELOG.md Format
-
-Follows [Keep a Changelog](https://keepachangelog.com/). Each release entry:
-
-```markdown
-## [X.Y.Z] - YYYY-MM-DD
-### Added
-- **Feature Name**: Description
-### Changed
-- Description
-### Fixed
-- **Bug Name**: Description
-```
-
-Add a comparison link at the bottom of the file:
-
-```
-[X.Y.Z]: https://github.com/memoryrelay/openclaw-plugin/compare/vPREV...vX.Y.Z
-```
-
-## Git Commit Conventions
-
-| Prefix | Use |
-|--------|-----|
-| `feat:` | New features or tools |
-| `fix:` | Bug fixes |
-| `docs:` | Documentation changes |
-| `chore:` | Maintenance, deps, cleanup |
-
-## CI/CD Workflows
-
-| File | Trigger | Purpose |
-|------|---------|---------|
-| `.github/workflows/ci.yml` | Push/PR to main | Tests on Node 20.x + 22.x matrix |
-| `.github/workflows/ci-cd.yml` | Push/PR | Full CI/CD pipeline |
-| `.github/workflows/publish.yml` | Manual dispatch | NPM publish with version verification |
-
-The publish workflow runs `npm publish --provenance --access public` and requires the `NPM_TOKEN` secret.
-
-## Pre-Release Audit Branch
-
-For doc review before release, create an audit branch:
-
-```
-docs/pre-release-audit-v{version}
-```
-
-Example: `docs/pre-release-audit-v0.12.11`. Merge to main once the audit is complete.
-
-## Release Checklist
-
-1. Update version in all 3 locations (`package.json`, `openclaw.plugin.json`, `index.ts`)
-2. Update `CHANGELOG.md` with new entry and comparison link
-3. Run `npm test` -- all tests must pass
-4. Create audit branch (`docs/pre-release-audit-v{version}`) if doc changes are needed
-5. Merge audit branch to main
-6. Trigger the `publish.yml` workflow manually from GitHub Actions
-7. Verify the published package on NPM

package/skills/testing-memoryrelay/SKILL.md

@@ -1,87 +0,0 @@
----
-name: testing-memoryrelay
-description: "Use when writing, running, or debugging tests for the MemoryRelay plugin, adding test coverage for new tools or hooks, or investigating test failures."
----
-
-# Testing MemoryRelay
-
-Test runner: **Vitest**. All tests run without a live API.
-
-## Commands
-
-| Command | Purpose |
-|---------|---------|
-| `npm test` | Run all tests once (`vitest run`) |
-| `npm run test:watch` | Watch mode (`vitest`) |
-| `npm run test:coverage` | Coverage report (`vitest run --coverage`) |
-
-## Test Files
-
-| File | Scope |
-|------|-------|
-| `index.test.ts` | Integration tests: API client, tools, hooks, retry logic, pattern detection, channel filtering, tool groups, workflow instructions |
-| `src/debug-logger.test.ts` | DebugLogger unit tests: circular buffer, filtering by tool/status, stats, formatting |
-| `src/status-reporter.test.ts` | StatusReporter unit tests: failure tracking, report building, formatting |
-
-## Mock Pattern
-
-Tests use `MockMemoryRelayClient` -- an in-memory implementation that replaces the real API client:
-
-```typescript
-import { describe, test, expect, beforeEach, vi } from "vitest";
-
-class MockMemoryRelayClient {
-  private memories: Memory[] = [];
-  private nextId = 1;
-  async store(content, metadata?) { /* push to array, return Memory */ }
-  async search(query, limit?, threshold?) { /* keyword .includes() match */ }
-  async list(limit?, offset?) { /* .slice() */ }
-  async get(id) { /* .find(), throws if missing */ }
-  async delete(id) { /* .splice(), throws if missing */ }
-  async health() { return { status: "healthy" }; }
-  async stats() { return { total_memories: this.memories.length }; }
-}
-```
-
-Instantiate fresh per test with `beforeEach(() => { client = new MockMemoryRelayClient("test_key", "test_agent"); })`.
-
-## What to Test per Tool
-
-| Area | Checks |
-|------|--------|
-| Input validation | Required params present, types correct |
-| Success path | API response formatted correctly, data stored/returned |
-| Error handling | Non-existent IDs throw, empty results return `[]` |
-| Deduplication | `deduplicate=true` prevents near-duplicate storage |
-| Session injection | `session_id` auto-applied from active session |
-| Retry logic | Network errors and 5xx retried; 4xx not retried |
-| Timeouts | 30s timeout via `AbortController` |
-
-## Testing Hooks
-
-**`before_agent_start`** -- workflow injection and auto-recall:
-
-- Verify workflow instructions are built from enabled tool groups
-- Mock `client.search()` to test auto-recall injects context
-- Test channel exclusion skips auto-recall for blocklisted channels
-
-**`agent_end`** -- auto-capture:
-
-- Test pattern detection (`shouldCapture`) with regex matching
-- Verify length bounds (20-2000 chars)
-- Confirm privacy blocklist rejects passwords, SSNs, API keys
-- Test tier logic: `off`, `conservative`, `smart`, `aggressive`
-
-## Testing Gateway Methods
-
-| Check | How |
-|-------|-----|
-| Response format | Assert returned object shape matches API contract |
-| Error surfaces | `detail` field extracted (FastAPI format), falls back to `message` |
-| HTTP method | GET with query params for search/check; POST with body for create/link |
-
-## Unit Test Patterns
-
-**DebugLogger**: Uses `vi.mock("fs")`. Test circular buffer (`maxEntries`), `getRecentLogs(n)`, `getToolLogs(name)`, `getErrorLogs()`, `getStats()`, `clear()`, `formatEntry()`.
-
-**StatusReporter**: Instantiate with real `DebugLogger`. Test `recordFailure`/`recordSuccess` toggle, `buildReport` shape, `formatReport`/`formatCompact` output, disconnected status handling.