brainclaw 0.19.12 → 0.20.0

package/dist/commands/reconcile.js

@@ -0,0 +1,138 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import path from 'node:path';
+import { buildMachineProfile, saveMachineProfile } from '../core/machine-profile.js';
+import { buildAgentInventory, saveAgentInventory } from '../core/agent-inventory.js';
+import { applyBootstrapImport, runBootstrapProfile } from '../core/bootstrap.js';
+import { loadConfig } from '../core/config.js';
+import { memoryExists } from '../core/io.js';
+import { summarizeWorkspaceProjects } from '../core/workspace-projects.js';
+export async function runReconcile(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found in the current directory. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const rootConfig = loadConfig(cwd);
+    const workspaceSummary = summarizeWorkspaceProjects(cwd, rootConfig);
+    const storeTargets = [
+        cwd,
+        ...workspaceSummary.uses_folder_resolution
+            ? workspaceSummary.discovered_projects
+                .filter((project) => project.source !== 'config')
+                .map((project) => project.path)
+            : [],
+    ];
+    const uniqueTargets = [...new Set(storeTargets.map((store) => path.resolve(store)))];
+    if (options.json && options.dryRun) {
+        console.log(JSON.stringify({
+            cwd,
+            mode: 'dry_run',
+            workspace_summary: workspaceSummary,
+            planned_actions: {
+                machine_profile_refresh: !options.skipMachineProfile,
+                agent_inventory_refresh: !options.skipAgentInventory,
+                bootstrap_refresh: uniqueTargets.map((store) => ({
+                    cwd: store,
+                    relative_path: path.relative(cwd, store) || '.',
+                    apply_bootstrap: Boolean(options.applyBootstrap),
+                })),
+            },
+        }, null, 2));
+        return;
+    }
+    if (options.applyBootstrap) {
+        await confirmBootstrapApply(options.yes);
+    }
+    const machineProfilePath = !options.skipMachineProfile
+        ? saveMachineProfile(buildMachineProfile())
+        : null;
+    const agentInventoryPath = !options.skipAgentInventory
+        ? saveAgentInventory(buildAgentInventory())
+        : null;
+    const stores = [];
+    for (const store of uniqueTargets) {
+        const config = loadConfig(store);
+        if (options.applyBootstrap) {
+            const result = applyBootstrapImport({ cwd: store, refresh: true });
+            stores.push({
+                cwd: store,
+                relative_path: path.relative(cwd, store) || '.',
+                project_name: config.project_name,
+                project_mode: config.project_mode,
+                project_strategy: config.projects.strategy,
+                bootstrap_refreshed: true,
+                bootstrap_applied: true,
+                workspace_kind: result.proposal.workspace_kind,
+                onboarding_mode: result.proposal.onboarding_mode,
+                confidence: result.proposal.confidence,
+                suggestion_count: result.proposal.suggestion_count,
+                created_count: result.createdCount,
+                skipped_count: result.skippedCount,
+            });
+            continue;
+        }
+        const result = runBootstrapProfile({ cwd: store, refresh: true });
+        stores.push({
+            cwd: store,
+            relative_path: path.relative(cwd, store) || '.',
+            project_name: config.project_name,
+            project_mode: config.project_mode,
+            project_strategy: config.projects.strategy,
+            bootstrap_refreshed: true,
+            bootstrap_applied: false,
+            workspace_kind: result.profile.workspace_kind,
+            onboarding_mode: result.profile.onboarding_mode,
+            confidence: result.profile.confidence,
+            suggestion_count: result.importPlan.suggestion_count,
+        });
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            cwd,
+            mode: options.applyBootstrap ? 'apply' : 'refresh',
+            workspace_summary: workspaceSummary,
+            machine_profile_refreshed: !options.skipMachineProfile,
+            machine_profile_path: machineProfilePath,
+            agent_inventory_refreshed: !options.skipAgentInventory,
+            agent_inventory_path: agentInventoryPath,
+            stores,
+        }, null, 2));
+        return;
+    }
+    if (!options.skipMachineProfile) {
+        console.log(`✔ Machine profile refreshed: ${machineProfilePath}`);
+    }
+    if (!options.skipAgentInventory) {
+        console.log(`✔ Agent inventory refreshed: ${agentInventoryPath}`);
+    }
+    console.log('');
+    console.log(`Reconciled ${stores.length} store(s):`);
+    for (const store of stores) {
+        const suffix = store.bootstrap_applied
+            ? `${store.created_count ?? 0} created, ${store.skipped_count ?? 0} skipped`
+            : `${store.suggestion_count ?? 0} bootstrap suggestion(s) available`;
+        console.log(`  - ${store.relative_path} (${store.project_name}) — ${store.onboarding_mode ?? 'unknown'}, confidence=${store.confidence ?? 'unknown'}, ${suffix}`);
+    }
+}
+async function confirmBootstrapApply(yes) {
+    if (yes) {
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error('Error: bootstrap apply across multiple stores requires --yes in non-interactive mode.');
+        process.exit(1);
+    }
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question('Apply bootstrap suggestions across all selected stores? [y/N] ');
+        if (answer.trim().toLowerCase() !== 'y') {
+            console.error('Cancelled.');
+            process.exit(1);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/commands/setup.js

@@ -4,6 +4,7 @@ import readline from 'node:readline/promises';
 import { spawnSync } from 'node:child_process';
 import { runInit } from './init.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
+import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-surface-inventory.js';
 import { buildMachineProfile, saveMachineProfile, loadMachineProfile } from '../core/machine-profile.js';
 import { buildAgentInventory, saveAgentInventory, loadAgentInventory } from '../core/agent-inventory.js';
 import { ensureClaudeCodeUserSettings, ensureClaudeCodeUserCommand, ensureCursorMcpConfig, ensureWindsurfMcpConfig, ensureAntigravityMcpConfig, ensureContinueUserMcpConfig, ensureCodexMcpConfig, writeDetectedAgentAutoConfig, describeAutoConfigWrite, ensureGitignoreEntries, collectWorkspaceGitignoreEntries, } from '../core/agent-files.js';
@@ -388,6 +389,7 @@ export async function runSetup(options = {}) {
     // Step 4: Agent detection & selection
     const detectedAi = detectAiAgent(env);
     const detectedName = detectedAi?.name;
+    const detectedSurfaces = buildAiSurfaceInventory();
     console.log('');
     if (detectedName) {
         console.log(`Detected AI agent: ${detectedName}`);
@@ -395,6 +397,23 @@ export async function runSetup(options = {}) {
     else {
         console.log('No AI agent detected automatically.');
     }
+    const visibleSurfaces = detectedSurfaces.filter((surface) => surface.status !== 'not_detected');
+    if (visibleSurfaces.length > 0) {
+        console.log('Other AI work surfaces on this machine:');
+        for (const surface of visibleSurfaces) {
+            console.log(`  - ${surface.display_name} [${surface.surface_kind}, ${surface.status}]`);
+        }
+        const usageHints = renderAiSurfaceUsageHints(visibleSurfaces);
+        if (usageHints.length > 0) {
+            console.log('');
+            console.log('Suggested uses:');
+            for (const line of usageHints) {
+                console.log(`  ${line}`);
+            }
+        }
+        console.log('');
+        console.log('These surfaces are tracked separately from coding agents and will use tailored onboarding flows.');
+    }
     console.log('Supported agents:');
     ALL_KNOWN_AGENTS.forEach((a, i) => {
         const tag = a === detectedName ? ' ← detected' : '';

package/dist/commands/status.js

@@ -9,7 +9,8 @@ import { loadState } from '../core/state.js';
 import { isTrapActive, listOperationalTraps } from '../core/traps.js';
 import { generateMarkdown } from '../core/markdown.js';
 import { memoryExists } from '../core/io.js';
-function printHumanStatus(state, config) {
+import { summarizeWorkspaceProjects } from '../core/workspace-projects.js';
+function printHumanStatus(state, config, cwd) {
     const activePlans = state.plan_items.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
     const activeInstructions = loadInstructions().filter((entry) => entry.active);
     const activeClaims = listClaims().filter((claim) => claim.status === 'active');
@@ -21,6 +22,7 @@ function printHumanStatus(state, config) {
     const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
     const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
     const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
+    const workspaceProjects = summarizeWorkspaceProjects(cwd, config);
     const counts = {
         instructions: activeInstructions.length,
         claims: activeClaims.length,
@@ -50,7 +52,7 @@ function printHumanStatus(state, config) {
     console.log(`  Traps       : ${activeSharedTraps.length} active shared, ${resolvedSharedTraps.length} resolved shared, ${activeMachineTraps.length} active machine-local (${currentHost})`);
     console.log(`  Handoffs    : ${counts.handoffs}`);
     if (config.project_mode === 'multi-project') {
-        console.log(`  Projects    : ${config.projects.known.length}`);
+        console.log(`  Projects    : ${workspaceProjects.effective_project_count} effective (${workspaceProjects.strategy})`);
     }
     // Show recent items (last 3 per section)
     const sections = [
@@ -84,24 +86,27 @@ function printHumanStatus(state, config) {
     }
 }
 export function runStatus(options = {}) {
-    if (!memoryExists()) {
+    const cwd = process.cwd();
+    if (!memoryExists(cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
-    const config = loadConfig();
-    const state = loadState();
+    const config = loadConfig(cwd);
+    const state = loadState(cwd);
     const currentHost = resolveCurrentHostId();
-    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' });
-    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' });
-    const machineTraps = listOperationalTraps({ visibility: 'machine' });
+    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' }, cwd);
+    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' }, cwd);
+    const machineTraps = listOperationalTraps({ visibility: 'machine' }, cwd);
     const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
     const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
     const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
-    const registeredAgents = listAgentIdentities();
-    const reputation = buildReputationSnapshot();
+    const registeredAgents = listAgentIdentities(cwd);
+    const reputation = buildReputationSnapshot(cwd);
+    const workspaceProjects = summarizeWorkspaceProjects(cwd, config);
     if (options.json) {
         console.log(JSON.stringify({
             config,
+            workspace_projects: workspaceProjects,
             agents: {
                 current_name: config.current_agent,
                 current_id: config.current_agent_id,
@@ -125,9 +130,9 @@ export function runStatus(options = {}) {
         return;
     }
     if (options.markdown) {
-        console.log(generateMarkdown(state));
+        console.log(generateMarkdown(state, cwd));
         return;
     }
-    printHumanStatus(state, config);
+    printHumanStatus(state, config, cwd);
 }
 //# sourceMappingURL=status.js.map

package/dist/commands/surface-task-resource.js

@@ -0,0 +1,35 @@
+import { runSurfaceTask } from './surface-task.js';
+import { runListSurfaceTasks } from './list-surface-tasks.js';
+import { runUpdateSurfaceTask } from './update-surface-task.js';
+export function runSurfaceTaskResource(subcommand, args, options = {}) {
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'create') {
+        const title = args.join(' ').trim();
+        if (!title) {
+            console.error('Error: surface-task create requires <title>.');
+            process.exit(1);
+        }
+        runSurfaceTask(title, options);
+        return;
+    }
+    if (normalized === 'list' || normalized === 'ls') {
+        runListSurfaceTasks(options);
+        return;
+    }
+    if (normalized === 'update') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: surface-task update requires <id>.');
+            process.exit(1);
+        }
+        runUpdateSurfaceTask(id, options);
+        return;
+    }
+    const legacyTitle = [subcommand, ...args].join(' ').trim();
+    if (!legacyTitle) {
+        console.error('Error: missing surface-task subcommand or title.');
+        process.exit(1);
+    }
+    runSurfaceTask(legacyTitle, options);
+}
+//# sourceMappingURL=surface-task-resource.js.map

package/dist/commands/surface-task.js

@@ -0,0 +1,57 @@
+import { buildOperationalIdentity } from '../core/identity.js';
+import { memoryExists } from '../core/io.js';
+import { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { saveAiSurfaceTask } from '../core/ai-surface-tasks.js';
+export function runSurfaceTask(title, options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (!options.target) {
+        console.error('Error: surface-task create requires --target <surface>.');
+        process.exit(1);
+    }
+    if (!options.instructions?.trim()) {
+        console.error('Error: surface-task create requires --instructions <text>.');
+        process.exit(1);
+    }
+    const registeredAgent = requireRegisteredAgentIdentity({
+        agentName: options.agent,
+        agentId: options.agentId,
+        cwd: options.cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(registeredAgent, 'contributor');
+    const actor = buildOperationalIdentity(registeredAgent.agent_name, options.cwd, {
+        agentId: registeredAgent.agent_id,
+    });
+    const ids = generateIdWithLabel('ai_surface_tasks', options.cwd);
+    const timestamp = nowISO();
+    const task = {
+        id: ids.id,
+        short_label: ids.short_label,
+        title: title.trim(),
+        instructions: options.instructions.trim(),
+        target_surface: options.target.trim(),
+        kind: options.kind ?? 'custom',
+        created_at: timestamp,
+        updated_at: timestamp,
+        author: actor.agent,
+        author_id: actor.agent_id,
+        project_id: actor.project_id,
+        session_id: actor.session_id,
+        status: 'queued',
+        requested_outputs: options.output ?? [],
+        related_paths: options.path,
+        tags: options.tag ?? [],
+    };
+    saveAiSurfaceTask(task, options.cwd);
+    console.log(`✔ Surface task queued: [${task.id}] ${task.title}`);
+    console.log(`  Target: ${task.target_surface} (${task.kind})`);
+    if (task.requested_outputs.length > 0) {
+        console.log(`  Outputs: ${task.requested_outputs.join(', ')}`);
+    }
+}
+//# sourceMappingURL=surface-task.js.map

package/dist/commands/uninstall.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { MEMORY_DIR, memoryExists } from '../core/io.js';
+import { BRAINCLAW_SECTION_START, BRAINCLAW_SECTION_END, AGENT_EXPORT_REGISTRY, } from '../core/agent-files.js';
+import { resolveHomeDir } from '../core/setup-state.js';
+/**
+ * Remove brainclaw from a project and/or machine.
+ *
+ * --project: removes .brainclaw/, agent instruction files, MCP configs,
+ *            and brainclaw sections from shared instruction files.
+ * --machine: removes ~/.brainclaw/ and global agent configs.
+ */
+export async function runUninstall(options) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!options.project && !options.machine) {
+        console.error('Error: specify --project, --machine, or both.');
+        process.exit(1);
+    }
+    if (options.project) {
+        await uninstallProject(cwd, options.yes);
+    }
+    if (options.machine) {
+        await uninstallMachine(options.yes);
+    }
+}
+async function uninstallProject(cwd, skipConfirm) {
+    if (!memoryExists(cwd)) {
+        console.log('No .brainclaw/ found in this project. Nothing to uninstall.');
+        return;
+    }
+    if (!skipConfirm && process.stdin.isTTY) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question('Remove brainclaw from this project? This deletes .brainclaw/ and all generated agent files. [y/N]: ')).trim().toLowerCase();
+            if (answer !== 'y' && answer !== 'yes') {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    // Remove .brainclaw/ directory
+    const brainclawDir = path.join(cwd, MEMORY_DIR);
+    if (fs.existsSync(brainclawDir)) {
+        fs.rmSync(brainclawDir, { recursive: true, force: true });
+        console.log(`✔ Removed ${MEMORY_DIR}/`);
+    }
+    // Remove dedicated agent files (non-shared, brainclaw-owned)
+    const dedicatedFiles = AGENT_EXPORT_REGISTRY
+        .map((entry) => entry.relativePath)
+        .filter((p) => p.includes('/'));
+    for (const relativePath of dedicatedFiles) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath)) {
+            fs.unlinkSync(fullPath);
+            console.log(`✔ Removed ${relativePath}`);
+        }
+    }
+    // Remove brainclaw sections from shared files
+    const sharedFiles = [
+        'CLAUDE.md',
+        '.windsurfrules',
+        'AGENTS.md',
+        'GEMINI.md',
+        '.github/copilot-instructions.md',
+    ];
+    for (const relativePath of sharedFiles) {
+        const fullPath = path.join(cwd, relativePath);
+        if (!fs.existsSync(fullPath))
+            continue;
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const startIdx = content.indexOf(BRAINCLAW_SECTION_START);
+        const endIdx = content.indexOf(BRAINCLAW_SECTION_END);
+        if (startIdx !== -1 && endIdx !== -1) {
+            const before = content.slice(0, startIdx).trimEnd();
+            const after = content.slice(endIdx + BRAINCLAW_SECTION_END.length).trimStart();
+            const cleaned = [before, after].filter(Boolean).join('\n\n');
+            if (cleaned.trim().length === 0) {
+                fs.unlinkSync(fullPath);
+                console.log(`✔ Removed ${relativePath} (was brainclaw-only)`);
+            }
+            else {
+                fs.writeFileSync(fullPath, cleaned + '\n', 'utf-8');
+                console.log(`✔ Removed brainclaw section from ${relativePath}`);
+            }
+        }
+    }
+    // Remove companion config files
+    const companionFiles = [
+        '.mcp.json',
+        '.claude/commands/brainclaw.md',
+        '.claude/settings.local.json',
+        '.claude/.bclaw-session',
+        '.cursor/rules/brainclaw-mcp-shim.mdc',
+        '.vscode/cline_mcp_settings.json',
+        '.roo/mcp.json',
+        '.continue/config.json',
+        'opencode.json',
+        '.github/skills/brainclaw-context/SKILL.md',
+    ];
+    for (const relativePath of companionFiles) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath)) {
+            fs.unlinkSync(fullPath);
+            console.log(`✔ Removed ${relativePath}`);
+        }
+    }
+    console.log('✔ Project uninstall complete.');
+}
+async function uninstallMachine(skipConfirm) {
+    const home = resolveHomeDir();
+    if (!home) {
+        console.log('Cannot determine home directory. Nothing to uninstall.');
+        return;
+    }
+    const userStore = path.join(home, '.brainclaw');
+    if (!fs.existsSync(userStore)) {
+        console.log('No ~/.brainclaw/ found. Nothing to uninstall.');
+        return;
+    }
+    if (!skipConfirm && process.stdin.isTTY) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question('Remove brainclaw global config (~/.brainclaw/)? [y/N]: ')).trim().toLowerCase();
+            if (answer !== 'y' && answer !== 'yes') {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    fs.rmSync(userStore, { recursive: true, force: true });
+    console.log('✔ Removed ~/.brainclaw/');
+    // Note: global MCP configs in ~/.claude/settings.json, ~/.cursor/mcp.json etc.
+    // are NOT removed automatically — they may contain non-brainclaw entries.
+    console.log('Note: global agent MCP configs (e.g. ~/.claude/settings.json) were not modified.');
+    console.log('Remove brainclaw entries manually if needed.');
+    console.log('✔ Machine uninstall complete.');
+}
+//# sourceMappingURL=uninstall.js.map

package/dist/commands/update-surface-task.js

@@ -0,0 +1,30 @@
+import { memoryExists } from '../core/io.js';
+import { loadAiSurfaceTask, saveAiSurfaceTask } from '../core/ai-surface-tasks.js';
+import { nowISO } from '../core/ids.js';
+export function runUpdateSurfaceTask(id, options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const task = loadAiSurfaceTask(id, options.cwd);
+    const timestamp = nowISO();
+    if (options.status) {
+        task.status = options.status;
+        if (options.status === 'in_progress' && !task.claimed_at) {
+            task.claimed_at = timestamp;
+        }
+        if ((options.status === 'completed' || options.status === 'failed' || options.status === 'cancelled') && !task.completed_at) {
+            task.completed_at = timestamp;
+        }
+    }
+    if (options.result !== undefined) {
+        task.result_note = options.result;
+    }
+    if (options.output && options.output.length > 0) {
+        task.requested_outputs = options.output;
+    }
+    task.updated_at = timestamp;
+    saveAiSurfaceTask(task, options.cwd);
+    console.log(`✔ Surface task updated: [${task.id}] ${task.title}`);
+}
+//# sourceMappingURL=update-surface-task.js.map