brainclaw 0.24.0 → 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];
@@ -963,6 +966,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')
@@ -993,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);
 });
@@ -1008,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')
@@ -1111,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/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/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/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/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