brainclaw 0.27.0 → 0.29.2

package/README.md

@@ -66,6 +66,8 @@ If you are documenting or integrating an agent workflow, treat MCP as the primar
 
 brainclaw is designed to sit alongside the coding agents teams are already using, not behind a separate hosted control plane.
 
+### Code Agents
+
 | Logo | Agent | Integration | What brainclaw configures |
 |---|---|---|---|
 | [![Claude Code](https://img.shields.io/badge/Claude_Code-111111?logo=anthropic&logoColor=white)](https://github.com/anthropics/claude-code) | **[Claude Code](https://github.com/anthropics/claude-code)** | Full | MCP + CLAUDE.md + hooks + permissions + /brainclaw command |
@@ -78,10 +80,21 @@ brainclaw is designed to sit alongside the coding agents teams are already using
 | [![Continue](https://img.shields.io/badge/Continue-2563EB?logoColor=white)](https://github.com/continuedev/continue) | **[Continue](https://github.com/continuedev/continue)** | Standard | MCP + .continue/rules/ |
 | [![Gemini CLI](https://img.shields.io/badge/Gemini_CLI-1A73E8?logo=googlegemini&logoColor=white)](https://github.com/google-gemini/gemini-cli) | **[Antigravity / Gemini CLI](https://github.com/google-gemini/gemini-cli)** | Standard | MCP + GEMINI.md |
 | [![GitHub Copilot](https://img.shields.io/badge/GitHub_Copilot-181717?logo=githubcopilot&logoColor=white)](https://github.com/features/copilot) | **[GitHub Copilot](https://github.com/features/copilot)** | Limited | copilot-instructions.md + brainclaw-context skill |
-| [![OpenClaw](https://img.shields.io/badge/OpenClaw-FF6B35?logoColor=white)](https://github.com/openclaw/openclaw) | **[OpenClaw](https://github.com/openclaw/openclaw)** | Limited | brainclaw skill (SKILL.md) for structured project memory |
 
 **Full** = MCP + hooks + auto-approve (context injected every prompt). **Standard** = MCP + instruction file (agent must call tools explicitly). **Limited** = skill-based (agent calls brainclaw CLI via skill instructions).
 
+### Autonomous Agents
+
+| Logo | Agent | Workflow | What brainclaw configures |
+|---|---|---|---|
+| [![OpenClaw](https://img.shields.io/badge/OpenClaw-FF6B35?logoColor=white)](https://github.com/openclaw/openclaw) | **[OpenClaw](https://github.com/openclaw/openclaw)** | Task-based | brainclaw skill (SKILL.md) for structured project memory |
+| [![NanoClaw](https://img.shields.io/badge/NanoClaw-4A90D9?logoColor=white)](https://github.com/qwibitai/nanoclaw) | **[NanoClaw](https://github.com/qwibitai/nanoclaw)** | Task-based | brainclaw skill — messaging agent (WhatsApp, Telegram, Slack) |
+| [![NemoClaw](https://img.shields.io/badge/NemoClaw-76B900?logo=nvidia&logoColor=white)](https://github.com/NVIDIA/NemoClaw) | **[NemoClaw](https://github.com/NVIDIA/NemoClaw)** | Task-based | brainclaw skill — NVIDIA enterprise agent stack |
+| [![PicoClaw](https://img.shields.io/badge/PicoClaw-00ADD8?logo=go&logoColor=white)](https://github.com/sipeed/picoclaw) | **[PicoClaw](https://github.com/sipeed/picoclaw)** | Scheduled | brainclaw skill — edge/IoT agent (Go, <10MB RAM) |
+| [![ZeroClaw](https://img.shields.io/badge/ZeroClaw-B7410E?logoColor=white)](https://github.com/zeroclaw-labs/zeroclaw) | **[ZeroClaw](https://github.com/zeroclaw-labs/zeroclaw)** | Task-based | brainclaw skill — ultra-lightweight Rust agent (20+ channels) |
+
+Autonomous agents use brainclaw via CLI skills with `--profile compact` for short sessions and constrained resources.
+
 brainclaw is most effective today when one agent works at a time in a given checkout and the next agent resumes from shared context, claims, and handoffs.
 
 ---

package/dist/cli.js

@@ -1157,6 +1157,17 @@ program
         cwd: globalOpts.cwd,
     });
 });
+program
+    .command('who')
+    .description('Show active agent sessions on this workspace')
+    .option('--json', 'Output as JSON')
+    .option('--all', 'Include stale sessions')
+    .option('--gc', 'Remove stale sessions')
+    .action(async (options) => {
+    const globalOpts = program.opts();
+    const { runWho } = await import('./commands/who.js');
+    runWho({ json: options.json, all: options.all, gc: options.gc, cwd: globalOpts.cwd });
+});
 program.parseAsync(process.argv).catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/commands/mcp.js

@@ -9,6 +9,7 @@ import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from
 import { buildExecutionContext, renderExecutionContextSummary } from '../core/execution-context.js';
 import { checkBrainclawInstallableUpdate, renderBrainclawInstallableUpdateNotice } from '../core/brainclaw-version.js';
 import { loadConfig } from '../core/config.js';
+import { loadAllSessions, gcStaleSessions } from '../core/identity.js';
 import { loadState, persistState, saveState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
 import { generateCandidateIdWithLabel, listArchivedCandidates, listCandidates, saveCandidate } from '../core/candidates.js';
@@ -307,6 +308,17 @@ export const MCP_READ_TOOLS = [
             },
         },
     },
+    {
+        name: 'bclaw_who',
+        description: 'List all active agent sessions on this workspace. Shows user, agent, active project, claims, and last activity for each session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                all: { type: 'boolean', description: 'Include stale sessions (default: false).' },
+                gc: { type: 'boolean', description: 'Remove stale sessions and return count.' },
+            },
+        },
+    },
 ];
 const MCP_WRITE_TOOLS = [
     {
@@ -1767,6 +1779,42 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             structuredContent: { agent: currentAgentName, conflicts, total: conflicts.length, schema_version: SCHEMA_VERSION },
         };
     }
+    if (name === 'bclaw_who') {
+        // loadAllSessions and gcStaleSessions imported at top of file
+        const doGc = args.gc === true;
+        const showAll = args.all === true;
+        if (doGc) {
+            const removed = gcStaleSessions(cwd);
+            return {
+                content: [{ type: 'text', text: `✔ Removed ${removed} stale session(s).` }],
+                structuredContent: { gc: true, removed, schema_version: SCHEMA_VERSION },
+            };
+        }
+        const allSessions = loadAllSessions(cwd);
+        const ttlMs = 4 * 60 * 60 * 1000;
+        const now = Date.now();
+        const sessions = showAll
+            ? allSessions
+            : allSessions.filter((s) => (now - Date.parse(s.last_seen_at)) <= ttlMs);
+        const activeClaims = listClaims(cwd).filter((c) => c.status === 'active');
+        const output = sessions.map((s) => ({
+            session_id: s.session_id,
+            user: s.user ?? 'unknown',
+            agent: s.agent,
+            agent_id: s.agent_id,
+            project: s.active_project?.name ?? s.active_project?.path ?? null,
+            claims: activeClaims.filter((c) => c.agent_id === s.agent_id).length,
+            last_seen_at: s.last_seen_at,
+            stale: (now - Date.parse(s.last_seen_at)) > ttlMs,
+        }));
+        const lines = sessions.length === 0
+            ? 'No active sessions.'
+            : output.map((s) => `${s.user} | ${s.agent} | ${s.project ?? '(root)'} | ${s.claims} claims | ${s.stale ? 'stale' : 'active'}`).join('\n');
+        return {
+            content: [{ type: 'text', text: lines }],
+            structuredContent: { sessions: output, total: output.length, schema_version: SCHEMA_VERSION },
+        };
+    }
     if (name === 'bclaw_doctor') {
         // Capture doctor JSON output by redirecting console.log
         const captured = [];
@@ -2188,6 +2236,7 @@ export async function executeMcpToolCall(payload) {
                 id: claimId,
                 agent: identity.agent,
                 agent_id: identity.agent_id,
+                user: process.env.USER || process.env.USERNAME || undefined,
                 project_id: identity.project_id,
                 host_id: identity.host_id,
                 session_id: identity.session_id,

package/dist/commands/switch.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { loadActiveProject, saveActiveProject, clearActiveProject } from '../core/active-project.js';
+import { loadCurrentSession, saveCurrentSession } from '../core/identity.js';
 import { memoryExists } from '../core/io.js';
 import { resolveProjectRef, resolveWorkspaceRoot } from '../core/store-resolution.js';
 import { scanNestedBrainclawProjects } from '../core/workspace-projects.js';
@@ -18,6 +19,11 @@ export function runSwitch(projectRef, options = {}) {
     }
     // --clear: remove active project
     if (options.clear) {
+        const session = loadCurrentSession(cwd);
+        if (session?.active_project) {
+            const { active_project: _removed, ...rest } = session;
+            saveCurrentSession(rest, cwd);
+        }
         clearActiveProject(wsRoot);
         if (options.json) {
             console.log(JSON.stringify({ cleared: true }));
@@ -47,18 +53,35 @@ export function runSwitch(projectRef, options = {}) {
     catch {
         // name is optional
     }
-    saveActiveProject(wsRoot, {
-        path: resolved,
-        name: projectName,
-        switched_at: new Date().toISOString(),
-        switched_by: process.env.BRAINCLAW_AGENT_NAME ?? process.env.USER ?? 'unknown',
-    });
+    const now = new Date().toISOString();
+    const session = loadCurrentSession(cwd);
+    const scopedToSession = options.session ?? !!session;
+    let scope;
+    if (scopedToSession && session) {
+        // Write to session state — only this agent sees this switch
+        saveCurrentSession({
+            ...session,
+            active_project: { path: resolved, name: projectName, switched_at: now },
+        }, cwd);
+        scope = 'session';
+    }
+    else {
+        // Fall back to global active-project.json
+        saveActiveProject(wsRoot, {
+            path: resolved,
+            name: projectName,
+            switched_at: now,
+            switched_by: process.env.BRAINCLAW_AGENT_NAME ?? process.env.USER ?? 'unknown',
+        });
+        scope = 'global';
+    }
     if (options.json) {
-        console.log(JSON.stringify({ switched: true, path: resolved, name: projectName }));
+        console.log(JSON.stringify({ switched: true, path: resolved, name: projectName, scope }));
     }
     else {
         const rel = path.relative(wsRoot, resolved) || '.';
-        console.log(`✔ Switched to ${projectName ? `"${projectName}" (${rel})` : rel}`);
+        const scopeHint = scope === 'session' ? ' (session-scoped)' : '';
+        console.log(`✔ Switched to ${projectName ? `"${projectName}" (${rel})` : rel}${scopeHint}`);
     }
 }
 function showCurrent(wsRoot, json) {

package/dist/commands/who.js

@@ -0,0 +1,96 @@
+import { loadAllSessions, gcStaleSessions } from '../core/identity.js';
+import { listClaims } from '../core/claims.js';
+export function runWho(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (options.gc) {
+        const removed = gcStaleSessions(cwd);
+        if (options.json) {
+            console.log(JSON.stringify({ gc: true, removed }));
+        }
+        else {
+            console.log(`✔ Removed ${removed} stale session(s).`);
+        }
+        return;
+    }
+    const allSessions = loadAllSessions(cwd);
+    const ttlMs = 4 * 60 * 60 * 1000; // 4h default
+    const now = Date.now();
+    const sessions = options.all
+        ? allSessions
+        : allSessions.filter(s => (now - Date.parse(s.last_seen_at)) <= ttlMs);
+    const activeClaims = listClaims(cwd).filter(c => c.status === 'active');
+    const enriched = sessions.map(s => {
+        const age = now - Date.parse(s.last_seen_at);
+        const stale = age > ttlMs;
+        const dead = s.pid ? !isPidAlive(s.pid) : false;
+        const status = dead ? 'dead' : stale ? 'stale' : 'active';
+        return {
+            session_id: s.session_id,
+            user: s.user ?? 'unknown',
+            agent: s.agent,
+            agent_id: s.agent_id,
+            host_id: s.host_id,
+            project: s.active_project?.name ?? s.active_project?.path ?? null,
+            claims: activeClaims.filter(c => c.agent_id === s.agent_id).length,
+            started_at: s.started_at,
+            last_seen_at: s.last_seen_at,
+            status,
+            pid: s.pid,
+        };
+    });
+    if (options.json) {
+        console.log(JSON.stringify({ sessions: enriched, total: enriched.length }, null, 2));
+        return;
+    }
+    if (enriched.length === 0) {
+        console.log('No active sessions.');
+        return;
+    }
+    // Table header
+    const header = ['USER', 'AGENT', 'PROJECT', 'CLAIMS', 'STATUS', 'LAST SEEN'];
+    const rows = [];
+    for (const s of enriched) {
+        const age = now - Date.parse(s.last_seen_at);
+        const project = s.project ?? '(workspace root)';
+        rows.push([
+            s.user,
+            s.agent,
+            project.length > 25 ? project.slice(0, 22) + '...' : project,
+            String(s.claims),
+            s.status,
+            formatAge(age),
+        ]);
+    }
+    // Calculate column widths
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
+    console.log('Active sessions:\n');
+    console.log('  ' + header.map((h, i) => h.padEnd(widths[i])).join('  '));
+    console.log('  ' + widths.map(w => '─'.repeat(w)).join('  '));
+    for (const row of rows) {
+        console.log('  ' + row.map((cell, i) => cell.padEnd(widths[i])).join('  '));
+    }
+    console.log(`\n${enriched.length} session(s).`);
+}
+function isPidAlive(pid) {
+    try {
+        // process.kill(pid, 0) throws if process doesn't exist
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function formatAge(ms) {
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+//# sourceMappingURL=who.js.map

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-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/bootstrap.js

@@ -8,7 +8,7 @@ import { resolveEntityDir } from './io.js';
 import { mutate } from './mutation-pipeline.js';
 import { BootstrapApplicationReceiptSchema, BootstrapInterviewAnswerSchema, BootstrapInterviewPlanSchema, BootstrapInterviewQuestionSchema, BootstrapImportPlanDocumentSchema, BootstrapProfileDocumentSchema, BootstrapSuggestionDocumentSchema, MemorySeedDocumentSchema, } from './schema.js';
 import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
-import { analyzeRepository } from './repo-analysis.js';
+import { analyzeRepository, findNestedAgentsFiles } from './repo-analysis.js';
 import { buildExecutionContext, compactExecutionContext } from './execution-context.js';
 import { buildAgentToolingContext } from './agent-context.js';
 import { createInstruction, loadInstructions, saveInstruction } from './instructions.js';
@@ -101,6 +101,7 @@ export function runBootstrapProfile(options = {}) {
         importPlan,
         lastApplication,
         reusedProfile: false,
+        subProjects: artifacts.subProjects,
     };
 }
 export function listBootstrapSeeds(cwd) {
@@ -183,6 +184,18 @@ export function renderBootstrapSummary(result) {
     if (result.lastApplication && !result.lastApplication.uninstalled_at) {
         lines.push(`Last bootstrap import: ${result.lastApplication.managed_artifacts.length} managed artifact(s) from ${result.lastApplication.applied_at}`);
     }
+    if (result.subProjects && result.subProjects.length > 0) {
+        lines.push('');
+        lines.push(`Sub-projects discovered (${result.subProjects.length}):`);
+        for (const sp of result.subProjects.slice(0, 20)) {
+            lines.push(`  ${sp}`);
+        }
+        if (result.subProjects.length > 20) {
+            lines.push(`  ... and ${result.subProjects.length - 20} more`);
+        }
+        lines.push('');
+        lines.push('Use: brainclaw bootstrap --for <sub-project-path> --refresh');
+    }
     if (result.importPlan.suggestions.length > 0) {
         lines.push('');
         lines.push('Import proposal:');
@@ -231,14 +244,19 @@ export function renderBootstrapInterview(result, audience = 'any') {
 function buildBootstrapArtifacts(input) {
     const sourcesScanned = [];
     const seeds = [];
-    const workspace = classifyWorkspace(input.cwd);
-    const nativeInstructionFiles = discoverNativeInstructionFiles(input.cwd);
-    const readmePath = findFirstExisting(input.cwd, README_CANDIDATES);
+    // When target is an absolute directory path, use it as the scan root
+    // so that instruction files, README, and AGENTS.md are discovered from
+    // the target scope — not from the workspace root. This fixes bootstrap
+    // returning wrong signals for monorepo sub-projects.
+    const scanRoot = resolveBootstrapScanRoot(input.cwd, input.target);
+    const workspace = classifyWorkspace(scanRoot);
+    const nativeInstructionFiles = discoverNativeInstructionFiles(scanRoot);
+    const readmePath = findFirstExisting(scanRoot, README_CANDIDATES);
     if (readmePath) {
         sourcesScanned.push('README');
         seeds.push(...extractReadmeSeeds(readmePath, input.target));
     }
-    const agentsPath = path.join(input.cwd, 'AGENTS.md');
+    const agentsPath = path.join(scanRoot, 'AGENTS.md');
     const agentsPresent = fs.existsSync(agentsPath);
     if (agentsPresent) {
         sourcesScanned.push('AGENTS.md');
@@ -246,9 +264,9 @@ function buildBootstrapArtifacts(input) {
     }
     if (nativeInstructionFiles.length > 0) {
         sourcesScanned.push('native_instructions');
-        seeds.push(...extractNativeInstructionSeeds(nativeInstructionFiles.map((relativePath) => path.join(input.cwd, relativePath)), input.cwd, input.target));
+        seeds.push(...extractNativeInstructionSeeds(nativeInstructionFiles.map((relativePath) => path.join(scanRoot, relativePath)), scanRoot, input.target));
     }
-    const manifestResult = extractManifestSeeds(input.cwd, input.target);
+    const manifestResult = extractManifestSeeds(scanRoot, input.target);
     if (manifestResult.seeds.length > 0) {
         sourcesScanned.push(...manifestResult.sources);
         seeds.push(...manifestResult.seeds);
@@ -265,16 +283,16 @@ function buildBootstrapArtifacts(input) {
         sourcesScanned.push('local_mcp');
         seeds.push(...extractMcpSeeds(agentTooling.mcp_servers, input.target));
     }
-    const repoAnalysis = analyzeRepository(input.cwd);
+    const repoAnalysis = analyzeRepository(scanRoot);
     sourcesScanned.push('repo-analysis');
     seeds.push(...extractRepoAnalysisSeeds(repoAnalysis, input.target));
     // Additional brownfield sources (step 12)
-    const additionalSeeds = extractAdditionalBrownfieldSeeds(input.cwd, input.target);
+    const additionalSeeds = extractAdditionalBrownfieldSeeds(scanRoot, input.target);
     if (additionalSeeds.seeds.length > 0) {
         sourcesScanned.push(...additionalSeeds.sources);
         seeds.push(...additionalSeeds.seeds);
     }
-    const gitProbe = probeGit(input.cwd, input.target);
+    const gitProbe = probeGit(scanRoot, input.target);
     if (gitProbe.available) {
         sourcesScanned.push('git');
         seeds.push(...gitProbe.hotspotSeeds);
@@ -342,6 +360,13 @@ function buildBootstrapArtifacts(input) {
             schema_version: DERIVED_SCHEMA_VERSION,
         })),
         importPlan,
+        // For multi-project workspaces without a target, list discovered sub-projects
+        subProjects: (!input.target && repoAnalysis.recommendedMode === 'multi-project')
+            ? findNestedAgentsFiles(scanRoot, 8)
+                .filter((p) => p !== 'AGENTS.md') // exclude root AGENTS.md
+                .map((p) => path.dirname(p))
+                .filter((d) => d !== '.')
+            : undefined,
     };
 }
 function extractReadmeSeeds(filepath, target) {
@@ -846,6 +871,9 @@ function buildSummary(input) {
     parts.push(`Onboarding mode: ${input.onboardingMode}.`);
     parts.push(`Confidence: ${input.confidence}.`);
     parts.push(`Repository mode looks ${input.repoAnalysis.recommendedMode}.`);
+    if (input.repoAnalysis.recommendedMode === 'multi-project' && !input.target) {
+        parts.push('This is a multi-project workspace — use --for <path> to bootstrap a specific sub-project.');
+    }
     if (input.agentsPresent) {
         parts.push('AGENTS.md detected and summarized.');
     }
@@ -1639,6 +1667,29 @@ function normalizeTarget(target) {
     const trimmed = target?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : undefined;
 }
+/**
+ * Resolve where to scan for project files (README, AGENTS.md, manifests).
+ * If target is an absolute directory path, scan from there.
+ * Otherwise fall back to cwd (the workspace/store root).
+ */
+function resolveBootstrapScanRoot(cwd, target) {
+    if (!target)
+        return cwd;
+    const resolved = path.isAbsolute(target) ? target : path.resolve(cwd, target);
+    try {
+        if (fs.statSync(resolved).isDirectory())
+            return resolved;
+    }
+    catch { /* not a directory or doesn't exist */ }
+    // Target is a file path or glob — use its parent directory if it exists
+    const parent = path.dirname(resolved);
+    try {
+        if (fs.statSync(parent).isDirectory())
+            return parent;
+    }
+    catch { /* fall back to cwd */ }
+    return cwd;
+}
 // ─── Step 12: Additional brownfield sources ──────────────────────────────────
 const CI_WORKFLOW_DIRS = ['.github/workflows', '.gitlab'];
 const CI_FILES = ['.gitlab-ci.yml', 'Jenkinsfile', '.circleci/config.yml'];