brainclaw 0.24.0 → 0.27.0

package/dist/commands/mcp.js

@@ -9,7 +9,7 @@ import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from
 import { buildExecutionContext, renderExecutionContextSummary } from '../core/execution-context.js';
 import { checkBrainclawInstallableUpdate, renderBrainclawInstallableUpdateNotice } from '../core/brainclaw-version.js';
 import { loadConfig } from '../core/config.js';
-import { loadState, persistState } from '../core/state.js';
+import { loadState, persistState, saveState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
 import { generateCandidateIdWithLabel, listArchivedCandidates, listCandidates, saveCandidate } from '../core/candidates.js';
 import { generateClaimId, listClaims, loadClaim, saveClaim } from '../core/claims.js';
@@ -18,8 +18,8 @@ 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 { appendAuditEntry } from '../core/audit.js';
+import { agentCanWriteDirect, AgentIdentityResolutionError, AgentTrustError, listAgentIdentities, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveAgentScope, resolveCurrentAgentIdentity, resolveCurrentAgentName, resolveCurrentModel, } from '../core/agent-registry.js';
+import { appendAuditEntry, readAuditLog } from '../core/audit.js';
 import { nowISO, generateIdWithLabel, generateId } from '../core/ids.js';
 import { inferProjectFromTarget, loadInstructions, resolveInstructions } from '../core/instructions.js';
 import { buildReputationSnapshot, toPublicReputationSummary } from '../core/reputation.js';
@@ -27,6 +27,9 @@ import { search } from '../core/search.js';
 import { buildOperationalIdentity } from '../core/identity.js';
 import { validateMcpInput, validateMcpField } from '../core/input-validation.js';
 import { buildEstimationReport } from './estimation-report.js';
+import { runDoctor } from './doctor.js';
+import { buildProjectDiscovery, saveDiscoveryProfile, loadDiscoveryProfile, renderDiscoverySummary } from '../core/project-discovery.js';
+import { listCapabilities, listTools as listRegistryTools, createCapability, createTool as createRegistryTool } from '../core/registries.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
 import { checkGitPresence, scanGitRepos, parseRoots, parseRepoSelection, parseAgentSelection, runGlobalInstall, initReposAndConfigureAgents, readSetupState, ALL_KNOWN_AGENTS, } from './setup.js';
 import { resolveEffectiveCwd, resolveTargetStore, resolveStoreChain } from '../core/store-resolution.js';
@@ -156,6 +159,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.' },
             },
         },
     },
@@ -244,6 +251,62 @@ export const MCP_READ_TOOLS = [
             required: ['query'],
         },
     },
+    {
+        name: 'bclaw_doctor',
+        description: 'Run health checks on the brainclaw memory store. Returns structured check results with ok/warn/error status and metrics.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                migrationCheck: { type: 'boolean', description: 'Include detailed schema migration status.' },
+            },
+        },
+    },
+    {
+        name: 'bclaw_history',
+        description: 'Show full mutation history of a memory item from the audit log.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Item ID to retrieve history for.' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'bclaw_audit',
+        description: 'View the append-only audit log of all memory mutations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                since: { type: 'string', description: 'Show entries since this ISO date.' },
+                actor: { type: 'string', description: 'Filter by actor name or agent ID.' },
+                action: { type: 'string', description: 'Filter by action type (create, accept, reject, etc.).' },
+                limit: { type: 'number', description: 'Show last N entries (default 20).' },
+            },
+        },
+    },
+    {
+        name: 'bclaw_get_discovery',
+        description: 'Scan workspace for MCP configs, instruction files, skills, hooks, and agent integrations. Returns a structured discovery profile. Saves result to .brainclaw/discovery/ by default.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                refresh: { type: 'boolean', description: 'Force a fresh scan even if a cached profile exists (default: true).' },
+                noSave: { type: 'boolean', description: 'Do not persist the discovery profile.' },
+            },
+        },
+    },
+    {
+        name: 'bclaw_conflict_check',
+        description: 'Check for claim conflicts between the current agent and other agents. Returns overlapping scopes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agent: { type: 'string', description: 'Agent name to check conflicts for (default: current agent).' },
+                agentId: { type: 'string', description: 'Registered agent id.' },
+            },
+        },
+    },
 ];
 const MCP_WRITE_TOOLS = [
     {
@@ -295,6 +358,8 @@ const MCP_WRITE_TOOLS = [
                 outcome: { type: 'string', description: 'Outcome for decisions: approved, rejected, deferred, pending.' },
                 severity: { type: 'string', description: 'Severity for traps: low, medium, high.' },
                 planId: { type: 'string', description: 'Optional plan item ID this decision or trap relates to.' },
+                scope: { type: 'string', description: 'Memory scope: project (default), machine, or user. Machine-scoped items apply to all projects on this machine.' },
+                store: { type: 'string', description: 'Target store level: local (default), repo, workspace, user. Use "user" to write to ~/.brainclaw/ (visible across all projects).' },
             },
             required: ['text', 'type'],
         },
@@ -480,6 +545,52 @@ const MCP_WRITE_TOOLS = [
             required: ['id', 'type'],
         },
     },
+    {
+        name: 'bclaw_add_capability',
+        description: 'Register a new project capability. Requires contributor trust level or above.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Capability name.' },
+                description: { type: 'string', description: 'Capability description.' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Additional tags.' },
+                agent: { type: 'string', description: 'Agent name.' },
+                agentId: { type: 'string', description: 'Registered agent id.' },
+            },
+            required: ['name', 'description'],
+        },
+    },
+    {
+        name: 'bclaw_add_tool',
+        description: 'Register a new project tool. Requires contributor trust level or above.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Tool name.' },
+                description: { type: 'string', description: 'Tool description.' },
+                type: { type: 'string', description: 'Tool type: workflow, validator, generator, utility, explorer (default: utility).' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Additional tags.' },
+                agent: { type: 'string', description: 'Agent name.' },
+                agentId: { type: 'string', description: 'Registered agent id.' },
+            },
+            required: ['name', 'description'],
+        },
+    },
+    {
+        name: 'bclaw_update_handoff',
+        description: 'Update the status or recipient of an open handoff. Requires contributor trust level or above.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Handoff ID to update.' },
+                status: { type: 'string', description: 'New status: open, closed.' },
+                to: { type: 'string', description: 'New recipient agent name.' },
+                agent: { type: 'string', description: 'Agent name.' },
+                agentId: { type: 'string', description: 'Registered agent id.' },
+            },
+            required: ['id'],
+        },
+    },
 ];
 const ALL_TOOLS = [...MCP_READ_TOOLS, ...MCP_WRITE_TOOLS];
 class McpProtocolError extends Error {
@@ -1036,10 +1147,9 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             refreshBootstrap: args.refreshBootstrap,
             cwd,
         });
-        // Load available capabilities and tools
-        const state = loadState(cwd);
-        const capabilities = state.recent_decisions.filter((d) => d.tags.includes('capability'));
-        const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
+        // Load available capabilities and tools from dedicated registries
+        const capabilities = listCapabilities(cwd);
+        const tools = listRegistryTools(cwd);
         const format = normaliseFormat(args.format);
         const content = renderContextForMcp(result, format, {
             explain: args.explain,
@@ -1052,8 +1162,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             if (capabilities.length > 0) {
                 suggestions.push(`\n## Available Capabilities (${capabilities.length})`);
                 capabilities.slice(0, 5).forEach((cap) => {
-                    const category = cap.tags.find((t) => t !== 'capability') || 'general';
-                    suggestions.push(`- [${cap.id}] ${cap.text.split('\n')[0]} (${category})`);
+                    suggestions.push(`- [${cap.id}] ${cap.name} (${cap.category})`);
                 });
                 if (capabilities.length > 5) {
                     suggestions.push(`- ... and ${capabilities.length - 5} more`);
@@ -1062,8 +1171,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             if (tools.length > 0) {
                 suggestions.push(`\n## Available Tools (${tools.length})`);
                 tools.slice(0, 5).forEach((tool) => {
-                    const type = tool.tags.find((t) => t !== 'tool') || 'utility';
-                    suggestions.push(`- [${tool.id}] ${tool.text.split('\n')[0]} (${type})`);
+                    suggestions.push(`- [${tool.id}] ${tool.name} (${tool.type})`);
                 });
                 if (tools.length > 5) {
                     suggestions.push(`- ... and ${tools.length - 5} more`);
@@ -1082,13 +1190,13 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                 ...result,
                 available_capabilities: capabilities.map((cap) => ({
                     id: cap.id,
-                    name: cap.text.split('\n')[0],
-                    category: cap.tags.find((t) => t !== 'capability') || 'general',
+                    name: cap.name,
+                    category: cap.category,
                 })),
                 available_tools: tools.map((tool) => ({
                     id: tool.id,
-                    name: tool.text.split('\n')[0],
-                    type: tool.tags.find((t) => t !== 'tool') || 'utility',
+                    name: tool.name,
+                    type: tool.type,
                 })),
                 ...(notifications ? { pending_notifications: notifications, unseen_event_count: unseenEvents.length } : {}),
             },
@@ -1265,6 +1373,12 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         for (const instruction of board.resolved_instructions.slice(0, 10)) {
             lines.push(`- [${instruction.id}] <${instruction.layer}${instruction.scope ? `:${instruction.scope}` : ''}> ${instruction.text}`);
         }
+        if (board.other_agents && board.other_agents.length > 0) {
+            lines.push(`Other agents: ${board.other_agents.length}`);
+            for (const other of board.other_agents) {
+                lines.push(`- ${other.name}: ${other.claim_count} claim(s) on ${other.scopes.join(', ')}`);
+            }
+        }
         return {
             content: [{ type: 'text', text: lines.join('\n') }],
             structuredContent: { ...board },
@@ -1308,6 +1422,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 +1451,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 +1472,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') {
@@ -1496,32 +1633,25 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_get_capabilities') {
-        const state = loadState(cwd);
-        const capabilities = state.recent_decisions.filter((d) => d.tags.includes('capability'));
-        const filtered = capabilities.filter((cap) => {
+        const allCapabilities = listCapabilities(cwd);
+        const filtered = allCapabilities.filter((cap) => {
             const categoryFilter = args.category;
             const tagsFilter = args.tags;
-            if (categoryFilter) {
-                const capCategory = cap.tags.find((t) => t !== 'capability');
-                if (capCategory !== categoryFilter)
-                    return false;
-            }
+            if (categoryFilter && cap.category !== categoryFilter)
+                return false;
             if (tagsFilter && tagsFilter.length > 0) {
-                const hasAllTags = tagsFilter.every((tag) => cap.tags.includes(tag));
-                if (!hasAllTags)
+                if (!tagsFilter.every((tag) => cap.tags.includes(tag)))
                     return false;
             }
             return true;
         });
         const lines = [`Capabilities (${filtered.length}):`];
         filtered.forEach((cap) => {
-            const category = cap.tags.find((t) => t !== 'capability') || 'general';
-            const otherTags = cap.tags.filter((t) => t !== 'capability' && t !== category);
-            lines.push(`\n[${cap.id}] ${cap.text.split('\n')[0]}`);
-            lines.push(`    Category: ${category}`);
+            lines.push(`\n[${cap.id}] ${cap.name}`);
+            lines.push(`    Category: ${cap.category}`);
             lines.push(`    Author: ${cap.author}`);
-            if (otherTags.length > 0) {
-                lines.push(`    Tags: ${otherTags.join(', ')}`);
+            if (cap.tags.length > 0) {
+                lines.push(`    Tags: ${cap.tags.join(', ')}`);
             }
         });
         return {
@@ -1530,32 +1660,25 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_list_tools') {
-        const state = loadState(cwd);
-        const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
-        const filtered = tools.filter((tool) => {
+        const allTools = listRegistryTools(cwd);
+        const filtered = allTools.filter((tool) => {
             const typeFilter = args.type;
             const tagsFilter = args.tags;
-            if (typeFilter) {
-                const toolType = tool.tags.find((t) => t !== 'tool');
-                if (toolType !== typeFilter)
-                    return false;
-            }
+            if (typeFilter && tool.type !== typeFilter)
+                return false;
             if (tagsFilter && tagsFilter.length > 0) {
-                const hasAllTags = tagsFilter.every((tag) => tool.tags.includes(tag));
-                if (!hasAllTags)
+                if (!tagsFilter.every((tag) => tool.tags.includes(tag)))
                     return false;
             }
             return true;
         });
         const lines = [`Tools (${filtered.length}):`];
         filtered.forEach((tool) => {
-            const type = tool.tags.find((t) => t !== 'tool') || 'utility';
-            const otherTags = tool.tags.filter((t) => t !== 'tool' && t !== type);
-            lines.push(`\n[${tool.id}] ${tool.text.split('\n')[0]}`);
-            lines.push(`    Type: ${type}`);
+            lines.push(`\n[${tool.id}] ${tool.name}`);
+            lines.push(`    Type: ${tool.type}`);
             lines.push(`    Author: ${tool.author}`);
-            if (otherTags.length > 0) {
-                lines.push(`    Tags: ${otherTags.join(', ')}`);
+            if (tool.tags.length > 0) {
+                lines.push(`    Tags: ${tool.tags.join(', ')}`);
             }
         });
         return {
@@ -1568,39 +1691,152 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         if (!query) {
             throw new Error('Missing required argument: query');
         }
-        const state = loadState(cwd);
-        const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
-        const filtered = tools.filter((tool) => {
+        const allTools = listRegistryTools(cwd);
+        const queryLower = query.toLowerCase();
+        const filtered = allTools.filter((tool) => {
             const typeFilter = args.type;
             const tagsFilter = args.tags;
-            // Type filter
-            if (typeFilter) {
-                const toolType = tool.tags.find((t) => t !== 'tool');
-                if (toolType !== typeFilter)
-                    return false;
-            }
-            // Tags filter (all must match)
+            if (typeFilter && tool.type !== typeFilter)
+                return false;
             if (tagsFilter && tagsFilter.length > 0) {
-                const hasAllTags = tagsFilter.every((tag) => tool.tags.includes(tag));
-                if (!hasAllTags)
+                if (!tagsFilter.every((tag) => tool.tags.includes(tag)))
                     return false;
             }
-            // Query search (name, description, tags)
-            const queryLower = query.toLowerCase();
-            return (tool.text.toLowerCase().includes(queryLower) ||
+            return (tool.name.toLowerCase().includes(queryLower) ||
+                tool.description.toLowerCase().includes(queryLower) ||
                 tool.tags.some((tag) => tag.toLowerCase().includes(queryLower)));
         });
         const lines = [`Search results for '${query}' (${filtered.length} tool(s)):`];
         filtered.forEach((tool) => {
-            const type = tool.tags.find((t) => t !== 'tool') || 'utility';
-            lines.push(`\n[${tool.id}] ${tool.text.split('\n')[0]}`);
-            lines.push(`    Type: ${type}`);
+            lines.push(`\n[${tool.id}] ${tool.name}`);
+            lines.push(`    Type: ${tool.type}`);
         });
         return {
             content: [{ type: 'text', text: lines.join('\n') || 'No tools found.' }],
             structuredContent: { query, total: filtered.length, tools: filtered },
         };
     }
+    if (name === 'bclaw_get_discovery') {
+        const refresh = args.refresh !== false; // default: true
+        const noSave = args.noSave;
+        let profile;
+        if (!refresh) {
+            profile = loadDiscoveryProfile(cwd);
+        }
+        if (!profile) {
+            profile = buildProjectDiscovery({ cwd });
+            if (!noSave) {
+                saveDiscoveryProfile(profile, cwd);
+            }
+        }
+        return {
+            content: [{ type: 'text', text: renderDiscoverySummary(profile) }],
+            structuredContent: { ...profile, schema_version: SCHEMA_VERSION },
+        };
+    }
+    if (name === 'bclaw_conflict_check') {
+        const agentNameArg = args.agent;
+        const agentIdArg = args.agentId;
+        const currentAgentName = agentNameArg ?? resolveCurrentAgentName(cwd);
+        const allClaimsForCheck = listClaims(cwd).filter((c) => c.status === 'active');
+        const myClaimsForCheck = allClaimsForCheck.filter((c) => agentIdArg ? c.agent_id === agentIdArg : c.agent === currentAgentName);
+        const otherClaimsForCheck = allClaimsForCheck.filter((c) => agentIdArg ? c.agent_id !== agentIdArg : c.agent !== currentAgentName);
+        const conflicts = [];
+        for (const mine of myClaimsForCheck) {
+            const myScopes = mine.scope.replace(/\\/g, '/').split(/\s+/);
+            for (const other of otherClaimsForCheck) {
+                const otherScopes = other.scope.replace(/\\/g, '/').split(/\s+/);
+                for (const ms of myScopes) {
+                    for (const os of otherScopes) {
+                        if (ms === os || ms.startsWith(os + '/') || os.startsWith(ms + '/')) {
+                            conflicts.push({
+                                my_claim: mine.id, my_scope: mine.scope,
+                                other_claim: other.id, other_agent: other.agent, other_scope: other.scope,
+                                reason: ms === os ? `exact: ${ms}` : `overlap: ${ms} ↔ ${os}`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const text = conflicts.length === 0
+            ? `No claim conflicts for ${currentAgentName}.`
+            : `${conflicts.length} conflict(s) found:\n${conflicts.map((c) => `  ${c.my_scope} ↔ ${c.other_agent}:${c.other_scope} (${c.reason})`).join('\n')}`;
+        return {
+            content: [{ type: 'text', text }],
+            structuredContent: { agent: currentAgentName, conflicts, total: conflicts.length, schema_version: SCHEMA_VERSION },
+        };
+    }
+    if (name === 'bclaw_doctor') {
+        // Capture doctor JSON output by redirecting console.log
+        const captured = [];
+        const origLog = console.log;
+        const origWarn = console.warn;
+        const origError = console.error;
+        console.log = (...a) => captured.push(a.join(' '));
+        console.warn = (...a) => captured.push(a.join(' '));
+        console.error = (...a) => captured.push(a.join(' '));
+        try {
+            runDoctor({ json: true, cwd, migrationCheck: args.migrationCheck });
+        }
+        finally {
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+        }
+        const jsonStr = captured.join('\n');
+        let structured = {};
+        try {
+            structured = JSON.parse(jsonStr);
+        }
+        catch { /* non-JSON fallback */ }
+        const ok = structured.ok;
+        const checks = structured.checks ?? [];
+        const errors = checks.filter(c => c.status === 'error');
+        const warns = checks.filter(c => c.status === 'warn');
+        const summary = ok
+            ? `✔ All ${checks.length} checks passed.`
+            : `${errors.length} error(s), ${warns.length} warning(s) out of ${checks.length} checks.`;
+        return {
+            content: [{ type: 'text', text: summary }],
+            structuredContent: { ...structured, schema_version: SCHEMA_VERSION },
+        };
+    }
+    if (name === 'bclaw_history') {
+        const id = String(args.id ?? '').trim();
+        if (!id)
+            throw new Error('Missing required argument: id');
+        const entries = readAuditLog({ itemId: id }, cwd);
+        const lines = [`History for ${id} — ${entries.length} event(s):`];
+        for (const e of entries) {
+            const reason = e.reason ? ` | ${e.reason}` : '';
+            lines.push(`  ${e.timestamp} [${e.actor}] ${e.action}${reason}`);
+        }
+        return {
+            content: [{ type: 'text', text: lines.join('\n') }],
+            structuredContent: { id, total: entries.length, entries, schema_version: SCHEMA_VERSION },
+        };
+    }
+    if (name === 'bclaw_audit') {
+        const limit = args.limit ?? 20;
+        const entries = readAuditLog({
+            since: args.since,
+            actor: args.actor,
+            action: args.action,
+        }, cwd);
+        const sliced = entries.slice(-limit);
+        const lines = [`Audit log — showing ${sliced.length} of ${entries.length} entries:`];
+        for (const e of sliced) {
+            const itemInfo = e.item_id ? ` → ${e.item_id}` : '';
+            const typeInfo = e.item_type ? ` (${e.item_type})` : '';
+            const reason = e.reason ? ` | ${e.reason}` : '';
+            lines.push(`  ${e.timestamp} [${e.actor}] ${e.action}${itemInfo}${typeInfo}${reason}`);
+        }
+        return {
+            content: [{ type: 'text', text: lines.join('\n') }],
+            structuredContent: { total: entries.length, returned: sliced.length, entries: sliced, schema_version: SCHEMA_VERSION },
+        };
+    }
     throw new Error(`Unknown read tool: ${name}`);
 }
 export async function executeMcpToolCall(payload) {
@@ -1611,6 +1847,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 +2032,7 @@ export async function executeMcpToolCall(payload) {
                 autoReflect: args.autoReflect,
                 cwd,
                 sessionId: connectionSessionId,
+                model: currentModel,
             }, false);
             return {
                 response: toolResponse({
@@ -1829,6 +2068,9 @@ export async function executeMcpToolCall(payload) {
             const type = String(args.type ?? 'decision');
             const writeThrough = agentCanWriteDirect(identity.agent_id ?? resolvedIdentity.agent_id, cwd);
             const candidatePlanId = args.planId;
+            const candidateScope = args.scope;
+            const targetStore = args.store;
+            const effectiveCwd = targetStore ? resolveTargetStore(cwd, targetStore) : cwd;
             const candidate = {
                 id: candId.id,
                 short_label: candId.short_label,
@@ -1845,7 +2087,9 @@ export async function executeMcpToolCall(payload) {
                 severity: type === 'trap' ? (args.severity ?? 'medium') : undefined,
                 category: type === 'constraint' ? args.category : undefined,
                 outcome: type === 'decision' ? args.outcome : undefined,
+                scope: candidateScope,
                 plan_id: candidatePlanId,
+                model: currentModel,
                 star_count: 0,
                 starred_by: [],
                 usage_count: 0,
@@ -1854,22 +2098,25 @@ export async function executeMcpToolCall(payload) {
             const planPrompt = (type === 'decision' || type === 'trap') && !candidatePlanId
                 ? `\n💡 Does this ${type} relate to an active plan item? If so, re-run with planId: 'pln_xxx' to link it.`
                 : '';
+            const storeLabel = targetStore && targetStore !== 'local' ? ` [store: ${targetStore}]` : '';
             if (writeThrough) {
-                saveCandidate(candidate, cwd);
-                const accepted = acceptCandidate(candId.id, resolvedIdentity.agent_name, cwd, resolvedIdentity.agent_id);
-                appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'promote_direct', item_id: candId.id, item_type: type }, cwd);
+                saveCandidate(candidate, effectiveCwd);
+                const accepted = acceptCandidate(candId.id, resolvedIdentity.agent_name, effectiveCwd, resolvedIdentity.agent_id);
+                appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'promote_direct', item_id: candId.id, item_type: type }, effectiveCwd);
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ Direct write [${candId.short_label}] (trusted agent)${planPrompt}` }],
+                        content: [{ type: 'text', text: `✔ Direct write [${candId.short_label}] (trusted agent)${storeLabel}${planPrompt}` }],
                         candidate_id: candId.id,
                         promoted_item_id: accepted.promoted_item_id,
                         write_through: true,
+                        store: targetStore ?? 'local',
+                        scope: candidateScope,
                     }),
                     nextConnectionSessionId: explicitSessionIdFromEnv() ? undefined : identity.session_id,
                 };
             }
-            saveCandidate(candidate, cwd);
-            appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: candId.id, item_type: type }, cwd);
+            saveCandidate(candidate, effectiveCwd);
+            appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: candId.id, item_type: type }, effectiveCwd);
             return {
                 response: toolResponse({
                     content: [{ type: 'text', text: `✔ Candidate created [${candId.short_label}] (pending review)${planPrompt}` }],
@@ -1949,6 +2196,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);
@@ -2436,6 +2684,100 @@ export async function executeMcpToolCall(payload) {
                 }),
             };
         }
+        if (name === 'bclaw_add_capability') {
+            const capName = String(args.name ?? '').trim();
+            const capDesc = String(args.description ?? '').trim();
+            if (!capName || !capDesc) {
+                return { response: createToolErrorResponse('validation_error', 'Missing required arguments: name and description') };
+            }
+            const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd);
+            if (resolved.error) {
+                return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+            }
+            const resolvedIdentity = resolved.identity;
+            const extraTags = Array.isArray(args.tags) ? args.tags : [];
+            const cap = createCapability({
+                name: capName,
+                description: capDesc,
+                tags: extraTags,
+                author: resolvedIdentity.agent_name,
+                authorId: resolvedIdentity.agent_id,
+                model: currentModel,
+            }, cwd);
+            appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: cap.id, item_type: 'capability', reason: `capability: ${capName}` }, cwd);
+            return {
+                response: toolResponse({
+                    content: [{ type: 'text', text: `✔ Capability registered: [${cap.id}] ${capName}` }],
+                    id: cap.id,
+                    name: capName,
+                    schema_version: SCHEMA_VERSION,
+                }),
+            };
+        }
+        if (name === 'bclaw_add_tool') {
+            const toolName = String(args.name ?? '').trim();
+            const toolDesc = String(args.description ?? '').trim();
+            if (!toolName || !toolDesc) {
+                return { response: createToolErrorResponse('validation_error', 'Missing required arguments: name and description') };
+            }
+            const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd);
+            if (resolved.error) {
+                return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+            }
+            const resolvedIdentity = resolved.identity;
+            const toolType = String(args.type ?? 'utility');
+            const extraTags = Array.isArray(args.tags) ? args.tags : [];
+            const tool = createRegistryTool({
+                name: toolName,
+                description: toolDesc,
+                type: toolType,
+                tags: extraTags,
+                author: resolvedIdentity.agent_name,
+                authorId: resolvedIdentity.agent_id,
+                model: currentModel,
+            }, cwd);
+            appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: tool.id, item_type: 'tool', reason: `tool: ${toolName}` }, cwd);
+            return {
+                response: toolResponse({
+                    content: [{ type: 'text', text: `✔ Tool registered: [${tool.id}] ${toolName} (${toolType})` }],
+                    id: tool.id,
+                    name: toolName,
+                    type: toolType,
+                    schema_version: SCHEMA_VERSION,
+                }),
+            };
+        }
+        if (name === 'bclaw_update_handoff') {
+            const handoffId = String(args.id ?? '').trim();
+            if (!handoffId) {
+                return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
+            }
+            const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd);
+            if (resolved.error) {
+                return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+            }
+            const resolvedIdentity = resolved.identity;
+            const state = loadState(cwd);
+            const handoff = state.open_handoffs.find((h) => h.id === handoffId);
+            if (!handoff) {
+                return { response: createToolErrorResponse('not_found', `Handoff not found: ${handoffId}`) };
+            }
+            if (args.status)
+                handoff.status = args.status;
+            if (args.to)
+                handoff.to = String(args.to);
+            saveState(state, cwd);
+            appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'update', item_id: handoffId, item_type: 'handoff' }, cwd);
+            return {
+                response: toolResponse({
+                    content: [{ type: 'text', text: `✔ Handoff updated: [${handoffId}] ${handoff.from} → ${handoff.to} (${handoff.status})` }],
+                    handoff_id: handoffId,
+                    status: handoff.status,
+                    to: handoff.to,
+                    schema_version: SCHEMA_VERSION,
+                }),
+            };
+        }
         return {
             response: createToolErrorResponse('unknown_tool', `Unknown tool: ${name}`),
         };