brainclaw 1.9.0 → 1.10.0

package/dist/cli.js

@@ -19,6 +19,7 @@ import { runListPlans } from './commands/list-plans.js';
 import { runUpdatePlan } from './commands/update-plan.js';
 import { runDeletePlan } from './commands/delete-plan.js';
 import { runPlanResource } from './commands/plan-resource.js';
+import { runCodeMap } from './commands/code-map.js';
 import { runSequenceResource } from './commands/sequence.js';
 import { runAddStep } from './commands/add-step.js';
 import { runDeleteStep } from './commands/delete-step.js';
@@ -598,6 +599,20 @@ program
     .action((subcommand, args, options) => {
     runPlanResource(subcommand, args, { ...options, actualEffort: options.actualEffort, localOnly: options.localOnly });
 });
+// --- code-map ---
+program
+    .command('code-map <subcommand> [args...]')
+    .description('Query the per-project Code Map (status, refresh, find, brief)')
+    .option('--json', 'Output as JSON')
+    .option('--all', 'For refresh: enumerate all supported files (full refresh)')
+    .option('--changed', 'For refresh: only changed files (default)')
+    .option('--limit <n>', 'Max results for find/brief', (v) => parseInt(v, 10))
+    .action((subcommand, args, options) => {
+    void runCodeMap(subcommand, args, options).catch((err) => {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+});
 // --- list-plans ---
 program
     .command('list-plans')
@@ -1806,15 +1821,17 @@ program
 });
 program
     .command('switch [project]')
-    .description('Set the active project for subsequent commands')
+    .description('Set the active project for subsequent commands (session-scoped by default)')
     .option('--list', 'List available projects in the workspace')
     .option('--clear', 'Clear the active project (revert to cwd)')
+    .option('--global', 'Set/clear the SHARED workspace default for ALL agents (writes active-project.json). Without it, switch is session-scoped and isolated.')
     .option('--json', 'Output as JSON')
     .action((project, options) => {
     const globalOpts = options.parent?.parent ? program.opts() : {};
     runSwitch(project, {
         list: options.list,
         clear: options.clear,
+        global: options.global,
         json: options.json,
         cwd: globalOpts.cwd,
     });

package/dist/commands/code-map.js

@@ -0,0 +1,129 @@
+/**
+ * `brainclaw code-map <subcommand>` — CLI surface over the Code Map backend
+ * (spec §9). Mirrors plan-resource.ts: a switch over the subcommand delegating
+ * to a JsonlBackend (status | refresh | find | brief). The backend owns all
+ * query logic; this file only adapts it to argv + stdout (text or --json), and
+ * every output carries the freshness_badge.
+ */
+import { JsonlBackend } from '../core/code-map/backend.js';
+const KNOWN_SUBCOMMANDS = new Set(['status', 'refresh', 'find', 'brief']);
+function backend() {
+    return new JsonlBackend();
+}
+function badgeLine(badge) {
+    const detailKeys = Object.keys(badge.details ?? {}).filter((k) => badge.details[k] !== null && badge.details[k] !== undefined);
+    const detail = detailKeys.length
+        ? ` (${detailKeys.map((k) => `${k}=${JSON.stringify(badge.details[k])}`).join(', ')})`
+        : '';
+    return `Freshness: ${badge.status}${detail}`;
+}
+export async function runCodeMap(subcommand, args, options = {}) {
+    const normalized = (subcommand ?? '').trim().toLowerCase();
+    const be = backend();
+    const cwd = options.cwd;
+    if (normalized === 'status') {
+        const status = await be.status({ cwd });
+        printStatus(status, options);
+        return;
+    }
+    if (normalized === 'refresh') {
+        const scope = options.all ? 'all' : 'changed';
+        const result = await be.refresh({ scope, cwd });
+        printRefresh(result, options);
+        return;
+    }
+    if (normalized === 'find') {
+        const query = args.join(' ').trim();
+        if (!query) {
+            console.error('Error: code-map find requires <query>.');
+            console.error('  Usage: brainclaw code-map find <query>');
+            process.exit(1);
+        }
+        const result = await be.find({ query, limit: options.limit, cwd });
+        printFind(result, options);
+        return;
+    }
+    if (normalized === 'brief') {
+        const target = args.join(' ').trim();
+        if (!target) {
+            console.error('Error: code-map brief requires <symbol-or-path>.');
+            console.error('  Usage: brainclaw code-map brief <symbol-or-path>');
+            process.exit(1);
+        }
+        const result = await be.brief({ target, limit: options.limit, cwd });
+        printBrief(result, options);
+        return;
+    }
+    console.error(`Error: unknown code-map subcommand "${subcommand}".`);
+    console.error(`  Available: ${[...KNOWN_SUBCOMMANDS].join(', ')}`);
+    process.exit(1);
+}
+function printStatus(status, options) {
+    if (options.json) {
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    console.log('Code Map status');
+    console.log(`  Store:    ${status.store_exists ? 'present' : 'absent'}`);
+    console.log(`  ${badgeLine(status.freshness_badge)}`);
+    if (status.stats) {
+        console.log(`  Files:    ${status.stats.files_indexed}`);
+        console.log(`  Nodes:    ${status.stats.nodes}`);
+        console.log(`  Edges:    ${status.stats.edges}`);
+    }
+    else {
+        console.log('  Stats:    (none — index not built)');
+    }
+}
+function printRefresh(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Code Map refresh [${result.scope}]`);
+    console.log(`  Ran:      ${result.ran}`);
+    console.log(`  Lock:     ${result.lock_acquired ? 'acquired' : 'not acquired'}`);
+    if (result.lock_status)
+        console.log(`  Status:   ${result.lock_status}`);
+    console.log(`  ${badgeLine(result.freshness_badge)}`);
+}
+function printFind(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Code Map find: "${result.query}"`);
+    console.log(`  ${badgeLine(result.freshness_badge)}`);
+    if (result.matches.length === 0) {
+        console.log('  (no matches)');
+        return;
+    }
+    for (const m of result.matches) {
+        const sub = m.subtype ? ` ${m.subtype}` : '';
+        console.log(`  [${m.score.toFixed(1)}] ${m.name}${sub} — ${m.path}`);
+    }
+}
+function printBrief(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Code Map brief: "${result.target}"`);
+    console.log(`  ${badgeLine(result.freshness_badge)}`);
+    if (result.suggested_files_to_read.length === 0) {
+        console.log('  Suggested files: (none)');
+    }
+    else {
+        console.log('  Suggested files to read:');
+        for (const f of result.suggested_files_to_read) {
+            console.log(`    [${f.score.toFixed(1)}] ${f.path} — ${f.reason}`);
+        }
+    }
+    if (result.related_memory.length > 0) {
+        console.log('  Related memory:');
+        for (const mem of result.related_memory) {
+            console.log(`    ${mem.id} (${mem.kind}): ${mem.text.slice(0, 80)}`);
+        }
+    }
+}
+//# sourceMappingURL=code-map.js.map

package/dist/commands/codev.js

@@ -26,6 +26,7 @@ import { buildContext } from '../core/context.js';
 import { buildCoordinationSnapshot } from '../core/coordination.js';
 import { getDefaultInvokeTemplate, getSpawnableAgents } from '../core/agent-capability.js';
 import { executeRound } from '../core/codev-rounds.js';
+import { buildWorkerIdentityEnv } from '../core/execution-profile.js';
 import { loadIdeationRound } from '../core/ideation.js';
 import { summarizeMetrics, summarizeMetricsByRound } from '../core/codev-metrics.js';
 import { generatePlansFromConvergence, generateSummaryNote } from '../core/codev-plan-gen.js';
@@ -422,12 +423,16 @@ function spawnConsultant(brief, threadId, personaName, cwd, agent) {
             console.warn(`  ⚠ Spawn error for ${agentName}/${personaName}: ${err.message}`);
         });
     };
+    // F7 (trp_0e5150d3): scrub coordinator identity so a consultant worker is an
+    // independent agent — these spawns previously inherited the full parent env.
+    const workerEnv = buildWorkerIdentityEnv(process.env, { agent: agentName });
     if (agentName === 'codex') {
         // Codex: use temp file via shell to avoid Windows .cmd ENOENT issues
         const child = spawn('sh', ['-c', `cat "${briefFile}" | "${binaryPath}" exec --full-auto - ; rm -f "${briefFile}"`], {
             detached: true,
             stdio: 'ignore',
             cwd,
+            env: workerEnv,
         });
         attachErrorHandler(child);
         child.unref();
@@ -438,6 +443,7 @@ function spawnConsultant(brief, threadId, personaName, cwd, agent) {
             detached: true,
             stdio: 'ignore',
             cwd,
+            env: workerEnv,
         });
         attachErrorHandler(child);
         child.unref();
@@ -448,6 +454,7 @@ function spawnConsultant(brief, threadId, personaName, cwd, agent) {
             detached: true,
             stdio: 'ignore',
             cwd,
+            env: workerEnv,
         });
         attachErrorHandler(child);
         child.unref();

package/dist/commands/harvest.js

@@ -299,7 +299,7 @@ export function harvestLaneResults(options = {}) {
 // ─────────────────────────────────────────────────────────────────────────────
 // pln#534 — worktree-as-contract: integrate a worker's lane on its behalf.
 //
-// LEVER #1 from the LeaseUp frontier (can_100f1e8c). The worker's contract is
+// LEVER #1 from a cross-project field session. The worker's contract is
 // reduced to "edit files in this worktree + drop LANE-RESULT.json". brainclaw
 // carries the rest for a worker that cannot (a sandboxed agent whose root
 // excludes `.git`, i.e. dispatchCanCommit=false): it COMMITS the worktree diff

package/dist/commands/hooks.js

@@ -9,33 +9,33 @@ import { BRAINCLAW_SECTION_START, BRAINCLAW_SECTION_END, upsertBrainclawSection,
  * deterministically into every agent conversation.
  */
 export function generateCursorHook(projectName) {
-    return `---
-description: brainclaw session bootstrap for ${projectName}
-alwaysApply: true
----
-
-# Brainclaw session bootstrap
-
-Brainclaw is the shared coordination layer for this project. Use its MCP facades first — the CLI is only a fallback when MCP is unavailable.
-
-## At the start of every session
-
-Call \`bclaw_work(intent)\` — it handles session setup, context load, and scope claim in a single call.
-
-- \`bclaw_work(intent: "resume")\` when continuing an existing task.
-- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
-- \`bclaw_work(intent: "consult")\` to read context without claiming.
-
-## To coordinate with other agents
-
-\`bclaw_coordinate(intent)\` — \`assign\`, \`consult\`, \`review\`, or \`reroute\`.
-
-## Before finishing
-
-- Release your claims: \`bclaw_release_claim(id)\`.
-- Close out the session: \`bclaw_session_end\` (or let it auto-release via the session hook).
-
-CLI fallback only: \`brainclaw context\` / \`brainclaw session-end --auto-release\` if MCP is not reachable.
+    return `---
+description: brainclaw session bootstrap for ${projectName}
+alwaysApply: true
+---
+
+# Brainclaw session bootstrap
+
+Brainclaw is the shared coordination layer for this project. Use its MCP facades first — the CLI is only a fallback when MCP is unavailable.
+
+## At the start of every session
+
+Call \`bclaw_work(intent)\` — it handles session setup, context load, and scope claim in a single call.
+
+- \`bclaw_work(intent: "resume")\` when continuing an existing task.
+- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
+- \`bclaw_work(intent: "consult")\` to read context without claiming.
+
+## To coordinate with other agents
+
+\`bclaw_coordinate(intent)\` — \`assign\`, \`consult\`, \`review\`, or \`reroute\`.
+
+## Before finishing
+
+- Release your claims: \`bclaw_release_claim(id)\`.
+- Close out the session: \`bclaw_session_end\` (or let it auto-release via the session hook).
+
+CLI fallback only: \`brainclaw context\` / \`brainclaw session-end --auto-release\` if MCP is not reachable.
 `;
 }
 /**
@@ -44,58 +44,58 @@ CLI fallback only: \`brainclaw context\` / \`brainclaw session-end --auto-releas
  * delimited "SESSION START" block acts as a deterministic trigger.
  */
 export function generateWindsurfHook(projectName) {
-    return `# Brainclaw session trigger — ${projectName}
-# This block is always active. Windsurf Cascade reads .windsurfrules on every activation.
-
-## SESSION START (always run first)
-
-Call the Brainclaw MCP facade before responding to any request:
-
-- \`bclaw_work(intent: "resume")\` when continuing an existing task.
-- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
-- \`bclaw_work(intent: "consult")\` to read context without claiming.
-
-This returns active constraints, recent decisions, known traps, open plans, active claims, and the last handoff. Do not skip.
-
-## COORDINATION
-
-\`bclaw_coordinate(intent)\` to assign, consult, review, or reroute other agents.
-
-## SESSION END (before finishing)
-
-- \`bclaw_release_claim(id)\` for each claim you hold.
-- \`bclaw_session_end\` to close the session (auto-releases remaining claims).
-
-CLI fallback only when MCP is unavailable: \`brainclaw context\` / \`brainclaw session-end --auto-release\`.
+    return `# Brainclaw session trigger — ${projectName}
+# This block is always active. Windsurf Cascade reads .windsurfrules on every activation.
+
+## SESSION START (always run first)
+
+Call the Brainclaw MCP facade before responding to any request:
+
+- \`bclaw_work(intent: "resume")\` when continuing an existing task.
+- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
+- \`bclaw_work(intent: "consult")\` to read context without claiming.
+
+This returns active constraints, recent decisions, known traps, open plans, active claims, and the last handoff. Do not skip.
+
+## COORDINATION
+
+\`bclaw_coordinate(intent)\` to assign, consult, review, or reroute other agents.
+
+## SESSION END (before finishing)
+
+- \`bclaw_release_claim(id)\` for each claim you hold.
+- \`bclaw_session_end\` to close the session (auto-releases remaining claims).
+
+CLI fallback only when MCP is unavailable: \`brainclaw context\` / \`brainclaw session-end --auto-release\`.
 `;
 }
 /**
  * Generate a generic markdown session-trigger section.
  */
 export function generateMarkdownHook(agentName, projectName) {
-    return `# Brainclaw session trigger — ${projectName}
-# This block is always active. ${agentName} reads this file on every activation.
-
-## SESSION START (always run first)
-
-Call the Brainclaw MCP facade before responding to any request:
-
-- \`bclaw_work(intent: "resume")\` when continuing an existing task.
-- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
-- \`bclaw_work(intent: "consult")\` to read context without claiming.
-
-This returns active constraints, recent decisions, known traps, open plans, active claims, and the last handoff. Do not skip.
-
-## COORDINATION
-
-\`bclaw_coordinate(intent)\` to assign, consult, review, or reroute other agents.
-
-## SESSION END (before finishing)
-
-- \`bclaw_release_claim(id)\` for each claim you hold.
-- \`bclaw_session_end\` to close the session (auto-releases remaining claims).
-
-CLI fallback only when MCP is unavailable: \`brainclaw context\` / \`brainclaw session-end --auto-release\`.
+    return `# Brainclaw session trigger — ${projectName}
+# This block is always active. ${agentName} reads this file on every activation.
+
+## SESSION START (always run first)
+
+Call the Brainclaw MCP facade before responding to any request:
+
+- \`bclaw_work(intent: "resume")\` when continuing an existing task.
+- \`bclaw_work(intent: "execute", scope: "<path>", task: "<text>")\` when starting new work on a specific scope.
+- \`bclaw_work(intent: "consult")\` to read context without claiming.
+
+This returns active constraints, recent decisions, known traps, open plans, active claims, and the last handoff. Do not skip.
+
+## COORDINATION
+
+\`bclaw_coordinate(intent)\` to assign, consult, review, or reroute other agents.
+
+## SESSION END (before finishing)
+
+- \`bclaw_release_claim(id)\` for each claim you hold.
+- \`bclaw_session_end\` to close the session (auto-releases remaining claims).
+
+CLI fallback only when MCP is unavailable: \`brainclaw context\` / \`brainclaw session-end --auto-release\`.
 `;
 }
 export function writeHook(content, relativePath, cwd) {

package/dist/commands/init.js

@@ -117,7 +117,7 @@ export async function runInit(options = {}) {
     });
     // Auto-detect and register the AI coding agent running in this environment
     const detectedAi = skipAgentBootstrap ? undefined : detectAiAgent();
-    let registeredAiAgent = detectedAi
+    const registeredAiAgent = detectedAi
         ? registerAgentIdentity({
             agentName: detectedAi.name,
             kind: detectedAi.kind,

package/dist/commands/install-hooks.js

@@ -40,63 +40,63 @@ export function runInstallHooks(options = {}) {
     }
 }
 function generateClaudePreToolScript() {
-    return `#!/bin/sh
-# brainclaw Claude Code preToolUse hook
-# Generated by: brainclaw install-hooks
-exec node -e "
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const toolName = process.env.CLAUDE_TOOL_NAME || process.argv[2] || process.env.TOOL_NAME || '';
-const isWrite = /edit|write|replace|bash|str_replace/i.test(toolName);
-
-if (!isWrite || !toolName) process.exit(0);
-
-try {
-  const BCLAW_CMD = fs.existsSync(path.join(process.cwd(), 'node_modules', '.bin', 'brainclaw')) 
-    ? 'npx brainclaw' : 'brainclaw';
-  const out = execSync(BCLAW_CMD + ' claim list --json', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
-  const claims = JSON.parse(out);
-  if (claims && claims.length > 0) process.exit(0);
-} catch (e) {
-  // ignore if brainclaw not found or fails
-  process.exit(0);
-}
-
-const sessionMark = path.join(process.cwd(), '.brainclaw', 'tmp', 'claude_warned');
-if (!fs.existsSync(path.dirname(sessionMark))) fs.mkdirSync(path.dirname(sessionMark), { recursive: true });
-
-if (fs.existsSync(sessionMark)) {
-  const mtime = fs.statSync(sessionMark).mtimeMs;
-  if (Date.now() - mtime < 2 * 60 * 60 * 1000) {
-    process.exit(0); // already warned this session
-  }
-}
-fs.writeFileSync(sessionMark, Date.now().toString());
-
-process.stderr.write('\\n[Brainclaw] ⚠️  WARNING: You are about to use an Edit/Write tool (' + toolName + ') but you have NO active claim.\\n');
-process.stderr.write('[Brainclaw] Consider running \\\`brainclaw claim create <scope>\\\` to lock your work and avoid conflicts.\\n\\n');
-" 2>&1 || exit 0
+    return `#!/bin/sh
+# brainclaw Claude Code preToolUse hook
+# Generated by: brainclaw install-hooks
+exec node -e "
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const toolName = process.env.CLAUDE_TOOL_NAME || process.argv[2] || process.env.TOOL_NAME || '';
+const isWrite = /edit|write|replace|bash|str_replace/i.test(toolName);
+
+if (!isWrite || !toolName) process.exit(0);
+
+try {
+  const BCLAW_CMD = fs.existsSync(path.join(process.cwd(), 'node_modules', '.bin', 'brainclaw')) 
+    ? 'npx brainclaw' : 'brainclaw';
+  const out = execSync(BCLAW_CMD + ' claim list --json', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+  const claims = JSON.parse(out);
+  if (claims && claims.length > 0) process.exit(0);
+} catch (e) {
+  // ignore if brainclaw not found or fails
+  process.exit(0);
+}
+
+const sessionMark = path.join(process.cwd(), '.brainclaw', 'tmp', 'claude_warned');
+if (!fs.existsSync(path.dirname(sessionMark))) fs.mkdirSync(path.dirname(sessionMark), { recursive: true });
+
+if (fs.existsSync(sessionMark)) {
+  const mtime = fs.statSync(sessionMark).mtimeMs;
+  if (Date.now() - mtime < 2 * 60 * 60 * 1000) {
+    process.exit(0); // already warned this session
+  }
+}
+fs.writeFileSync(sessionMark, Date.now().toString());
+
+process.stderr.write('\\n[Brainclaw] ⚠️  WARNING: You are about to use an Edit/Write tool (' + toolName + ') but you have NO active claim.\\n');
+process.stderr.write('[Brainclaw] Consider running \\\`brainclaw claim create <scope>\\\` to lock your work and avoid conflicts.\\n\\n');
+" 2>&1 || exit 0
 `;
 }
 function generatePostMergeScript() {
-    return `#!/bin/sh
-# brainclaw post-merge hook
-# Auto-releases claims whose scope overlaps with files changed by the merge
-# Generated by: brainclaw install-hooks
-
-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
-$BCLAW_CMD worktree clean 2>/dev/null || true
+    return `#!/bin/sh
+# brainclaw post-merge hook
+# Auto-releases claims whose scope overlaps with files changed by the merge
+# Generated by: brainclaw install-hooks
+
+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
+$BCLAW_CMD worktree clean 2>/dev/null || true
 `;
 }
 function findGitRoot(cwd) {
@@ -113,30 +113,30 @@ function findGitRoot(cwd) {
 function generateHookScript() {
     // Use node directly to avoid sh.exe pipe issues on Windows (SIGPIPE).
     // The script is a self-contained node -e that runs both checks.
-    return `#!/bin/sh
-# brainclaw pre-commit hook — generated by brainclaw install-hooks
-# Runs via node to avoid sh.exe SIGPIPE issues on Windows.
-exec node -e "
-const { execSync } = require('child_process');
-const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' }).trim();
-if (!staged) process.exit(0);
-
-// Check 1: reject staged .brainclaw/ files
-const brainclawFiles = staged.split('\\\\n').filter(f => f.startsWith('.brainclaw/'));
-if (brainclawFiles.length > 0) {
-  process.stderr.write('\\\\nbrainclaw: .brainclaw/ files are staged — blocked.\\\\n');
-  brainclawFiles.forEach(f => process.stderr.write('  ' + f + '\\\\n'));
-  process.stderr.write('  Fix: git reset HEAD .brainclaw/\\\\n\\\\n');
-  process.exit(1);
-}
-
-// Check 2: active constraint violations
-try {
-  execSync('brainclaw check-constraints --staged', { stdio: 'inherit' });
-} catch (e) {
-  if (e.status) process.exit(e.status);
-}
-" 2>&1 || exit $?
+    return `#!/bin/sh
+# brainclaw pre-commit hook — generated by brainclaw install-hooks
+# Runs via node to avoid sh.exe SIGPIPE issues on Windows.
+exec node -e "
+const { execSync } = require('child_process');
+const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' }).trim();
+if (!staged) process.exit(0);
+
+// Check 1: reject staged .brainclaw/ files
+const brainclawFiles = staged.split('\\\\n').filter(f => f.startsWith('.brainclaw/'));
+if (brainclawFiles.length > 0) {
+  process.stderr.write('\\\\nbrainclaw: .brainclaw/ files are staged — blocked.\\\\n');
+  brainclawFiles.forEach(f => process.stderr.write('  ' + f + '\\\\n'));
+  process.stderr.write('  Fix: git reset HEAD .brainclaw/\\\\n\\\\n');
+  process.exit(1);
+}
+
+// Check 2: active constraint violations
+try {
+  execSync('brainclaw check-constraints --staged', { stdio: 'inherit' });
+} catch (e) {
+  if (e.status) process.exit(e.status);
+}
+" 2>&1 || exit $?
 `;
 }
 //# sourceMappingURL=install-hooks.js.map