brainclaw 0.25.3 → 0.28.0

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

package/dist/core/registries.js

@@ -0,0 +1,120 @@
+/**
+ * Dedicated registries for project capabilities and tools.
+ *
+ * Replaces the legacy hack of storing capabilities/tools as decisions
+ * with 'capability'/'tool' tags. Items are now persisted as individual
+ * JSON files under discovery/capabilities/ and discovery/tools/.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveEntityDir } from './io.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
+import { ProjectCapabilitySchema, ProjectToolSchema } from './schema.js';
+import { generateIdWithLabel, nowISO } from './ids.js';
+import { appendEvent } from './event-log.js';
+// --- Capabilities ---
+export function listCapabilities(cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'read');
+    if (!dir || !fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const items = [];
+    for (const file of files) {
+        try {
+            const result = loadVersionedJsonFile('capability', path.join(dir, file));
+            items.push(ProjectCapabilitySchema.parse(result.document));
+        }
+        catch {
+            // skip invalid
+        }
+    }
+    return items;
+}
+export function saveCapability(cap, cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'write');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    saveVersionedJsonFile('capability', path.join(dir, `${cap.id}.json`), cap);
+}
+export function deleteCapability(id, cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'read');
+    if (!dir)
+        return false;
+    const fp = path.join(dir, `${id}.json`);
+    if (!fs.existsSync(fp))
+        return false;
+    fs.unlinkSync(fp);
+    return true;
+}
+export function createCapability(opts, cwd) {
+    const idObj = generateIdWithLabel('cap');
+    const cap = {
+        id: idObj.id,
+        name: opts.name,
+        description: opts.description,
+        category: opts.category ?? 'general',
+        tags: opts.tags ?? [],
+        status: 'stable',
+        created_at: nowISO(),
+        author: opts.author,
+        author_id: opts.authorId,
+        model: opts.model,
+    };
+    saveCapability(cap, cwd);
+    appendEvent({ action: 'create', item_type: 'decision', item_id: cap.id, agent: opts.author, agent_id: opts.authorId, summary: `capability: ${opts.name}` }, cwd);
+    return cap;
+}
+// --- Tools ---
+export function listTools(cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'read');
+    if (!dir || !fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const items = [];
+    for (const file of files) {
+        try {
+            const result = loadVersionedJsonFile('tool', path.join(dir, file));
+            items.push(ProjectToolSchema.parse(result.document));
+        }
+        catch {
+            // skip invalid
+        }
+    }
+    return items;
+}
+export function saveTool(tool, cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'write');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    saveVersionedJsonFile('tool', path.join(dir, `${tool.id}.json`), tool);
+}
+export function deleteTool(id, cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'read');
+    if (!dir)
+        return false;
+    const fp = path.join(dir, `${id}.json`);
+    if (!fs.existsSync(fp))
+        return false;
+    fs.unlinkSync(fp);
+    return true;
+}
+export function createTool(opts, cwd) {
+    const idObj = generateIdWithLabel('tol');
+    const tool = {
+        id: idObj.id,
+        name: opts.name,
+        description: opts.description,
+        type: (opts.type ?? 'utility'),
+        implementation: opts.implementation ?? '',
+        tags: opts.tags ?? [],
+        status: 'stable',
+        created_at: nowISO(),
+        author: opts.author,
+        author_id: opts.authorId,
+        model: opts.model,
+    };
+    saveTool(tool, cwd);
+    appendEvent({ action: 'create', item_type: 'decision', item_id: tool.id, agent: opts.author, agent_id: opts.authorId, summary: `tool: ${opts.name}` }, cwd);
+    return tool;
+}
+//# sourceMappingURL=registries.js.map

package/dist/core/schema.js

@@ -42,6 +42,7 @@ export const PrioritySchema = z.enum(['low', 'medium', 'high']);
 export const MemoryVisibilitySchema = z.enum(['shared', 'machine', 'private']);
 export const HandoffStatusSchema = z.enum(['open', 'accepted', 'closed']);
 export const DecisionOutcomeSchema = z.enum(['approved', 'rejected', 'deferred', 'pending']);
+export const MemoryScopeSchema = z.enum(['project', 'machine', 'user']).default('project');
 export const ConstraintSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
@@ -56,6 +57,7 @@ export const ConstraintSchema = z.object({
     session_id: z.string().optional(),
     status: ConstraintStatusSchema,
     category: ConstraintCategorySchema.optional(),
+    scope: MemoryScopeSchema.optional(),
     tags: z.array(z.string()),
     related_paths: z.array(z.string()).optional(),
     expires_at: z.string().optional(),
@@ -73,6 +75,7 @@ export const DecisionSchema = z.object({
     host_id: z.string().optional(),
     session_id: z.string().optional(),
     outcome: DecisionOutcomeSchema.optional(),
+    scope: MemoryScopeSchema.optional(),
     related_paths: z.array(z.string()).optional(),
     plan_id: z.string().optional(),
     tags: z.array(z.string()),
@@ -90,6 +93,7 @@ export const TrapSchema = z.object({
     session_id: z.string().optional(),
     status: TrapStatusSchema.default('active'),
     severity: SeveritySchema,
+    scope: MemoryScopeSchema.optional(),
     tags: z.array(z.string()),
     related_paths: z.array(z.string()).optional(),
     plan_id: z.string().optional(),
@@ -122,10 +126,11 @@ export const HandoffSchema = z.object({
     }).optional(),
 });
 export const PlanStatusSchema = z.enum(['todo', 'in_progress', 'blocked', 'done', 'dropped']);
+export const PlanStepStatusSchema = z.enum(['todo', 'in_progress', 'testing', 'done', 'blocked']);
 export const PlanStepSchema = z.object({
     id: z.string(),
     text: z.string(),
-    status: z.enum(['todo', 'done']),
+    status: PlanStepStatusSchema.default('todo'),
     assignee: z.string().optional(),
     created_at: z.string(),
     updated_at: z.string(),
@@ -413,7 +418,7 @@ export const ProjectModeSchema = z.enum(['single-project', 'multi-project', 'aut
 export const ProjectStrategySchema = z.enum(['manual', 'folder']);
 export const TopologyModeSchema = z.enum(['embedded', 'sidecar', 'local-only']);
 export const IgnoreStrategySchema = z.enum(['project-gitignore', 'none']);
-export const AgentKindSchema = z.enum(['agent', 'human', 'unknown']);
+export const AgentKindSchema = z.enum(['agent', 'autonomous', 'human', 'unknown']);
 export const AgentTrustLevelSchema = z.enum(['observer', 'contributor', 'trusted', 'curator']);
 export const AgentIdentityKeySchema = z.object({
     algorithm: z.literal('ed25519'),
@@ -633,6 +638,10 @@ export const AgentIntegrationNameSchema = z.enum([
     'continue',
     'roo',
     'openclaw',
+    'nanoclaw',
+    'nemoclaw',
+    'picoclaw',
+    'zeroclaw',
 ]);
 export const AgentIntegrationSurfaceKindSchema = z.enum(['instructions', 'mcp', 'skill', 'rule', 'hook']);
 export const AgentIntegrationLocationSchema = z.enum(['workspace', 'machine']);

package/docs/integrations/agents.md

@@ -44,14 +44,21 @@ More directive:
 - The top 5 most critical traps (the agent won't see them otherwise)
 - Explicit step-by-step protocol with all MCP calls listed
 
-### For agents without MCP (Copilot)
+### For agents without MCP (Copilot, autonomous agents)
 
-Full static context:
+Full static context via instruction file or SKILL.md:
 - All of the above
 - Active plans with status and assignees
 - All shared traps
 - Recent architectural decisions
 
+### For autonomous agents (OpenClaw, NanoClaw, NemoClaw, PicoClaw, ZeroClaw)
+
+Skill-based integration via `skills/<agent>/SKILL.md`:
+- Compact brainclaw usage instructions adapted to the agent's workflow
+- Uses `--profile compact` by default (short sessions, constrained resources)
+- Supports task-based and scheduled workflow models
+
 ## Setting up agent integration
 
 ### Automatic (recommended)
@@ -83,7 +90,7 @@ brainclaw export --detect --write          # auto-detect and write all formats
 When brainclaw memory changes (new constraints, resolved traps, updated plans), regenerate instruction files:
 
 ```bash
-brainclaw export --all              # all 9 agent formats at once
+brainclaw export --all              # all 15 agent formats at once
 brainclaw export --detect --write   # only the detected agent
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.25.3",
+  "version": "0.28.0",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {
@@ -13,6 +13,12 @@
     "README.md",
     "LICENSE"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
     "build": "tsc",
     "dev": "tsc && node dist/cli.js",