brainclaw 0.20.0 → 0.21.0

package/README.md

@@ -78,8 +78,9 @@ brainclaw is designed to sit alongside the coding agents teams are already using
 | [![Continue](https://img.shields.io/badge/Continue-2563EB?logoColor=white)](https://github.com/continuedev/continue) | **[Continue](https://github.com/continuedev/continue)** | Standard | MCP + .continue/rules/ |
 | [![Gemini CLI](https://img.shields.io/badge/Gemini_CLI-1A73E8?logo=googlegemini&logoColor=white)](https://github.com/google-gemini/gemini-cli) | **[Antigravity / Gemini CLI](https://github.com/google-gemini/gemini-cli)** | Standard | MCP + GEMINI.md |
 | [![GitHub Copilot](https://img.shields.io/badge/GitHub_Copilot-181717?logo=githubcopilot&logoColor=white)](https://github.com/features/copilot) | **[GitHub Copilot](https://github.com/features/copilot)** | Limited | copilot-instructions.md + brainclaw-context skill |
+| [![OpenClaw](https://img.shields.io/badge/OpenClaw-FF6B35?logoColor=white)](https://github.com/openclaw/openclaw) | **[OpenClaw](https://github.com/openclaw/openclaw)** | Limited | brainclaw skill (SKILL.md) for structured project memory |
 
-**Full** = MCP + hooks + auto-approve (context injected every prompt). **Standard** = MCP + instruction file (agent must call tools explicitly). **Limited** = no MCP (static instruction file is the only source of context).
+**Full** = MCP + hooks + auto-approve (context injected every prompt). **Standard** = MCP + instruction file (agent must call tools explicitly). **Limited** = skill-based (agent calls brainclaw CLI via skill instructions).
 
 brainclaw is most effective today when one agent works at a time in a given checkout and the next agent resumes from shared context, claims, and handoffs.
 

package/dist/commands/setup.js

@@ -25,6 +25,7 @@ export const ALL_KNOWN_AGENTS = [
     'antigravity',
     'continue',
     'roo',
+    'openclaw',
 ];
 const BRAINCLAW_ASCII = [
     '',

package/dist/core/agent-capability.js

@@ -129,6 +129,18 @@ const PROFILES = {
         mcpConfigScope: 'none',
         templateTier: 'C',
     },
+    openclaw: {
+        name: 'openclaw',
+        hasMcp: false,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: true,
+        hasRules: false,
+        instructionFile: 'skills/openclaw/SKILL.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'none',
+        templateTier: 'C',
+    },
 };
 /**
  * Get the capability profile for a known agent.

package/dist/core/agent-integrations.js

@@ -57,6 +57,9 @@ const DEFAULT_SURFACES = {
         { kind: 'instructions', location: 'workspace', path: '.roo/rules/brainclaw.md' },
         { kind: 'mcp', location: 'workspace', path: '.roo/mcp.json' },
     ],
+    'openclaw': [
+        { kind: 'skill', location: 'machine', path: '.openclaw/workspace/skills/brainclaw/SKILL.md' },
+    ],
 };
 function mergeSurfaces(current, next) {
     const merged = [...current];

package/dist/core/ai-agent-detection.js

@@ -6,18 +6,20 @@ import os from 'node:os';
  * environment variables and well-known config paths. Returns the first confident
  * match, or undefined if no agent is detected.
  *
- * Detection order (highest confidence first):
+ * Detection order (highest confidence first — agents with dedicated env vars
+ * are tested before agents detected via passive/ambient env vars):
  * 1. BRAINCLAW_AGENT env var (explicit override)
- * 2. GitHub Copilot (VSCODE_GIT_IPC_HANDLE or VSCODE_INJECTION, then GITHUB_COPILOT_*)
- * 3. Claude Code (CLAUDE_CODE_VERSION or ANTHROPIC_AI_PRODUCT)
- * 4. Cursor (CURSOR_TRACE_ID or CURSOR_*)
- * 5. Windsurf (WINDSURF_*)
- * 6. Cline (CLINE_*)
+ * 2. Claude Code (CLAUDE_CODE_VERSION — set by Claude Code itself)
+ * 3. Cursor (CURSOR_TRACE_ID — set by Cursor itself)
+ * 4. Windsurf (WINDSURF_SESSION_ID — set by Windsurf itself)
+ * 5. Cline (CLINE_AGENT — set by Cline itself)
+ * 6. GitHub Copilot (GITHUB_COPILOT_PRODUCT — passive VS Code env, tested after active agents)
  * 7. Codex CLI (~/.codex/ directory exists)
  * 8. OpenCode (OPENCODE_* env or ~/.config/opencode/)
  * 9. Antigravity / Gemini CLI (ANTIGRAVITY_* env or ~/.gemini/antigravity/)
  * 10. Continue (CONTINUE_*)
  * 11. Roo Code (ROO_*)
+ * 12. OpenClaw (~/.openclaw/ or OPENCLAW_*)
  */
 export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
     // Explicit override
@@ -29,24 +31,14 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'BRAINCLAW_AGENT env var',
         };
     }
-    // GitHub Copilot — VS Code extension or Copilot Chat
-    if (env.GITHUB_COPILOT_TOKEN ||
-        env.GITHUB_COPILOT_PRODUCT ||
-        (env.VSCODE_GIT_IPC_HANDLE && (env.AGENT_NAME?.toLowerCase().includes('copilot') || env.GH_COPILOT_AGENT))) {
-        return {
-            name: 'github-copilot',
-            kind: 'agent',
-            trust_level: 'trusted',
-            detection_source: 'GITHUB_COPILOT_* env var',
-        };
-    }
-    // Claude Code (Anthropic's CLI coding agent)
+    // Claude Code — tested BEFORE Copilot because both can be present in VS Code.
+    // CLAUDE_CODE_VERSION is set by Claude Code itself, not by VS Code passively.
     if (env.CLAUDE_CODE_VERSION || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
         return {
             name: 'claude-code',
             kind: 'agent',
             trust_level: 'trusted',
-            detection_source: 'CLAUDE_CODE_VERSION env var',
+            detection_source: env.CLAUDE_CODE_VERSION ? 'CLAUDE_CODE_VERSION env var' : 'ANTHROPIC_AI_PRODUCT env var',
         };
     }
     // Cursor IDE
@@ -76,6 +68,20 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'CLINE_* env var',
         };
     }
+    // GitHub Copilot — tested AFTER agents with dedicated env vars.
+    // GITHUB_COPILOT_TOKEN and GITHUB_COPILOT_PRODUCT are set passively by VS Code
+    // whenever the Copilot extension is installed, even when another agent is active.
+    // We only match if no higher-priority agent was detected above.
+    if (env.GITHUB_COPILOT_PRODUCT ||
+        (env.GITHUB_COPILOT_TOKEN && !env.CLAUDE_CODE_VERSION && !env.CURSOR_TRACE_ID && !env.WINDSURF_SESSION_ID) ||
+        (env.VSCODE_GIT_IPC_HANDLE && (env.AGENT_NAME?.toLowerCase().includes('copilot') || env.GH_COPILOT_AGENT))) {
+        return {
+            name: 'github-copilot',
+            kind: 'agent',
+            trust_level: 'trusted',
+            detection_source: env.GITHUB_COPILOT_PRODUCT ? 'GITHUB_COPILOT_PRODUCT env var' : 'GITHUB_COPILOT_TOKEN env var',
+        };
+    }
     // OpenAI Codex CLI (~/.codex/ presence)
     if (fs.existsSync(path.join(homeDir, '.codex'))) {
         return {
@@ -121,6 +127,15 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: 'ROO_* env var',
         };
     }
+    // OpenClaw (~/.openclaw/ presence or OPENCLAW_* env)
+    if (env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT || fs.existsSync(path.join(homeDir, '.openclaw'))) {
+        return {
+            name: 'openclaw',
+            kind: 'agent',
+            trust_level: 'trusted',
+            detection_source: env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT ? 'OPENCLAW_* env var' : '~/.openclaw directory',
+        };
+    }
     return undefined;
 }
 /**

package/dist/core/schema.js

@@ -624,6 +624,7 @@ export const AgentIntegrationNameSchema = z.enum([
     'antigravity',
     'continue',
     'roo',
+    'openclaw',
 ]);
 export const AgentIntegrationSurfaceKindSchema = z.enum(['instructions', 'mcp', 'skill', 'rule', 'hook']);
 export const AgentIntegrationLocationSchema = z.enum(['workspace', 'machine']);

package/docs/integrations/openclaw.md

@@ -0,0 +1,98 @@
+# OpenClaw Integration
+
+## Why brainclaw for OpenClaw users
+
+OpenClaw's built-in memory (`MEMORY.md` + daily logs) is great for personal notes and preferences, but it doesn't distinguish between different types of project knowledge. After many conversations, constraints get buried, decisions lose their reasoning, and the agent drifts from its original instructions.
+
+brainclaw adds a structured memory layer on top:
+
+| Problem | OpenClaw alone | With brainclaw |
+|---|---|---|
+| "Don't deploy on Friday" gets forgotten | Buried in MEMORY.md after 50 conversations | Stored as a constraint, always visible |
+| Agent repeats a known mistake | No trap system | Traps scored by relevance to current scope |
+| Two agents work on same file | No coordination | Claims prevent collisions |
+| Decision reasoning is lost | Mixed with daily notes | Preserved as typed decisions, searchable |
+
+## How it works
+
+brainclaw integrates as an OpenClaw **skill**. The skill instructs the agent to:
+
+1. Load brainclaw project context before any coding work
+2. Record constraints, traps, and decisions in brainclaw (not MEMORY.md)
+3. Keep MEMORY.md for personal preferences and daily observations
+4. Coordinate with other agents through plans and claims
+
+## Installation
+
+### Prerequisites
+
+```bash
+npm install -g brainclaw
+```
+
+### Install the skill
+
+```bash
+brainclaw enable-agent openclaw
+```
+
+This copies the brainclaw skill to `~/.openclaw/workspace/skills/brainclaw/`.
+
+Or manually:
+
+```bash
+mkdir -p ~/.openclaw/workspace/skills/brainclaw
+cp "$(npm root -g)/brainclaw/skills/openclaw/SKILL.md" ~/.openclaw/workspace/skills/brainclaw/
+```
+
+### Initialize a project
+
+```bash
+cd /path/to/your/project
+brainclaw init
+```
+
+### Restart OpenClaw
+
+```
+/new
+```
+
+or restart the Gateway. The brainclaw skill will be loaded automatically.
+
+## What the agent sees
+
+After installation, your OpenClaw agent will:
+
+- Run `brainclaw context` before project work to load constraints, traps, and plans
+- Record rules you give it as brainclaw constraints (not just MEMORY.md entries)
+- Record problems it discovers as traps (with severity)
+- Log architectural decisions with their reasoning
+- Clean up with `brainclaw session-end` when finished
+
+## Memory split
+
+The brainclaw skill establishes a clear split:
+
+- **MEMORY.md** — your preferences, habits, personal context (OpenClaw manages this)
+- **brainclaw** — project constraints, traps, decisions, plans (shared with all agents)
+
+This means if you switch from OpenClaw to Claude Code or Codex for coding, the project memory follows — it's in `.brainclaw/`, not in `~/.openclaw/`.
+
+## Multi-agent coordination
+
+If you use both OpenClaw and a coding agent (Claude Code, Cursor, etc.) on the same project, brainclaw coordinates between them:
+
+- OpenClaw records a constraint → Claude Code sees it at next session
+- Claude Code claims a file scope → OpenClaw knows not to edit there
+- Either agent creates a plan → both see it in their context
+
+## Profile
+
+When loading context for OpenClaw, use the `openclaw` profile for optimized scoring:
+
+```bash
+brainclaw context --profile openclaw
+```
+
+This boosts constraints, handoffs, and runtime notes — the items most relevant to an agent that might not be editing code directly but needs to understand the project state.

package/docs/integrations/overview.md

@@ -69,6 +69,7 @@ The agent cannot call brainclaw tools at all. The instruction file becomes the o
 | **Codex** | ✔ global | AGENTS.md | — | — | — |
 | **Gemini CLI** | ✔ global | GEMINI.md | — | — | — |
 | **Copilot** | — | .github/copilot-instructions.md | — | — | ✔ brainclaw-context |
+| **OpenClaw** | — | — | — | — | ✔ brainclaw skill |
 
 **Legend:** ✔ = fully supported, ◐ = partial (static trigger, not dynamic injection), — = not available
 
@@ -98,3 +99,4 @@ Running multiple agents in parallel on the same checkout will create conflicts.
 - [cursor.md](cursor.md)
 - [codex.md](codex.md)
 - [copilot.md](copilot.md)
+- [openclaw.md](openclaw.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {