brainclaw 0.25.3 → 0.27.0

package/dist/cli.js

@@ -81,6 +81,9 @@ import { cleanOrphanFiles, memoryDir } from './core/io.js';
 import { initLogLevel, logger } from './core/logger.js';
 import { resolveEffectiveCwd } from './core/store-resolution.js';
 import { runSwitch } from './commands/switch.js';
+import { runCheckEvents } from './commands/check-events.js';
+import { runDiscover } from './commands/discover.js';
+import { runMigrate } from './commands/migrate.js';
 const program = new Command();
 function collect(value, previous) {
     return [...previous, value];
@@ -994,8 +997,8 @@ program
 // --- hooks ---
 program
     .command('hooks')
-    .description('Write deterministic session-trigger hooks for Cursor (.cursor/rules/brainclaw-session.mdc) and Windsurf (.windsurfrules)')
-    .option('--target <target>', 'Which hooks to write: cursor, windsurf, all (default: all)')
+    .description('Write deterministic session-trigger hooks for Cursor, Windsurf, and Claude Code (PostToolUse event check)')
+    .option('--target <target>', 'Which hooks to write: cursor, windsurf, claude-code, all (default: all)')
     .action((options) => {
     runHooks(options);
 });
@@ -1009,6 +1012,15 @@ program
     .action((options) => {
     runWatch({ ...options, autoClaim: options.autoClaim });
 });
+// --- check-events ---
+program
+    .command('check-events')
+    .description('Show unseen events from the event bus (events.jsonl) for the current agent')
+    .option('--agent <name>', 'Agent name for cursor lookup (default: auto-detected)')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    runCheckEvents(options);
+});
 // --- metrics ---
 program
     .command('metrics')
@@ -1112,6 +1124,24 @@ program
     .action((options) => {
     runExplore({ query: options.query });
 });
+// --- discover ---
+program
+    .command('discover')
+    .description('Scan workspace for MCP configs, instruction files, skills, hooks, and agent integrations')
+    .option('--json', 'Output as JSON')
+    .option('--no-save', 'Do not persist discovery profile to .brainclaw/discovery/')
+    .action((options) => {
+    runDiscover({ json: options.json, save: options.save });
+});
+// --- migrate ---
+program
+    .command('migrate')
+    .description('Migrate memory items between stores (e.g. promote machine-scoped items to user store)')
+    .option('--promote-machine-items', 'Move items with scope:machine from project store to user store (~/.brainclaw/)')
+    .option('--dry-run', 'Show what would be moved without actually moving')
+    .action((options) => {
+    runMigrate({ promoteMachineItems: options.promoteMachineItems, dryRun: options.dryRun });
+});
 program
     .command('switch [project]')
     .description('Set the active project for subsequent commands')

package/dist/commands/capability.js

@@ -1,11 +1,10 @@
-import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { memoryExists } from '../core/io.js';
-import { generateIdWithLabel, nowISO } from '../core/ids.js';
 import { loadConfig } from '../core/config.js';
 import { scanText } from '../core/security.js';
 import { validateCliInput } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
+import { listCapabilities, createCapability } from '../core/registries.js';
 export function runCapability(subcommand, args, options = {}) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
     if (!memoryExists(cwd)) {
@@ -38,10 +37,7 @@ export function runCapability(subcommand, args, options = {}) {
     }
 }
 function runCapabilityList(cwd) {
-    const state = loadState(cwd);
-    const capabilities = state.active_constraints
-        .filter((c) => c.tags.includes('capability'))
-        .map((c) => ({ id: c.id, name: c.text.split('\n')[0], tags: c.tags }));
+    const capabilities = listCapabilities(cwd);
     if (capabilities.length === 0) {
         console.log('No capabilities registered yet.');
         return;
@@ -49,8 +45,8 @@ function runCapabilityList(cwd) {
     console.log(`\n${capabilities.length} capability(ies):\n`);
     capabilities.forEach((cap) => {
         console.log(`  [${cap.id}] ${cap.name}`);
-        if (cap.tags.length > 1) {
-            console.log(`      tags: ${cap.tags.filter((t) => t !== 'capability').join(', ')}`);
+        if (cap.tags.length > 0) {
+            console.log(`      tags: ${cap.tags.join(', ')}`);
         }
     });
     console.log('');
@@ -66,36 +62,29 @@ function runCapabilityAdd(name, description, options, cwd) {
             process.exit(1);
         }
     }
-    const state = loadState(cwd);
-    const { id, short_label } = generateIdWithLabel('recent_decisions');
-    const entry = {
-        id,
-        short_label,
-        text: name,
-        created_at: nowISO(),
+    const cap = createCapability({
+        name,
+        description,
+        tags: options.tag,
         author: options.author ?? resolveCurrentAgentName(cwd),
-        tags: ['capability', ...(options.tag ?? [])],
-    };
-    // For now, store as decision to avoid schema migration
-    // Will migrate to separate capability storage in v0.16
-    state.recent_decisions.push(entry);
-    persistState(state, cwd);
-    console.log(`✔ Capability added: [${id}] ${name}`);
-    console.log('  (Stored in decisions for now; will move to dedicated registry in v0.16)');
+    }, cwd);
+    console.log(`✔ Capability added: [${cap.id}] ${name}`);
 }
 function runCapabilityDescribe(capId, cwd) {
-    const state = loadState(cwd);
-    const decision = state.recent_decisions.find((d) => d.id === capId || d.short_label === capId);
-    if (!decision) {
+    const capabilities = listCapabilities(cwd);
+    const cap = capabilities.find((c) => c.id === capId || c.id.startsWith(capId));
+    if (!cap) {
         console.error(`Error: capability '${capId}' not found`);
         process.exit(1);
     }
-    console.log(`\nCapability: ${decision.text}`);
-    console.log(`ID: ${decision.id}`);
-    console.log(`Author: ${decision.author}`);
-    console.log(`Created: ${decision.created_at}`);
-    if (decision.tags.length > 1) {
-        console.log(`Tags: ${decision.tags.filter((t) => t !== 'capability').join(', ')}`);
+    console.log(`\nCapability: ${cap.name}`);
+    console.log(`Description: ${cap.description}`);
+    console.log(`ID: ${cap.id}`);
+    console.log(`Category: ${cap.category}`);
+    console.log(`Author: ${cap.author}`);
+    console.log(`Created: ${cap.created_at}`);
+    if (cap.tags.length > 0) {
+        console.log(`Tags: ${cap.tags.join(', ')}`);
     }
     console.log('');
 }

package/dist/commands/check-events.js

@@ -0,0 +1,36 @@
+import { memoryExists } from '../core/io.js';
+import { readUnseenEvents, buildNotificationSummary } from '../core/event-log.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+export function runCheckEvents(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const agent = options.agent ?? resolveCurrentAgentName();
+    const events = readUnseenEvents(agent);
+    if (events.length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify({ agent, unseen: 0 }));
+        }
+        else {
+            console.log('No unseen events.');
+        }
+        return;
+    }
+    const summary = buildNotificationSummary(events) ?? {};
+    if (options.json) {
+        console.log(JSON.stringify({ agent, unseen: events.length, summary, events }));
+        return;
+    }
+    console.log(`${events.length} unseen event(s) since last read:\n`);
+    for (const [key, count] of Object.entries(summary)) {
+        console.log(`  ${key}: ${count}`);
+    }
+    console.log('');
+    for (const evt of events) {
+        const id = evt.item_id ? ` [${evt.item_id.slice(0, 12)}]` : '';
+        const sum = evt.summary ? ` — ${evt.summary}` : '';
+        console.log(`  ${evt.ts}  ${evt.agent}  ${evt.action}:${evt.item_type}${id}${sum}`);
+    }
+}
+//# sourceMappingURL=check-events.js.map

package/dist/commands/discover.js

@@ -0,0 +1,21 @@
+import { memoryExists } from '../core/io.js';
+import { buildProjectDiscovery, saveDiscoveryProfile, renderDiscoverySummary, } from '../core/project-discovery.js';
+export function runDiscover(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const profile = buildProjectDiscovery({ cwd });
+    // Save by default (non-destructive refresh)
+    if (options.save !== false) {
+        saveDiscoveryProfile(profile, cwd);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(profile, null, 2));
+    }
+    else {
+        console.log(renderDiscoverySummary(profile));
+    }
+}
+//# sourceMappingURL=discover.js.map

package/dist/commands/doctor.js

@@ -1,4 +1,5 @@
 import { listAgentIdentities, resolveCurrentAgentIdentity } from '../core/agent-registry.js';
+import { listCapabilities as listRegistryCapabilities, listTools as listRegistryTools } from '../core/registries.js';
 import { buildReputationSummary } from '../core/reputation.js';
 import { buildCircuitBreakerSnapshot } from '../core/circuit-breaker.js';
 import { loadState } from '../core/state.js';
@@ -1195,28 +1196,26 @@ export function runDoctor(options = {}) {
                     console.log('✔ Cross-level duplicates: no duplicates across store levels');
                 }
             }
-            // Metadata consistency checks
-            const capabilities = state.recent_decisions.filter((d) => d.tags.includes('capability'));
-            const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
+            // Metadata consistency checks (capabilities/tools from dedicated registries)
+            const capabilities = listRegistryCapabilities(options.cwd);
+            const tools = listRegistryTools(options.cwd);
             const metadataIssues = [];
             // Check capabilities completeness
             capabilities.forEach((cap) => {
-                const category = cap.tags.find((t) => t !== 'capability');
-                if (!category) {
+                if (!cap.category) {
                     metadataIssues.push(`Capability [${cap.id}] missing category`);
                 }
-                if (!cap.text || cap.text.trim().length === 0) {
-                    metadataIssues.push(`Capability [${cap.id}] has empty description`);
+                if (!cap.name || cap.name.trim().length === 0) {
+                    metadataIssues.push(`Capability [${cap.id}] has empty name`);
                 }
             });
             // Check tools completeness
             tools.forEach((tool) => {
-                const type = tool.tags.find((t) => t !== 'tool');
-                if (!type) {
+                if (!tool.type) {
                     metadataIssues.push(`Tool [${tool.id}] missing type`);
                 }
-                if (!tool.text || tool.text.trim().length === 0) {
-                    metadataIssues.push(`Tool [${tool.id}] has empty description`);
+                if (!tool.name || tool.name.trim().length === 0) {
+                    metadataIssues.push(`Tool [${tool.id}] has empty name`);
                 }
             });
             if (metadataIssues.length > 0) {
@@ -1245,6 +1244,63 @@ export function runDoctor(options = {}) {
             }
         }
         catch { /* non-fatal */ }
+        // Check for machine-scoped items in project store (should be in user store)
+        try {
+            const machineInProject = [
+                ...state.active_constraints.filter((c) => c.scope === 'machine'),
+                ...state.recent_decisions.filter((d) => d.scope === 'machine'),
+                ...state.known_traps.filter((t) => t.scope === 'machine'),
+            ];
+            if (machineInProject.length > 0) {
+                const ids = machineInProject.map((i) => i.id).slice(0, 5);
+                checks.push({
+                    name: 'machine_scope_placement',
+                    status: 'warn',
+                    message: `${machineInProject.length} machine-scoped item(s) in project store — consider promoting to user store with 'brainclaw migrate --promote-machine-items'`,
+                    details: ids,
+                });
+                if (!options.json) {
+                    console.warn(`⚠ ${machineInProject.length} machine-scoped item(s) in project store: ${ids.join(', ')}`);
+                }
+            }
+            else {
+                checks.push({ name: 'machine_scope_placement', status: 'ok', message: 'No machine-scoped items misplaced in project store' });
+                if (!options.json) {
+                    console.log('✔ Machine-scope placement: no misplaced items');
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+        // Workflow hygiene check (Phase 9)
+        try {
+            const activeClaims = listClaims(options.cwd).filter((c) => c.status === 'active');
+            const inProgressPlans = state.plan_items.filter((p) => p.status === 'in_progress');
+            const workflowIssues = [];
+            if (activeClaims.length > 3) {
+                workflowIssues.push(`${activeClaims.length} active claims — consider releasing finished ones`);
+            }
+            const unclaimedInProgress = inProgressPlans.filter((p) => !activeClaims.some((c) => c.plan_id === p.id));
+            if (unclaimedInProgress.length > 0) {
+                workflowIssues.push(`${unclaimedInProgress.length} in-progress plan(s) without a claim`);
+            }
+            if (workflowIssues.length > 0) {
+                checks.push({
+                    name: 'workflow_hygiene',
+                    status: 'warn',
+                    message: `Workflow hygiene: ${workflowIssues.join('; ')}`,
+                    details: workflowIssues,
+                });
+                if (!options.json) {
+                    console.warn(`⚠ Workflow hygiene: ${workflowIssues.join('; ')}`);
+                }
+            }
+            else {
+                checks.push({ name: 'workflow_hygiene', status: 'ok', message: 'Workflow hygiene OK' });
+                if (!options.json)
+                    console.log('✔ Workflow hygiene: OK');
+            }
+        }
+        catch { /* non-fatal */ }
     }
     catch { /* non-fatal */ }
     if (options.json) {

package/dist/commands/explore.js

@@ -1,14 +1,13 @@
-import { loadState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
+import { listCapabilities, listTools } from '../core/registries.js';
 export function runExplore(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     if (!memoryExists(cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
-    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'));
+    const capabilities = listCapabilities(cwd);
+    const tools = listTools(cwd);
     console.log('\n╔════════════════════════════════════════════════════════╗');
     console.log('║          Project Capabilities & Tools                   ║');
     console.log('╚════════════════════════════════════════════════════════╝\n');
@@ -18,9 +17,8 @@ export function runExplore(options = {}) {
     }
     else {
         capabilities.forEach((cap) => {
-            const category = cap.tags.find((t) => t !== 'capability') || 'general';
-            console.log(`   [${cap.id}] ${cap.text.split('\n')[0]}`);
-            console.log(`       Category: ${category}\n`);
+            console.log(`   [${cap.id}] ${cap.name}`);
+            console.log(`       Category: ${cap.category}\n`);
         });
     }
     console.log(`🔧 Tools (${tools.length}):\n`);
@@ -29,9 +27,8 @@ export function runExplore(options = {}) {
     }
     else {
         tools.forEach((tool) => {
-            const type = tool.tags.find((t) => t !== 'tool') || 'utility';
-            console.log(`   [${tool.id}] ${tool.text.split('\n')[0]}`);
-            console.log(`       Type: ${type}\n`);
+            console.log(`   [${tool.id}] ${tool.name}`);
+            console.log(`       Type: ${tool.type}\n`);
         });
     }
     if (capabilities.length === 0 && tools.length === 0) {

package/dist/commands/hooks.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { memoryExists } from '../core/io.js';
 import { loadConfig } from '../core/config.js';
-import { BRAINCLAW_SECTION_START, BRAINCLAW_SECTION_END, upsertBrainclawSection } from '../core/agent-files.js';
+import { BRAINCLAW_SECTION_START, BRAINCLAW_SECTION_END, upsertBrainclawSection, ensureClaudeCodeSettings } from '../core/agent-files.js';
 /**
  * Generate the Cursor MDC hook file content.
  * Uses MDC frontmatter with `alwaysApply: true` so Cursor injects it
@@ -25,14 +25,14 @@ brainclaw context
 This loads the shared project memory: active constraints, recent decisions, known traps,
 open plan items, active claims, and the last handoff.
 
-**Before finishing any session:**
-
-\`\`\`bash
-brainclaw claim release <id>               # release claims you opened
-brainclaw plan update <id> --status done   # close plan items you completed
-# or in one shot:
-brainclaw session-end --auto-release
-\`\`\`
+**Before finishing any session:**
+
+\`\`\`bash
+brainclaw claim release <id>               # release claims you opened
+brainclaw plan update <id> --status done   # close plan items you completed
+# or in one shot:
+brainclaw session-end --auto-release
+\`\`\`
 `;
 }
 /**
@@ -55,14 +55,14 @@ brainclaw context
 This gives you: active constraints, recent decisions, known traps, open plans, active claims,
 and the last handoff note. Do not skip this step.
 
-## SESSION END (before finishing)
-
-\`\`\`bash
-brainclaw claim release <id>               # for each claim you hold
-brainclaw plan update <id> --status done   # for each plan item you completed
-# or:
-brainclaw session-end --auto-release
-\`\`\`
+## SESSION END (before finishing)
+
+\`\`\`bash
+brainclaw claim release <id>               # for each claim you hold
+brainclaw plan update <id> --status done   # for each plan item you completed
+# or:
+brainclaw session-end --auto-release
+\`\`\`
 `;
 }
 export function writeHook(content, relativePath, cwd) {
@@ -100,6 +100,14 @@ export function runHooks(options = {}) {
         const content = generateWindsurfHook(config.project_name);
         results.push(writeHook(content, '.windsurfrules', cwd));
     }
+    if (target === 'claude-code' || target === 'all') {
+        const autoResult = ensureClaudeCodeSettings(cwd);
+        results.push({
+            target: 'claude-code',
+            relativePath: autoResult.relativePath ?? '.claude/settings.local.json',
+            created: autoResult.created,
+        });
+    }
     for (const r of results) {
         console.log(`✔ Hook written to ${r.relativePath} (${r.created ? 'created' : 'updated'})`);
     }
@@ -118,6 +126,14 @@ export function writeDetectedAgentHooks(agentName, projectName, cwd) {
         const content = generateWindsurfHook(projectName);
         results.push(writeHook(content, '.windsurfrules', cwd));
     }
+    if (agentName === 'claude-code') {
+        const autoResult = ensureClaudeCodeSettings(cwd);
+        results.push({
+            target: 'claude-code',
+            relativePath: autoResult.relativePath ?? '.claude/settings.local.json',
+            created: autoResult.created,
+        });
+    }
     return results;
 }
 //# sourceMappingURL=hooks.js.map