brainclaw 0.25.3 → 0.27.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-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/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',
 };

package/dist/core/migration.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import YAML from 'yaml';
 import { memoryDir, memoryPath, readFileSync, writeFileAtomic, resolveEntityDir } from './io.js';
-import { BootstrapApplicationReceiptSchema, BootstrapImportPlanDocumentSchema, AgentIdentityDocumentSchema, BootstrapProfileDocumentSchema, CandidateSchema, ClaimSchema, ConfigSchema, MemorySeedDocumentSchema, ConstraintSchema, CurrentSessionStateSchema, DecisionSchema, HandoffSchema, InstructionEntrySchema, PlanItemSchema, ProjectIdentityDocumentSchema, RuntimeNoteSchema, SessionSnapshotSchema, TrapSchema, AiSurfaceTaskRequestSchema, } from './schema.js';
+import { BootstrapApplicationReceiptSchema, BootstrapImportPlanDocumentSchema, AgentIdentityDocumentSchema, BootstrapProfileDocumentSchema, CandidateSchema, ClaimSchema, ConfigSchema, MemorySeedDocumentSchema, ConstraintSchema, CurrentSessionStateSchema, DecisionSchema, HandoffSchema, InstructionEntrySchema, PlanItemSchema, ProjectIdentityDocumentSchema, RuntimeNoteSchema, SessionSnapshotSchema, TrapSchema, AiSurfaceTaskRequestSchema, ProjectCapabilitySchema, ProjectToolSchema, } from './schema.js';
 export class MigrationError extends Error {
     kind;
     documentType;
@@ -33,6 +33,8 @@ const registry = {
     runtime_note: createRegistryEntry(RuntimeNoteSchema),
     ai_surface_task: createRegistryEntry(AiSurfaceTaskRequestSchema),
     session_snapshot: createRegistryEntry(SessionSnapshotSchema),
+    capability: createRegistryEntry(ProjectCapabilitySchema),
+    tool: createRegistryEntry(ProjectToolSchema),
     trap: createRegistryEntry(TrapSchema),
 };
 function createRegistryEntry(schema) {

package/dist/core/project-discovery.js

@@ -0,0 +1,236 @@
+/**
+ * Project discovery — unified workspace inventory that composes existing
+ * scan functions into a single structured profile.
+ *
+ * Boundary: discovery describes what exists in the workspace RIGHT NOW.
+ * It is NOT canonical memory (decisions, traps, plans). It is NOT
+ * machine profile (shells, SSH keys, WSL distros). It is the project-level
+ * answer to "what MCP servers, skills, hooks, instruction files, and
+ * agent integrations are available in this workspace?"
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildAgentToolingContext } from './agent-context.js';
+import { assessAgentIntegrationReadiness } from './agent-integrations.js';
+import { loadConfig } from './config.js';
+import { memoryDir } from './io.js';
+import { nowISO } from './ids.js';
+// --- Native instruction file discovery (extracted from bootstrap.ts) ---
+const NATIVE_INSTRUCTION_FILES = [
+    'AGENTS.md',
+    'CLAUDE.md',
+    'GEMINI.md',
+    '.windsurfrules',
+    '.github/copilot-instructions.md',
+];
+const NATIVE_INSTRUCTION_DIRS = [
+    '.cursor/rules',
+    '.roo/rules',
+    '.continue/rules',
+    '.clinerules',
+];
+// MCP config files that agents use
+const MCP_CONFIG_FILES = [
+    '.mcp.json',
+    'opencode.json',
+    '.cursor/mcp.json',
+    '.roo/mcp.json',
+    '.continue/config.json',
+];
+// Hook config files
+const HOOK_CONFIG_FILES = [
+    '.claude/settings.local.json',
+    '.cursor/rules/brainclaw-session.mdc',
+];
+export function buildProjectDiscovery(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    // 1. Agent tooling (AGENTS.md, skills, MCP servers)
+    const agentTooling = buildAgentToolingContext({ cwd, env });
+    // 2. Native instruction files
+    const instructionFiles = discoverFiles(cwd, NATIVE_INSTRUCTION_FILES, NATIVE_INSTRUCTION_DIRS);
+    // 3. MCP config files
+    const mcpConfigs = discoverStaticFiles(cwd, MCP_CONFIG_FILES);
+    // 4. Hook config files
+    const hookConfigs = discoverStaticFiles(cwd, HOOK_CONFIG_FILES);
+    // 5. Integration readiness
+    let integrations = [];
+    try {
+        const config = loadConfig(cwd);
+        integrations = assessAgentIntegrationReadiness(config, cwd, env);
+    }
+    catch {
+        // config may not exist yet
+    }
+    const foundInstructions = instructionFiles.filter(f => f.exists);
+    const foundMcpConfigs = mcpConfigs.filter(f => f.exists);
+    const foundHookConfigs = hookConfigs.filter(f => f.exists);
+    return {
+        discovered_at: nowISO(),
+        workspace_root: cwd,
+        agent_tooling: agentTooling,
+        instruction_files: foundInstructions,
+        mcp_configs: foundMcpConfigs,
+        hook_configs: foundHookConfigs,
+        integrations,
+        summary: {
+            total_instruction_files: foundInstructions.length,
+            total_mcp_servers: agentTooling.mcp_servers.length,
+            total_skills: agentTooling.skills.length,
+            total_mcp_configs: foundMcpConfigs.length,
+            total_hook_configs: foundHookConfigs.length,
+            integrations_ready: integrations.filter(i => i.ready).length,
+            integrations_total: integrations.length,
+        },
+    };
+}
+// --- Persistence ---
+const DISCOVERY_PROFILE_FILE = 'discovery-profile.json';
+export function saveDiscoveryProfile(profile, cwd) {
+    const dir = path.join(memoryDir(cwd), 'discovery');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, DISCOVERY_PROFILE_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(profile, null, 2), 'utf-8');
+}
+export function loadDiscoveryProfile(cwd) {
+    const filePath = path.join(memoryDir(cwd), 'discovery', DISCOVERY_PROFILE_FILE);
+    if (!fs.existsSync(filePath))
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+// --- Rendering ---
+export function renderDiscoverySummary(profile) {
+    const lines = [];
+    const s = profile.summary;
+    lines.push('# Project Discovery');
+    lines.push(`Discovered at: ${profile.discovered_at}`);
+    lines.push('');
+    // Instruction files
+    if (profile.instruction_files.length > 0) {
+        lines.push(`## Instruction Files (${s.total_instruction_files})`);
+        for (const f of profile.instruction_files) {
+            const managed = f.managed_by_brainclaw ? ' (managed)' : '';
+            lines.push(`  ${f.path}${managed}`);
+        }
+        lines.push('');
+    }
+    // MCP configs
+    if (profile.mcp_configs.length > 0) {
+        lines.push(`## MCP Configs (${s.total_mcp_configs})`);
+        for (const f of profile.mcp_configs) {
+            lines.push(`  ${f.path}`);
+        }
+        lines.push('');
+    }
+    // MCP servers (from agent tooling)
+    if (s.total_mcp_servers > 0) {
+        lines.push(`## MCP Servers (${s.total_mcp_servers})`);
+        for (const server of profile.agent_tooling.mcp_servers) {
+            lines.push(`  ${server.name} (${server.transport}, ${server.availability})`);
+        }
+        lines.push('');
+    }
+    // Skills
+    if (s.total_skills > 0) {
+        lines.push(`## Skills (${s.total_skills})`);
+        for (const skill of profile.agent_tooling.skills.slice(0, 10)) {
+            lines.push(`  ${skill.name}${skill.description ? `: ${skill.description}` : ''}`);
+        }
+        if (s.total_skills > 10) {
+            lines.push(`  ... and ${s.total_skills - 10} more`);
+        }
+        lines.push('');
+    }
+    // Hook configs
+    if (profile.hook_configs.length > 0) {
+        lines.push(`## Hook Configs (${s.total_hook_configs})`);
+        for (const f of profile.hook_configs) {
+            lines.push(`  ${f.path}`);
+        }
+        lines.push('');
+    }
+    // Integrations
+    if (profile.integrations.length > 0) {
+        lines.push(`## Agent Integrations (${s.integrations_ready}/${s.integrations_total} ready)`);
+        for (const integ of profile.integrations) {
+            const status = integ.ready ? '✔' : '✗';
+            const missing = integ.missing_surfaces.length > 0
+                ? ` — missing: ${integ.missing_surfaces.map(s => s.kind).join(', ')}`
+                : '';
+            lines.push(`  ${status} ${integ.agent_name}${missing}`);
+        }
+        lines.push('');
+    }
+    if (s.total_instruction_files + s.total_mcp_servers + s.total_skills === 0) {
+        lines.push('No integration surfaces detected.');
+    }
+    return lines.join('\n');
+}
+// --- Helpers ---
+function discoverStaticFiles(cwd, files) {
+    const results = [];
+    for (const relativePath of files) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+            const stat = fs.statSync(fullPath);
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: stat.size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    return results;
+}
+function discoverFiles(cwd, files, dirs) {
+    const results = [];
+    for (const relativePath of files) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: fs.statSync(fullPath).size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    for (const relativeDir of dirs) {
+        const dir = path.join(cwd, relativeDir);
+        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+            continue;
+        for (const entry of fs.readdirSync(dir).sort()) {
+            if (!/\.(md|mdc)$/i.test(entry))
+                continue;
+            const relativePath = path.posix.join(relativeDir.replace(/\\/g, '/'), entry);
+            const fullPath = path.join(cwd, relativePath);
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: fs.statSync(fullPath).size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    return results;
+}
+function isManagedByBrainclaw(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8').slice(0, 200);
+        return content.includes('brainclaw') && (content.includes('Managed by brainclaw') ||
+            content.includes('BRAINCLAW_SECTION') ||
+            content.includes('brainclaw export'));
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=project-discovery.js.map