brainclaw 0.25.3 → 0.28.0

package/dist/commands/migrate.js

@@ -0,0 +1,75 @@
+import { loadState, persistState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+export function runMigrate(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (options.promoteMachineItems) {
+        promoteMachineItems(cwd, options.dryRun ?? false);
+    }
+    else {
+        console.log('Usage: brainclaw migrate --promote-machine-items [--dry-run]');
+        console.log('');
+        console.log('Moves items tagged scope:machine from project store to user store (~/.brainclaw/).');
+    }
+}
+function promoteMachineItems(cwd, dryRun) {
+    const state = loadState(cwd);
+    const agent = resolveCurrentAgentName(cwd);
+    const machineConstraints = state.active_constraints.filter((c) => c.scope === 'machine');
+    const machineDecisions = state.recent_decisions.filter((d) => d.scope === 'machine');
+    const machineTraps = state.known_traps.filter((t) => t.scope === 'machine');
+    const total = machineConstraints.length + machineDecisions.length + machineTraps.length;
+    if (total === 0) {
+        console.log('No machine-scoped items found in project store.');
+        return;
+    }
+    console.log(`Found ${total} machine-scoped item(s) in project store:\n`);
+    for (const c of machineConstraints)
+        console.log(`  [constraint] ${c.id} — ${c.text.slice(0, 80)}`);
+    for (const d of machineDecisions)
+        console.log(`  [decision]   ${d.id} — ${d.text.slice(0, 80)}`);
+    for (const t of machineTraps)
+        console.log(`  [trap]       ${t.id} — ${t.text.slice(0, 80)}`);
+    if (dryRun) {
+        console.log(`\n(dry-run) Would move ${total} item(s) to user store.`);
+        return;
+    }
+    // Resolve user store
+    let userCwd;
+    try {
+        userCwd = resolveTargetStore(cwd, 'user');
+    }
+    catch {
+        console.error('Error: cannot resolve user store. Run `brainclaw setup` first.');
+        process.exit(1);
+    }
+    const userState = loadState(userCwd);
+    // Move constraints
+    for (const c of machineConstraints) {
+        userState.active_constraints.push(c);
+        state.active_constraints = state.active_constraints.filter((x) => x.id !== c.id);
+        appendAuditEntry({ actor: agent, action: 'update', item_id: c.id, item_type: 'constraint', reason: 'promote to user store (machine scope)' }, cwd);
+    }
+    // Move decisions
+    for (const d of machineDecisions) {
+        userState.recent_decisions.push(d);
+        state.recent_decisions = state.recent_decisions.filter((x) => x.id !== d.id);
+        appendAuditEntry({ actor: agent, action: 'update', item_id: d.id, item_type: 'decision', reason: 'promote to user store (machine scope)' }, cwd);
+    }
+    // Move traps
+    for (const t of machineTraps) {
+        userState.known_traps.push(t);
+        state.known_traps = state.known_traps.filter((x) => x.id !== t.id);
+        appendAuditEntry({ actor: agent, action: 'update', item_id: t.id, item_type: 'trap', reason: 'promote to user store (machine scope)' }, cwd);
+    }
+    persistState(userState, userCwd);
+    persistState(state, cwd);
+    console.log(`\n✔ Promoted ${total} item(s) to user store (${userCwd})`);
+}
+//# sourceMappingURL=migrate.js.map

package/dist/commands/tool.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 { listTools, createTool } from '../core/registries.js';
 export function runTool(subcommand, args, options = {}) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
     if (!memoryExists(cwd)) {
@@ -46,10 +45,7 @@ export function runTool(subcommand, args, options = {}) {
     }
 }
 function runToolList(cwd) {
-    const state = loadState(cwd);
-    const tools = state.recent_decisions
-        .filter((d) => d.tags.includes('tool'))
-        .map((d) => ({ id: d.id, name: d.text.split('\n')[0], type: d.tags.find((t) => t !== 'tool') }));
+    const tools = listTools(cwd);
     if (tools.length === 0) {
         console.log('No tools registered yet.');
         return;
@@ -57,9 +53,7 @@ function runToolList(cwd) {
     console.log(`\n${tools.length} tool(s):\n`);
     tools.forEach((tool) => {
         console.log(`  [${tool.id}] ${tool.name}`);
-        if (tool.type) {
-            console.log(`      type: ${tool.type}`);
-        }
+        console.log(`      type: ${tool.type}`);
     });
     console.log('');
 }
@@ -74,50 +68,46 @@ function runToolAdd(name, description, options, cwd) {
             process.exit(1);
         }
     }
-    const state = loadState(cwd);
-    const { id, short_label } = generateIdWithLabel('recent_decisions');
-    const toolType = options.type ?? 'utility';
-    const entry = {
-        id,
-        short_label,
-        text: name,
-        created_at: nowISO(),
+    const tool = createTool({
+        name,
+        description,
+        type: options.type,
+        tags: options.tag,
         author: options.author ?? resolveCurrentAgentName(cwd),
-        tags: ['tool', toolType, ...(options.tag ?? [])],
-    };
-    // For now, store as decision to avoid schema migration
-    // Will migrate to separate tool storage in v0.16
-    state.recent_decisions.push(entry);
-    persistState(state, cwd);
-    console.log(`✔ Tool added: [${id}] ${name}`);
-    console.log('  (Stored in decisions for now; will move to dedicated registry in v0.16)');
+    }, cwd);
+    console.log(`✔ Tool added: [${tool.id}] ${name} (${tool.type})`);
 }
 function runToolDescribe(toolId, cwd) {
-    const state = loadState(cwd);
-    const decision = state.recent_decisions.find((d) => d.id === toolId || d.short_label === toolId);
-    if (!decision) {
+    const tools = listTools(cwd);
+    const tool = tools.find((t) => t.id === toolId || t.id.startsWith(toolId));
+    if (!tool) {
         console.error(`Error: tool '${toolId}' not found`);
         process.exit(1);
     }
-    console.log(`\nTool: ${decision.text}`);
-    console.log(`ID: ${decision.id}`);
-    console.log(`Type: ${decision.tags.find((t) => t !== 'tool')}`);
-    console.log(`Author: ${decision.author}`);
-    console.log(`Created: ${decision.created_at}`);
+    console.log(`\nTool: ${tool.name}`);
+    console.log(`Description: ${tool.description}`);
+    console.log(`ID: ${tool.id}`);
+    console.log(`Type: ${tool.type}`);
+    console.log(`Author: ${tool.author}`);
+    console.log(`Created: ${tool.created_at}`);
+    if (tool.tags.length > 0) {
+        console.log(`Tags: ${tool.tags.join(', ')}`);
+    }
     console.log('');
 }
 function runToolSearch(query, cwd) {
-    const state = loadState(cwd);
-    const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
-    const results = tools.filter((tool) => tool.text.toLowerCase().includes(query.toLowerCase()) ||
-        tool.tags.some((tag) => tag.toLowerCase().includes(query.toLowerCase())));
+    const tools = listTools(cwd);
+    const queryLower = query.toLowerCase();
+    const results = tools.filter((tool) => tool.name.toLowerCase().includes(queryLower) ||
+        tool.description.toLowerCase().includes(queryLower) ||
+        tool.tags.some((tag) => tag.toLowerCase().includes(queryLower)));
     if (results.length === 0) {
         console.log(`No tools found matching '${query}'`);
         return;
     }
     console.log(`\n${results.length} tool(s) matching '${query}':\n`);
-    results.forEach((result) => {
-        console.log(`  [${result.id}] ${result.text.split('\n')[0]}`);
+    results.forEach((tool) => {
+        console.log(`  [${tool.id}] ${tool.name} (${tool.type})`);
     });
     console.log('');
 }

package/dist/core/agent-capability.js

@@ -9,137 +9,82 @@
  *   C (limited) — no MCP → rich static content (plans, traps, decisions)
  */
 const PROFILES = {
+    // --- Code agents (interactive, IDE-driven) ---
     'claude-code': {
-        name: 'claude-code',
-        hasMcp: true,
-        hasHooks: true,
-        hasAutoApprove: true,
-        hasSkills: true,
-        hasRules: true,
-        instructionFile: 'CLAUDE.md',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'both',
-        templateTier: 'A',
+        name: 'claude-code', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: true, hasAutoApprove: true, hasSkills: true, hasRules: true,
+        instructionFile: 'CLAUDE.md', sharedInstructionFile: true, mcpConfigScope: 'both', templateTier: 'A',
     },
     cursor: {
-        name: 'cursor',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: '.cursor/rules/brainclaw.md',
-        sharedInstructionFile: false,
-        mcpConfigScope: 'machine',
-        templateTier: 'B',
+        name: 'cursor', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: '.cursor/rules/brainclaw.md', sharedInstructionFile: false, mcpConfigScope: 'machine', templateTier: 'B',
     },
     windsurf: {
-        name: 'windsurf',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: '.windsurfrules',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'machine',
-        templateTier: 'B',
+        name: 'windsurf', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: '.windsurfrules', sharedInstructionFile: true, mcpConfigScope: 'machine', templateTier: 'B',
     },
     cline: {
-        name: 'cline',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: true,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: '.clinerules/brainclaw.md',
-        sharedInstructionFile: false,
-        mcpConfigScope: 'project',
-        templateTier: 'B',
+        name: 'cline', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: true, hasSkills: false, hasRules: true,
+        instructionFile: '.clinerules/brainclaw.md', sharedInstructionFile: false, mcpConfigScope: 'project', templateTier: 'B',
     },
     roo: {
-        name: 'roo',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: true,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: '.roo/rules/brainclaw.md',
-        sharedInstructionFile: false,
-        mcpConfigScope: 'project',
-        templateTier: 'B',
+        name: 'roo', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: true, hasSkills: false, hasRules: true,
+        instructionFile: '.roo/rules/brainclaw.md', sharedInstructionFile: false, mcpConfigScope: 'project', templateTier: 'B',
     },
     continue: {
-        name: 'continue',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: '.continue/rules/brainclaw.md',
-        sharedInstructionFile: false,
-        mcpConfigScope: 'both',
-        templateTier: 'B',
+        name: 'continue', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: '.continue/rules/brainclaw.md', sharedInstructionFile: false, mcpConfigScope: 'both', templateTier: 'B',
     },
     opencode: {
-        name: 'opencode',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: 'AGENTS.md',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'project',
-        templateTier: 'B',
+        name: 'opencode', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: 'AGENTS.md', sharedInstructionFile: true, mcpConfigScope: 'project', templateTier: 'B',
     },
     codex: {
-        name: 'codex',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: 'AGENTS.md',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'machine',
-        templateTier: 'B',
+        name: 'codex', category: 'code-agent', workflowModel: 'task-based',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: 'AGENTS.md', sharedInstructionFile: true, mcpConfigScope: 'machine', templateTier: 'B',
     },
     antigravity: {
-        name: 'antigravity',
-        hasMcp: true,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: false,
-        hasRules: true,
-        instructionFile: 'GEMINI.md',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'machine',
-        templateTier: 'B',
+        name: 'antigravity', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
+        instructionFile: 'GEMINI.md', sharedInstructionFile: true, mcpConfigScope: 'machine', templateTier: 'B',
     },
     'github-copilot': {
-        name: 'github-copilot',
-        hasMcp: false,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: true,
-        hasRules: true,
-        instructionFile: '.github/copilot-instructions.md',
-        sharedInstructionFile: true,
-        mcpConfigScope: 'none',
-        templateTier: 'C',
+        name: 'github-copilot', category: 'code-agent', workflowModel: 'interactive',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: true,
+        instructionFile: '.github/copilot-instructions.md', sharedInstructionFile: true, mcpConfigScope: 'none', templateTier: 'C',
     },
+    // --- Autonomous agents (headless, task-based or scheduled) ---
     openclaw: {
-        name: 'openclaw',
-        hasMcp: false,
-        hasHooks: false,
-        hasAutoApprove: false,
-        hasSkills: true,
-        hasRules: false,
-        instructionFile: 'skills/openclaw/SKILL.md',
-        sharedInstructionFile: false,
-        mcpConfigScope: 'none',
-        templateTier: 'C',
+        name: 'openclaw', category: 'autonomous-agent', workflowModel: 'task-based',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: false,
+        instructionFile: 'skills/openclaw/SKILL.md', sharedInstructionFile: false, mcpConfigScope: 'none', templateTier: 'C',
+    },
+    nanoclaw: {
+        name: 'nanoclaw', category: 'autonomous-agent', workflowModel: 'task-based',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: false,
+        instructionFile: 'skills/nanoclaw/SKILL.md', sharedInstructionFile: false, mcpConfigScope: 'none', templateTier: 'C',
+    },
+    nemoclaw: {
+        name: 'nemoclaw', category: 'autonomous-agent', workflowModel: 'task-based',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: false,
+        instructionFile: 'skills/nemoclaw/SKILL.md', sharedInstructionFile: false, mcpConfigScope: 'none', templateTier: 'C',
+    },
+    picoclaw: {
+        name: 'picoclaw', category: 'autonomous-agent', workflowModel: 'scheduled',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: false,
+        instructionFile: 'skills/picoclaw/SKILL.md', sharedInstructionFile: false, mcpConfigScope: 'none', templateTier: 'C',
+    },
+    zeroclaw: {
+        name: 'zeroclaw', category: 'autonomous-agent', workflowModel: 'task-based',
+        hasMcp: false, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: false,
+        instructionFile: 'skills/zeroclaw/SKILL.md', sharedInstructionFile: false, mcpConfigScope: 'none', templateTier: 'C',
     },
 };
 /**

package/dist/core/agent-files.js

@@ -441,6 +441,12 @@ function buildCommandHookEntry(command) {
         hooks: [{ type: 'command', command }],
     };
 }
+function buildMatchedCommandHookEntry(matcher, command) {
+    return {
+        matcher,
+        hooks: [{ type: 'command', command }],
+    };
+}
 function containsCommandHook(entries, command) {
     return entries.some((entry) => isJsonObject(entry) &&
         Array.isArray(entry.hooks) &&
@@ -582,6 +588,13 @@ export function ensureClaudeCodeSettings(cwd) {
         stopHooks.push(buildCommandHookEntry(stopCommand));
     }
     hooks.Stop = stopHooks;
+    // PostToolUse — check for unseen events after any brainclaw MCP tool call
+    const checkEventsCommand = 'npx brainclaw check-events 2>/dev/null';
+    const postToolHooks = Array.isArray(hooks.PostToolUse) ? [...hooks.PostToolUse] : [];
+    if (!containsCommandHook(postToolHooks, checkEventsCommand)) {
+        postToolHooks.push(buildMatchedCommandHookEntry('mcp__brainclaw__', checkEventsCommand));
+    }
+    hooks.PostToolUse = postToolHooks;
     const { created, updated } = writeJsonFileIfChanged(filePath, {
         ...existing,
         permissions,

package/dist/core/agent-integrations.js

@@ -12,6 +12,11 @@ const SUPPORTED_AGENT_INTEGRATION_NAMES = new Set([
     'antigravity',
     'continue',
     'roo',
+    'openclaw',
+    'nanoclaw',
+    'nemoclaw',
+    'picoclaw',
+    'zeroclaw',
 ]);
 const DEFAULT_SURFACES = {
     'github-copilot': [
@@ -60,6 +65,18 @@ const DEFAULT_SURFACES = {
     'openclaw': [
         { kind: 'skill', location: 'machine', path: '.openclaw/workspace/skills/brainclaw/SKILL.md' },
     ],
+    'nanoclaw': [
+        { kind: 'skill', location: 'workspace', path: 'skills/nanoclaw/SKILL.md' },
+    ],
+    'nemoclaw': [
+        { kind: 'skill', location: 'workspace', path: 'skills/nemoclaw/SKILL.md' },
+    ],
+    'picoclaw': [
+        { kind: 'skill', location: 'workspace', path: 'skills/picoclaw/SKILL.md' },
+    ],
+    'zeroclaw': [
+        { kind: 'skill', location: 'workspace', path: 'skills/zeroclaw/SKILL.md' },
+    ],
 };
 function mergeSurfaces(current, next) {
     const merged = [...current];

package/dist/core/context.js

@@ -13,7 +13,7 @@ import { inferProjectFromTarget, loadInstructions, resolveInstructions } from '.
 import { buildCurrentAgentResumeSummary, buildReputationRankingLookup } from './reputation.js';
 import { loadState } from './state.js';
 import { listCandidates } from './candidates.js';
-import { listClaims } from './claims.js';
+import { listClaims, isClaimExpired } from './claims.js';
 import { listRuntimeNotes } from './runtime.js';
 import { isTrapActive, listOperationalTraps } from './traps.js';
 import { buildEstimationReport } from '../commands/estimation-report.js';
@@ -67,6 +67,7 @@ export function buildContext(options = {}) {
             score: 0,
             reasons: [],
             extra: meta.join(', '),
+            provenance: { actor: plan.author },
         });
     }
     for (const c of state.active_constraints) {
@@ -316,10 +317,36 @@ export function buildContext(options = {}) {
         items.splice(0, items.length, ...items.filter((i) => allowed.includes(i.section)));
     }
     const queryTerms = tokenise(target);
+    // Agent-layer scoring: boost items related to the current agent's claims
+    const agentName = agent;
+    const agentId = currentAgentIdentity?.agent_id;
+    const allClaims = [...listClaims(contextCwd), ...parentStoreClaims];
+    const myClaims = allClaims.filter((c) => c.status === 'active' && (agentId ? c.agent_id === agentId : c.agent === agentName));
+    const myClaimScopes = myClaims.map((c) => c.scope);
+    const otherActiveClaims = allClaims.filter((c) => c.status === 'active' && !(agentId ? c.agent_id === agentId : c.agent === agentName));
     for (const item of items) {
         const relevance = computeRelevance(item, queryTerms, profile, target);
         item.score = relevance.score;
         item.reasons = relevance.reasons;
+        // Layer 1: boost items in my claimed scope (+6)
+        if (item.score >= 0 && myClaimScopes.length > 0 && item.related_paths) {
+            const overlaps = item.related_paths.some((p) => myClaimScopes.some((scope) => p.includes(scope) || scope.includes(p)));
+            if (overlaps) {
+                item.score += 6;
+                item.reasons = uniqueReasons([...item.reasons, 'agent-layer: my claimed scope']);
+            }
+        }
+        // Layer 1: boost plans assigned to me (+5)
+        if (item.score >= 0 && item.section === 'plan' && item.extra?.includes(`assignee:${agentName}`)) {
+            item.score += 5;
+            item.reasons = uniqueReasons([...item.reasons, 'agent-layer: my assigned plan']);
+        }
+        // Layer 2: boost items authored by me (+2)
+        if (item.score >= 0 && item.provenance?.actor === agentName) {
+            item.score += 2;
+            item.reasons = uniqueReasons([...item.reasons, 'agent-layer: my authored item']);
+        }
+        // Reputation signal
         if (item.score >= 0 && item.provenance) {
             const trustBonus = rankingLookup.getRankingBonus(item.provenance.actor_id, item.provenance.actor);
             if (trustBonus > 0) {
@@ -327,6 +354,14 @@ export function buildContext(options = {}) {
                 item.reasons = uniqueReasons([...item.reasons, `reputation signal:+${trustBonus.toFixed(2)}`]);
             }
         }
+        // Layer 3: boost machine-scoped items for broader visibility (+1)
+        if (item.score >= 0) {
+            const itemScope = item.scope;
+            if (itemScope === 'machine') {
+                item.score += 1;
+                item.reasons = uniqueReasons([...item.reasons, 'machine-scope signal']);
+            }
+        }
     }
     const ranked = items
         .filter(item => item.score >= 0)
@@ -384,18 +419,15 @@ export function buildContext(options = {}) {
         ? summariseAgentTooling(rawAgentTooling)
         : undefined;
     // Build open_work: active claims and in_progress plans owned by the current agent
+    // Reuses myClaims computed in agent-layer scoring above
     let openWork;
     if (currentAgentIdentity || agent) {
-        const agentName = agent;
-        const agentId = currentAgentIdentity?.agent_id;
-        const allClaims = [...listClaims(contextCwd), ...parentStoreClaims];
-        const activeClaims = allClaims.filter((c) => c.status === 'active' && (agentId ? c.agent_id === agentId : c.agent === agentName));
-        const claimPlanIds = new Set(activeClaims.map((c) => c.plan_id).filter(Boolean));
+        const claimPlanIds = new Set(myClaims.map((c) => c.plan_id).filter(Boolean));
         const inProgressPlans = state.plan_items.filter((p) => p.status === 'in_progress' &&
             (p.assignee === agentName || claimPlanIds.has(p.id)));
-        if (activeClaims.length > 0 || inProgressPlans.length > 0) {
+        if (myClaims.length > 0 || inProgressPlans.length > 0) {
             openWork = {
-                active_claims: activeClaims.map(({ id, scope, description, created_at, plan_id, expires_at }) => ({ id, scope, description, created_at, plan_id, expires_at })),
+                active_claims: myClaims.map(({ id, scope, description, created_at, plan_id, expires_at }) => ({ id, scope, description, created_at, plan_id, expires_at })),
                 in_progress_plans: inProgressPlans.map(({ id, text, assignee }) => ({ id, text, assignee })),
             };
         }
@@ -471,6 +503,8 @@ export function buildContext(options = {}) {
             }
         })(),
         cross_project_items: crossProjectItems.length > 0 ? crossProjectItems : undefined,
+        claim_conflicts: detectClaimConflicts(myClaims, otherActiveClaims),
+        workflow_hints: buildWorkflowHints(myClaims, openWork, state.plan_items),
         selected,
     };
     if (options.digest) {
@@ -1232,4 +1266,64 @@ function applyCharBudget(items, maxChars) {
     }
     return selected;
 }
+// --- Claim conflict detection ---
+function detectClaimConflicts(myClaims, otherClaims) {
+    if (myClaims.length === 0 || otherClaims.length === 0)
+        return undefined;
+    const conflicts = [];
+    for (const mine of myClaims) {
+        for (const other of otherClaims) {
+            if (isClaimExpired(other))
+                continue;
+            const overlap = scopesOverlap(mine.scope, other.scope);
+            if (overlap) {
+                conflicts.push({
+                    my_claim_id: mine.id,
+                    my_scope: mine.scope,
+                    other_claim_id: other.id,
+                    other_agent: other.agent,
+                    other_scope: other.scope,
+                    overlap_reason: overlap,
+                });
+            }
+        }
+    }
+    return conflicts.length > 0 ? conflicts : undefined;
+}
+function scopesOverlap(a, b) {
+    const aParts = a.replace(/\\/g, '/').split(/\s+/);
+    const bParts = b.replace(/\\/g, '/').split(/\s+/);
+    for (const ap of aParts) {
+        for (const bp of bParts) {
+            if (ap === bp)
+                return `exact match: ${ap}`;
+            if (ap.startsWith(bp + '/') || bp.startsWith(ap + '/'))
+                return `path overlap: ${ap} ↔ ${bp}`;
+        }
+    }
+    return null;
+}
+// --- Workflow hints ---
+function buildWorkflowHints(myClaims, openWork, plans) {
+    const hints = [];
+    // No claims — suggest claiming before editing
+    if (myClaims.length === 0) {
+        const todoPlans = plans.filter((p) => p.status === 'todo' && p.priority === 'high');
+        if (todoPlans.length > 0) {
+            hints.push(`${todoPlans.length} high-priority plan(s) available — consider claiming one with bclaw_claim`);
+        }
+    }
+    // Multiple unclosed claims — suggest releasing finished ones
+    if (myClaims.length > 2) {
+        hints.push(`You have ${myClaims.length} active claims — consider releasing finished ones with bclaw_release_claim`);
+    }
+    // In-progress plans without claims
+    if (openWork) {
+        const unclaimedInProgress = openWork.in_progress_plans.filter((p) => !openWork.active_claims.some((c) => c.plan_id === p.id));
+        if (unclaimedInProgress.length > 0) {
+            hints.push(`${unclaimedInProgress.length} in-progress plan(s) without a claim — consider claiming the scope you're editing`);
+        }
+    }
+    return hints.length > 0 ? hints : undefined;
+}
 //# sourceMappingURL=context.js.map

package/dist/core/coordination.js

@@ -81,6 +81,31 @@ export function buildCoordinationSnapshot(options = {}) {
         resolved_instructions: instructions,
         reputation_summary: reputationSummary,
         agent_reputation: agentReputation,
+        other_agents: buildOtherAgentsSummary(filteredClaims, filteredNotes, agent),
     };
 }
+function buildOtherAgentsSummary(claims, notes, currentAgent) {
+    const agentMap = new Map();
+    for (const claim of claims) {
+        if (claim.agent === currentAgent)
+            continue;
+        const existing = agentMap.get(claim.agent) ?? { name: claim.agent, claim_count: 0, scopes: [] };
+        existing.claim_count++;
+        existing.scopes.push(claim.scope);
+        if (!existing.last_active || claim.created_at > existing.last_active) {
+            existing.last_active = claim.created_at;
+        }
+        agentMap.set(claim.agent, existing);
+    }
+    for (const note of notes) {
+        if (note.agent === currentAgent)
+            continue;
+        const existing = agentMap.get(note.agent);
+        if (existing && (!existing.last_active || note.created_at > existing.last_active)) {
+            existing.last_active = note.created_at;
+        }
+    }
+    const result = [...agentMap.values()];
+    return result.length > 0 ? result : undefined;
+}
 //# sourceMappingURL=coordination.js.map

package/dist/core/io.js

@@ -35,6 +35,8 @@ const ENTITY_DIR_MAP = {
     // discovery/ — Project entity: what's available
     'bootstrap': 'discovery/bootstrap',
     'bootstrap/seeds': 'discovery/bootstrap/seeds',
+    'capabilities': 'discovery/capabilities',
+    'tools': 'discovery/tools',
     // agents/ — stays at top level (already entity-aligned)
     'agents': 'agents',
 };