brainclaw 0.24.0 → 0.25.3

package/dist/cli.js

@@ -963,6 +963,7 @@ program
     .description('Export memory as instructions for IDE/AI tools')
     .option('--format <format>', 'Format: copilot-instructions, cursor-rules, agents-md, claude-md, gemini-md, windsurf, cline, roo, continue')
     .option('--detect', 'Auto-detect agent environment and write to its native file')
+    .option('--all', 'Write all known agent instruction files at once (claude-md, agents-md, copilot-instructions, cursor-rules, etc.)')
     .option('--write', 'Write to canonical file path instead of stdout (when --format is given); local files are gitignored by default')
     .option('--shared', 'Keep the main exported instruction file versionable instead of auto-ignoring it (companions remain local)')
     .option('--output <file>', 'Write to a specific file path instead of stdout')

package/dist/commands/claim.js

@@ -5,7 +5,7 @@ import { saveClaim, generateClaimId, listClaims } from '../core/claims.js';
 import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
 import { nowISO } from '../core/ids.js';
-import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveCurrentModel } from '../core/agent-registry.js';
 import { validateCliTtl } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
 function parseTtl(ttl) {
@@ -72,6 +72,7 @@ export function runClaim(description, options) {
         plan_id: options.plan,
         status: 'active',
         expires_at: options.ttl ? parseTtl(options.ttl) : undefined,
+        model: resolveCurrentModel(options.cwd),
     };
     mutate({ cwd: options.cwd }, () => {
         if (plan) {

package/dist/commands/context-diff.js

@@ -1,5 +1,14 @@
 import { buildContextDiff, resolveContextDiffSince } from '../core/context-diff.js';
+import { listClaims, isClaimExpired } from '../core/claims.js';
+import { loadInstructions, resolveInstructions } from '../core/instructions.js';
 import { memoryExists } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { isTrapActive } from '../core/traps.js';
+/**
+ * Hybrid context-diff: always includes critical anchors (active claims,
+ * top traps, instructions) so the agent stays grounded, plus the memory
+ * delta since last context read.
+ */
 export function runContextDiff(options = {}) {
     if (!memoryExists(options.cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
@@ -20,13 +29,62 @@ export function runContextDiff(options = {}) {
         process.exit(1);
     }
     if (options.json) {
-        console.log(JSON.stringify(diff, null, 2));
+        const anchors = buildCriticalAnchors(options.cwd);
+        console.log(JSON.stringify({ ...diff, anchors }, null, 2));
         return;
     }
+    const lines = [];
+    // --- Critical anchors (always present) ---
+    const anchors = buildCriticalAnchors(options.cwd);
+    if (anchors.claims.length > 0) {
+        lines.push('Active claims:');
+        for (const c of anchors.claims) {
+            lines.push(`- [${c.id}] ${c.agent} → ${c.scope}: ${c.description}`);
+        }
+        lines.push('');
+    }
+    if (anchors.instructions.length > 0) {
+        lines.push('Instructions:');
+        for (const ins of anchors.instructions) {
+            const scope = ins.scope ? `:${ins.scope}` : '';
+            lines.push(`- [${ins.id}] <${ins.layer}${scope}> ${ins.text}`);
+        }
+        lines.push('');
+    }
+    if (anchors.traps.length > 0) {
+        lines.push('Active traps:');
+        for (const t of anchors.traps) {
+            lines.push(`- [${t.id}] (${t.severity}) ${t.text}`);
+        }
+        lines.push('');
+    }
+    // --- Memory delta ---
     if (diff.counts.total === 0) {
-        console.log(`${diff.summary} since ${diff.since}.`);
-        return;
+        lines.push(`Memory: no changes since ${diff.since?.slice(0, 16).replace('T', ' ')}.`);
     }
-    console.log(`${diff.summary} since ${diff.since}.`);
+    else {
+        lines.push(`Memory delta (${diff.summary}):`);
+        for (const item of diff.changed_items ?? []) {
+            lines.push(`- [${item.section}] [${item.id}] ${item.text}`);
+        }
+    }
+    console.log(lines.join('\n'));
+}
+function buildCriticalAnchors(cwd) {
+    const activeClaims = listClaims(cwd)
+        .filter((c) => c.status === 'active' && !isClaimExpired(c))
+        .map((c) => ({ id: c.id, agent: c.agent, scope: c.scope, description: c.description }));
+    const instructions = resolveInstructions(loadInstructions(cwd))
+        .map((ins) => ({ id: ins.id, layer: ins.layer, scope: ins.scope, text: ins.text }));
+    const state = loadState(cwd);
+    const traps = state.known_traps
+        .filter((t) => isTrapActive(t))
+        .sort((a, b) => {
+        const severityOrder = { high: 0, medium: 1, low: 2 };
+        return (severityOrder[a.severity] ?? 1) - (severityOrder[b.severity] ?? 1);
+    })
+        .slice(0, 5)
+        .map((t) => ({ id: t.id, severity: t.severity, text: t.text }));
+    return { claims: activeClaims, instructions, traps };
 }
 //# sourceMappingURL=context-diff.js.map

package/dist/commands/export.js

@@ -6,7 +6,7 @@ import { loadConfig, saveConfig } from '../core/config.js';
 import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
 import { resolveInstructions, loadInstructions } from '../core/instructions.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
-import { resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
+import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
 import { logger } from '../core/logger.js';
 import { getAgentCapabilityProfile } from '../core/agent-capability.js';
 import { renderBrainclawSection } from '../core/instruction-templates.js';
@@ -17,6 +17,10 @@ export function runExport(options) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
+    if (options.all) {
+        runExportAll(cwd, options);
+        return;
+    }
     if (options.detect) {
         if (options.shared) {
             console.error('Error: --shared cannot be used with --detect. Use `brainclaw export --format <format> --write --shared` to publish a specific instruction file.');
@@ -26,7 +30,7 @@ export function runExport(options) {
         return;
     }
     if (!options.format) {
-        console.error('Error: --format or --detect is required.');
+        console.error('Error: --format, --detect, or --all is required.');
         process.exit(1);
     }
     const content = generateExport(options.format, options, cwd);
@@ -90,6 +94,40 @@ function runExportDetect(cwd, options) {
         }
     }
 }
+function runExportAll(cwd, options) {
+    // Deduplicate by format (e.g. codex and opencode both use agents-md)
+    const seen = new Set();
+    const targets = AGENT_EXPORT_REGISTRY.filter((t) => {
+        if (seen.has(t.format))
+            return false;
+        seen.add(t.format);
+        return true;
+    });
+    let written = 0;
+    const allGitignoreEntries = [];
+    for (const target of targets) {
+        try {
+            const content = generateExport(target.format, options, cwd);
+            const result = writeExportFile(content, target.relativePath, cwd);
+            const autoConfigs = writeExportCompanionFiles(target.format, cwd);
+            const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs);
+            allGitignoreEntries.push(...gitignoreEntries);
+            declareAgentIntegrationFromTarget(cwd, target.agentName, 'manual');
+            console.log(`✔ ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
+            written++;
+        }
+        catch (err) {
+            logger.debug(`Failed to export ${target.format}:`, err);
+            console.warn(`⚠ Skipped ${target.format}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Consolidate gitignore entries
+    if (allGitignoreEntries.length > 0) {
+        ensureGitignoreEntries(cwd, [...new Set(allGitignoreEntries)]);
+        console.log('✔ Updated .gitignore');
+    }
+    console.log(`✔ Exported ${written} agent file(s)`);
+}
 export function writeAgentExportForAgent(agentName, cwd) {
     const rendered = renderAgentExportForAgent(agentName, cwd);
     if (!rendered) {

package/dist/commands/init.js

@@ -245,6 +245,8 @@ export async function runInit(options = {}) {
     if (initMemoryRepo(cwd)) {
         console.log('✔ Initialized memory git repo for versioning');
     }
+    // Install post-merge hook for auto-release of claims after merge
+    installPostMergeHookIfMissing(cwd);
     const onboardingPreflight = runBootstrapProfile({ cwd, refresh: true });
     console.log('');
     console.log('Onboarding preflight:');
@@ -268,6 +270,45 @@ export async function runInit(options = {}) {
     console.log('');
     console.log(`Tip: run 'brainclaw context --json' to load the shared memory into your agent session.`);
 }
+function installPostMergeHookIfMissing(cwd) {
+    try {
+        let dir = path.resolve(cwd);
+        let gitRoot;
+        while (true) {
+            if (fs.existsSync(path.join(dir, '.git'))) {
+                gitRoot = dir;
+                break;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        if (!gitRoot)
+            return;
+        const hooksDir = path.join(gitRoot, '.git', 'hooks');
+        const hookPath = path.join(hooksDir, 'post-merge');
+        if (fs.existsSync(hookPath))
+            return; // don't overwrite existing hooks
+        if (!fs.existsSync(hooksDir))
+            fs.mkdirSync(hooksDir, { recursive: true });
+        const script = [
+            '#!/bin/sh',
+            '# brainclaw post-merge hook — auto-release claims on merged files',
+            'BCLAW_CMD=""',
+            'if command -v brainclaw >/dev/null 2>&1; then BCLAW_CMD="brainclaw"',
+            'elif command -v bclaw >/dev/null 2>&1; then BCLAW_CMD="bclaw"',
+            'else BCLAW_CMD="npx --no brainclaw"; fi',
+            '$BCLAW_CMD release-claims --from-git-diff 2>/dev/null || true',
+            '',
+        ].join('\n');
+        fs.writeFileSync(hookPath, script, { encoding: 'utf-8', mode: 0o755 });
+        console.log('✔ Installed post-merge hook for auto-release of claims');
+    }
+    catch {
+        // Non-critical — skip silently
+    }
+}
 function resolveStorageDir(storageDir) {
     const candidate = (storageDir ?? MEMORY_DIR).trim();
     if (candidate !== MEMORY_DIR) {

package/dist/commands/mcp.js

@@ -18,7 +18,7 @@ import { acceptCandidate } from './accept.js';
 import { rejectCandidate } from './reject.js';
 import { startSession } from './session-start.js';
 import { endSession } from './session-end.js';
-import { agentCanWriteDirect, AgentIdentityResolutionError, AgentTrustError, listAgentIdentities, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveAgentScope, resolveCurrentAgentIdentity, resolveCurrentAgentName, } from '../core/agent-registry.js';
+import { agentCanWriteDirect, AgentIdentityResolutionError, AgentTrustError, listAgentIdentities, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveAgentScope, resolveCurrentAgentIdentity, resolveCurrentAgentName, resolveCurrentModel, } from '../core/agent-registry.js';
 import { appendAuditEntry } from '../core/audit.js';
 import { nowISO, generateIdWithLabel, generateId } from '../core/ids.js';
 import { inferProjectFromTarget, loadInstructions, resolveInstructions } from '../core/instructions.js';
@@ -156,6 +156,10 @@ export const MCP_READ_TOOLS = [
                 type: { type: 'string', description: 'Filter by plan type.' },
                 assignee: { type: 'string', description: 'Filter by assignee name.' },
                 project: { type: 'string', description: 'Filter by project namespace.' },
+                id: { type: 'string', description: 'Get a single plan by ID (exact match).' },
+                limit: { type: 'number', description: 'Maximum number of plans to return (default: 20).' },
+                offset: { type: 'number', description: 'Number of plans to skip (for pagination).' },
+                compact: { type: 'boolean', description: 'Return only key fields (id, short_label, text, status, priority) to reduce output size.' },
             },
         },
     },
@@ -1308,6 +1312,18 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     }
     if (name === 'bclaw_list_plans') {
         let plans = loadState(cwd).plan_items;
+        // Direct lookup by ID
+        if (args.id) {
+            const plan = plans.find((p) => p.id === String(args.id) || p.short_label === String(args.id));
+            if (!plan) {
+                return { content: [{ type: 'text', text: `Plan '${args.id}' not found.` }], structuredContent: { total: 0, plans: [] } };
+            }
+            return {
+                content: [{ type: 'text', text: `[${plan.id}] ${plan.text} (${plan.status}, ${plan.priority})` }],
+                structuredContent: { total: 1, plans: [plan] },
+            };
+        }
+        // Filters
         if (!args.all) {
             plans = plans.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
         }
@@ -1325,11 +1341,16 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             const project = String(args.project).toLowerCase();
             plans = plans.filter((plan) => plan.project?.toLowerCase() === project);
         }
-        const lines = plans.length === 0
+        const totalFiltered = plans.length;
+        // Pagination
+        const offset = Math.max(0, Number(args.offset) || 0);
+        const limit = Math.max(1, Number(args.limit) || 20);
+        const paginated = plans.slice(offset, offset + limit);
+        const lines = paginated.length === 0
             ? ['No plan items found.']
             : [
-                `${plans.length} plan item(s):`,
-                ...plans.map((plan) => {
+                `${totalFiltered} plan(s)${totalFiltered > paginated.length ? ` (showing ${offset + 1}-${offset + paginated.length})` : ''}:`,
+                ...paginated.map((plan) => {
                     const meta = [plan.type ?? 'feat', plan.status, plan.priority];
                     if (plan.assignee)
                         meta.push(`assignee ${plan.assignee}`);
@@ -1341,9 +1362,15 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                     return `[${plan.id}] ${plan.text} (${meta.join(' · ')})${tags}`;
                 }),
             ];
+        // Compact mode: strip heavy fields
+        const outputPlans = args.compact
+            ? paginated.map(({ id, short_label, text, status, priority, tags, assignee, type }) => ({
+                id, short_label, text, status, priority, tags, assignee, type,
+            }))
+            : paginated;
         return {
             content: [{ type: 'text', text: lines.join('\n') }],
-            structuredContent: { total: plans.length, plans },
+            structuredContent: { total: totalFiltered, offset, limit, plans: outputPlans },
         };
     }
     if (name === 'bclaw_list_claims') {
@@ -1611,6 +1638,8 @@ export async function executeMcpToolCall(payload) {
                 response: toolResponse(handleMcpReadToolCall(name, args, { cwd })),
             };
         }
+        // Resolve model once for all write operations
+        const currentModel = resolveCurrentModel(cwd);
         if (name === 'bclaw_setup') {
             const step = args.step;
             const choice = args.choice ?? '';
@@ -1794,6 +1823,7 @@ export async function executeMcpToolCall(payload) {
                 autoReflect: args.autoReflect,
                 cwd,
                 sessionId: connectionSessionId,
+                model: currentModel,
             }, false);
             return {
                 response: toolResponse({
@@ -1846,6 +1876,7 @@ export async function executeMcpToolCall(payload) {
                 category: type === 'constraint' ? args.category : undefined,
                 outcome: type === 'decision' ? args.outcome : undefined,
                 plan_id: candidatePlanId,
+                model: currentModel,
                 star_count: 0,
                 starred_by: [],
                 usage_count: 0,
@@ -1949,6 +1980,7 @@ export async function executeMcpToolCall(payload) {
                 created_at: nowISO(),
                 status: 'active',
                 plan_id: args.planId,
+                model: currentModel,
             }, claimCwd);
             appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'claim', item_id: claimId, item_type: 'claim' }, claimCwd);
             const postClaimItems = getTriggeredItems('trigger:post-claim', claimCwd);

package/dist/commands/runtime-note.js

@@ -61,6 +61,7 @@ export function createRuntimeNote(text, options, printSuccess = false) {
         host_id: hostId,
         expires_at: expiresAt,
         note_type: 'observation',
+        model: options.model,
     };
     saveRuntimeNote(note, options.cwd);
     const result = maybeAutoReflectRuntimeNote(note, options);

package/dist/core/schema.js

@@ -164,6 +164,7 @@ export const InstructionEntrySchema = z.object({
     created_at: z.string(),
     updated_at: z.string(),
     author: z.string(),
+    model: z.string().optional(),
     tags: z.array(z.string()).default([]),
     active: z.boolean().default(true),
     supersedes: z.string().optional(),
@@ -184,6 +185,7 @@ export const ProjectCapabilitySchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
 });
 export const ToolTypeSchema = z.enum(['workflow', 'validator', 'generator', 'utility', 'explorer']);
 export const ProjectToolSchema = z.object({
@@ -204,6 +206,7 @@ export const ProjectToolSchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- State schema ---
 export const StateSchema = z.object({
@@ -258,6 +261,7 @@ export const CandidateSchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
     project_id: z.string().optional(),
     host_id: z.string().optional(),
     session_id: z.string().optional(),
@@ -326,6 +330,7 @@ export const ClaimSchema = z.object({
     status: ClaimStatusSchema,
     released_at: z.string().optional(),
     expires_at: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- Runtime notes schemas ---
 export const RuntimeNoteSchema = z.object({
@@ -344,6 +349,7 @@ export const RuntimeNoteSchema = z.object({
     host_id: z.string().optional(),
     expires_at: z.string().optional(),
     note_type: z.enum(['observation', 'session_start', 'session_end']).default('observation'),
+    model: z.string().optional(),
 });
 // --- AI surface task request schemas ---
 export const AiSurfaceTaskStatusSchema = z.enum(['queued', 'in_progress', 'completed', 'cancelled', 'failed']);
@@ -369,6 +375,7 @@ export const AiSurfaceTaskRequestSchema = z.object({
     claimed_at: z.string().optional(),
     completed_at: z.string().optional(),
     result_note: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- Runtime event schemas ---
 export const RuntimeEventTypeSchema = z.enum([
@@ -398,6 +405,7 @@ export const RuntimeEventSchema = z.object({
     to: z.string().optional(),
     related_paths: z.array(z.string()).optional(),
     metadata: z.record(z.unknown()).optional(),
+    model: z.string().optional(),
 });
 // --- Profile schema ---
 export const ProfileSchema = z.enum(['dev', 'openclaw', 'ops', 'research']);

package/docs/cli.md

@@ -86,7 +86,7 @@ brainclaw setup --roots ~/Projects,~/work --agents all  # all agents, multiple r
 
 ### `brainclaw init`
 
-Initialize workspace state for the current project root. Detects the AI agent environment and writes to its native instruction file. `brainclaw setup` must have been run first on this machine. Do not run `init` from inside `.brainclaw/`; that directory is Brainclaw's own memory store, not a project root.
+Initialize workspace state for the current project root. Detects the AI agent environment, writes to its native instruction file, and installs a git post-merge hook for automatic claim release. `brainclaw setup` must have been run first on this machine. Do not run `init` from inside `.brainclaw/`; that directory is Brainclaw's own memory store, not a project root.
 
 | Option | Description |
 |---|---|
@@ -993,13 +993,13 @@ brainclaw context --since-session --max-items 20
 
 ### `brainclaw context-diff`
 
-Show what has changed in shared memory since a reference point.
+Hybrid context view for subsequent prompts: always includes **critical anchors** (active claims, resolved instructions, top 5 traps) plus the memory delta since a reference point. Used by the Claude Code UserPromptSubmit hook after the first prompt.
 
 | Option | Description |
 |---|---|
 | `--since <date>` | Start date for the diff |
 | `--session <id>` | Compare against a specific session start |
-| `--json` | Output as JSON |
+| `--json` | Output as JSON (includes anchors + changed items) |
 
 ```bash
 brainclaw context-diff --session sess_42
@@ -1127,6 +1127,7 @@ Export memory as a native agent instruction file.
 |---|---|
 | `--format <format>` | Target format: `copilot-instructions`, `cursor-rules`, `agents-md`, `claude-md`, `gemini-md`, `windsurf`, `cline`, `roo`, or `continue` |
 | `--detect` | Auto-detect the running agent and write to its native file |
+| `--all` | Write all known agent instruction files at once (deduplicates by format) |
 | `--write` | Write output to the native file path (instead of stdout); generated workspace files are treated as local and added to `.gitignore` |
 | `--shared` | Keep the main exported instruction file versionable when used with `--write`; companion MCP/settings files stay local |
 | `--output <path>` | Write to a custom output path |
@@ -1146,6 +1147,7 @@ brainclaw export --format roo --write                    # .roo/rules/brainclaw.
 brainclaw export --format continue --write               # .continue/rules/brainclaw.md
 brainclaw export --format claude-md --write --shared     # publish CLAUDE.md intentionally
 brainclaw export --format claude-md                      # stdout
+brainclaw export --all                                   # all 9 agent files at once
 ```
 
 `brainclaw export --write` is local-first by default: the generated workspace file and any companion MCP/settings files are added to `.gitignore`. Use `--shared` only when you intentionally want the main instruction file to be committed. `brainclaw export --detect` also writes companion MCP config where relevant, including `opencode.json` for OpenCode and `.gemini/antigravity/mcp_config.json` for Antigravity/Gemini when the local environment is available.
@@ -1174,7 +1176,7 @@ See [adapters/openclaw.md](adapters/openclaw.md).
 
 ### `brainclaw install-hooks`
 
-Install Git hooks for constraint checking.
+Install Git hooks: pre-commit (constraint checking, sensitive content detection) and post-merge (auto-release of claims whose scope overlaps merged files).
 
 | Option | Description |
 |---|---|
@@ -1391,7 +1393,7 @@ brainclaw mcp
 | `bclaw_get_agent_board` | Live plan + claim board with active sessions |
 | `bclaw_search` | Full-text BM25 search across all memory items |
 | `bclaw_estimation_report` | Estimation accuracy report for completed plans |
-| `bclaw_list_plans` | List plan items with the same filters as `brainclaw plan list` |
+| `bclaw_list_plans` | List plan items with filters, pagination (`limit`/`offset`), `compact` mode, and direct `id` lookup |
 | `bclaw_list_claims` | List claims with the same filters as `brainclaw claim list` |
 | `bclaw_list_agents` | List registered agents, optionally with bounded reputation summaries |
 | `bclaw_list_instructions` | List raw or resolved shared instructions |

package/docs/concepts/plans-and-claims.md

@@ -106,6 +106,16 @@ brainclaw claim release <id>
 
 `claim list` shows who holds each claim and whether it is still active. If a claim has a `session_id`, the last 8 characters are shown so you can correlate with the agent session that created it.
 
+### Automatic claim release
+
+Claims are automatically released after a `git merge` if the post-merge hook is installed (default since `brainclaw init` v0.25.3+). The hook matches merged file paths against active claim scopes and releases overlapping claims.
+
+You can also install or reinstall the hook manually:
+
+```bash
+brainclaw install-hooks
+```
+
 ## Why claims matter
 
 Without claims, multiple agents can easily touch the same area at once and generate conflicting changes.

package/docs/integrations/agents.md

@@ -83,7 +83,8 @@ brainclaw export --detect --write          # auto-detect and write all formats
 When brainclaw memory changes (new constraints, resolved traps, updated plans), regenerate instruction files:
 
 ```bash
-brainclaw export --detect --write
+brainclaw export --all              # all 9 agent formats at once
+brainclaw export --detect --write   # only the detected agent
 ```
 
 For agents without MCP (Copilot), this is especially important — the instruction file is their only source of project context.

package/docs/integrations/mcp.md

@@ -42,7 +42,7 @@ This keeps session continuity inside Brainclaw instead of pushing the agent back
 | `bclaw_write_note` | Record a runtime note, supports `autoReflect: true` |
 | `bclaw_read_handoff` | Read active handoffs |
 | `bclaw_get_agent_board` | Coordination snapshot |
-| `bclaw_list_plans` | Structured plan listing with CLI-equivalent filters |
+| `bclaw_list_plans` | Structured plan listing with filters, pagination (`limit`/`offset`), `compact` mode, and `id` lookup |
 | `bclaw_list_claims` | Structured claim listing with CLI-equivalent filters |
 | `bclaw_list_agents` | Registered agent inventory, optionally with bounded reputation |
 | `bclaw_list_instructions` | Raw or resolved instruction listing |

package/package.json

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