brainclaw 0.19.14 → 0.20.0

package/README.md

@@ -66,18 +66,20 @@ 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.
 
-| Logo | Agent | Brainclaw fit | Best use today |
+| 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)** | Best fit | full agent workflow with MCP, instructions, commands, and session hooks |
-| [![Codex](https://img.shields.io/badge/Codex-111111?logo=openai&logoColor=white)](https://openai.com/codex/) | **[Codex](https://openai.com/codex/)** | Strong fit | agent-first repo coordination with explicit plans, claims, and handoffs |
-| [![Cursor](https://img.shields.io/badge/Cursor-1F2430?logo=cursor&logoColor=white)](https://cursor.com/en-US) | **[Cursor](https://cursor.com/en-US)** | Strong fit | repo-native agent workflows with rules plus MCP |
-| [![OpenCode](https://img.shields.io/badge/OpenCode-0F172A?logoColor=white)](https://github.com/opencode-ai/opencode) | **[OpenCode](https://github.com/opencode-ai/opencode)** | Strong fit | simple agent bootstrap with `AGENTS.md` plus workspace MCP |
-| [![Windsurf](https://img.shields.io/badge/Windsurf-0B1220?logo=codeium&logoColor=white)](https://windsurf.com/) | **[Windsurf](https://windsurf.com/)** | Good fit | guided agent workflows with instructions, hooks, and MCP |
-| [![Roo](https://img.shields.io/badge/Roo-7C3AED?logoColor=white)](https://github.com/RooCodeInc/Roo-Code) | **[Roo](https://github.com/RooCodeInc/Roo-Code)** | Good fit | workspace agent coordination with rules plus MCP |
-| [![Continue](https://img.shields.io/badge/Continue-2563EB?logoColor=white)](https://github.com/continuedev/continue) | **[Continue](https://github.com/continuedev/continue)** | Good fit | editor-based agent workflows with MCP context access |
-| [![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)** | Promising fit | local agent workflows with `GEMINI.md` plus MCP |
-| [![Cline](https://img.shields.io/badge/Cline-0F766E?logoColor=white)](https://github.com/cline/cline) | **[Cline](https://github.com/cline/cline)** | Functional fit | lightweight agent use through rules plus MCP |
-| [![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)** | Supported fit | project awareness and shared local instructions with lighter workflow control |
+| [![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 |
+| [![Codex](https://img.shields.io/badge/Codex-111111?logo=openai&logoColor=white)](https://openai.com/codex/) | **[Codex](https://openai.com/codex/)** | Standard | MCP + AGENTS.md |
+| [![Cursor](https://img.shields.io/badge/Cursor-1F2430?logo=cursor&logoColor=white)](https://cursor.com/en-US) | **[Cursor](https://cursor.com/en-US)** | Standard | MCP + .cursor/rules/ + alwaysApply MDC |
+| [![OpenCode](https://img.shields.io/badge/OpenCode-0F172A?logoColor=white)](https://github.com/opencode-ai/opencode) | **[OpenCode](https://github.com/opencode-ai/opencode)** | Standard | MCP + AGENTS.md |
+| [![Windsurf](https://img.shields.io/badge/Windsurf-0B1220?logo=codeium&logoColor=white)](https://windsurf.com/) | **[Windsurf](https://windsurf.com/)** | Standard | MCP + .windsurfrules session trigger |
+| [![Roo](https://img.shields.io/badge/Roo-7C3AED?logoColor=white)](https://github.com/RooCodeInc/Roo-Code) | **[Roo](https://github.com/RooCodeInc/Roo-Code)** | Standard | MCP (auto-approve) + .roo/rules/ |
+| [![Cline](https://img.shields.io/badge/Cline-0F766E?logoColor=white)](https://github.com/cline/cline) | **[Cline](https://github.com/cline/cline)** | Standard | MCP (auto-approve) + .clinerules/ |
+| [![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 |
+
+**Full** = MCP + hooks + auto-approve (context injected every prompt). **Standard** = MCP + instruction file (agent must call tools explicitly). **Limited** = no MCP (static instruction file is the only source of context).
 
 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.
 
@@ -303,6 +305,19 @@ npm run test:coverage      # with coverage report
 
 ## Changelog
 
+### v0.20.0
+
+- **Onboarding rework** : nouveau parcours d'installation en 2-3 étapes au lieu de 4, avec choix explicites (type de projet, topologie mémoire) au lieu de termes techniques
+- **Agent capability profiles** : chaque agent (10 supportés) a un profil de capacité (MCP, hooks, auto-approve, skills, rules) qui détermine le contenu de ses fichiers d'instructions
+- **Templates adaptatifs** : les fichiers d'instructions (CLAUDE.md, AGENTS.md, etc.) sont générés selon 3 tiers — Full (léger, hooks font le reste), Standard (directif, top traps inclus), Limited (riche, tout en statique)
+- **Séparation core/run** : les fichiers statiques ne contiennent plus que le protocole, les contraintes et instructions. Les traps, plans, decisions et claims sont exclusivement dans le contexte dynamique MCP
+- **Bootstrap enrichi** : scan des workflows CI/CD, ADR, CONTRIBUTING, Docker, .env.example, branches actives et tags git
+- **Quick setup MCP** : `bclaw_setup` détecte le repo courant et propose un init rapide au lieu de forcer le scan multi-repo
+- **`brainclaw uninstall`** : nouvelle commande pour retirer brainclaw d'un projet (`--project`) ou d'une machine (`--machine`)
+- **Traps machine-scoped** : nouveau champ `platform_scope` sur les traps — les traps machine ne polluent plus les fichiers d'instructions statiques
+- **Init sans setup préalable** : `brainclaw init` crée automatiquement le user store si absent, plus besoin de `brainclaw setup` d'abord
+- **Docs réécrites** : intégrations, quickstart et README avec niveaux Full/Standard/Limited et matrice agent factuelle
+
 ### v0.9.10
 
 - **OpenCode** : détection et auto-config MCP workspace via `opencode.json`; l'export réutilise `AGENTS.md`

package/dist/cli.js

@@ -463,6 +463,17 @@ program
     .action((options) => {
     runVersion(options);
 });
+// --- uninstall ---
+import { runUninstall } from './commands/uninstall.js';
+program
+    .command('uninstall')
+    .description('Remove brainclaw from a project and/or machine')
+    .option('--project', 'Remove brainclaw from the current project (.brainclaw/, agent files, configs)')
+    .option('--machine', 'Remove brainclaw global config (~/.brainclaw/)')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(async (options) => {
+    await runUninstall(options);
+});
 // --- rebuild ---
 program
     .command('rebuild')

package/dist/commands/context.js

@@ -3,6 +3,7 @@ import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from
 import { writeContextMarker } from '../core/freshness.js';
 import { nowISO } from '../core/ids.js';
 import { logger } from '../core/logger.js';
+import { resolveContextStoreCwd } from '../core/store-resolution.js';
 export function runContext(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     if (!memoryExists(cwd)) {
@@ -17,6 +18,7 @@ export function runContext(options = {}) {
         }
         return;
     }
+    const contextCwd = resolveContextStoreCwd(cwd, options.for);
     const result = buildContext({
         target: options.for,
         project: options.project,
@@ -43,7 +45,7 @@ export function runContext(options = {}) {
     else {
         console.log(renderContextMarkdown(result, options.explain));
     }
-    writeLastContextMarker(result, options, cwd);
+    writeLastContextMarker(result, options, contextCwd);
 }
 function writeLastContextMarker(result, options, cwd) {
     try {

package/dist/commands/export.js

@@ -8,6 +8,9 @@ import { resolveInstructions, loadInstructions } from '../core/instructions.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
 import { resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
 import { logger } from '../core/logger.js';
+import { getAgentCapabilityProfile } from '../core/agent-capability.js';
+import { renderBrainclawSection } from '../core/instruction-templates.js';
+import { getInstalledBrainclawVersion } from '../core/brainclaw-version.js';
 export function runExport(options) {
     const cwd = options.cwd ?? process.cwd();
     if (!memoryExists(cwd)) {
@@ -125,7 +128,28 @@ function declareAgentIntegrationFromTarget(cwd, agentName, declarationSource) {
         saveConfig(config, cwd);
     }
 }
+function formatToAgentName(format) {
+    const map = {
+        'claude-md': 'claude-code',
+        'cursor-rules': 'cursor',
+        'copilot-instructions': 'github-copilot',
+        'agents-md': 'codex',
+        'gemini-md': 'antigravity',
+        'windsurf': 'windsurf',
+        'cline': 'cline',
+        'roo': 'roo',
+        'continue': 'continue',
+    };
+    return map[format];
+}
 function generateExport(format, options, cwd) {
+    const agentName = formatToAgentName(format);
+    if (agentName) {
+        const adaptive = generateAdaptiveExport(agentName, options, cwd);
+        if (adaptive)
+            return adaptive;
+    }
+    // Fallback to legacy generators for unknown formats
     switch (format) {
         case 'copilot-instructions': return generateCopilotInstructions(options, cwd);
         case 'cursor-rules': return generateCursorRules(options, cwd);
@@ -140,6 +164,26 @@ function generateExport(format, options, cwd) {
             throw new Error(`Unknown export format: ${format}`);
     }
 }
+/**
+ * Generate export content using adaptive templates when a capability profile
+ * exists for the agent, falling back to the legacy per-format generators.
+ */
+function generateAdaptiveExport(agentName, options, cwd) {
+    const profile = getAgentCapabilityProfile(agentName);
+    if (!profile)
+        return undefined;
+    const state = loadState(cwd);
+    const instructions = getInstructionText(options, cwd);
+    const config = loadConfig(cwd);
+    const result = renderBrainclawSection({
+        profile,
+        state,
+        projectName: config.project_name,
+        brainclawVersion: getInstalledBrainclawVersion(),
+        resolvedInstructions: instructions,
+    });
+    return result.content;
+}
 function getInstructionText(options, cwd) {
     try {
         const all = loadInstructions(cwd);

package/dist/commands/init.js

@@ -15,17 +15,18 @@ import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../co
 import { describeAutoConfigWrite, ensureAgentFiles, ensureGitignoreEntries, writeDetectedAgentAutoConfig } from '../core/agent-files.js';
 import { detectAiAgent, detectWslEnvironment } from '../core/ai-agent-detection.js';
 import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-surface-inventory.js';
-import { hasCompletedSetup } from '../core/setup-state.js';
+import { ensureUserStore, hasCompletedSetup } from '../core/setup-state.js';
 import { writeDetectedAgentExport } from './export.js';
 import { writeDetectedAgentHooks } from './hooks.js';
 export async function runInit(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const containingMemoryStore = resolveContainingMemoryStore(cwd);
-    const skipSetupRequirement = options.skipSetupRequirement === true || process.env.BRAINCLAW_SKIP_SETUP_REQUIREMENT === '1';
-    if (!skipSetupRequirement && !hasCompletedSetup()) {
-        console.error('Error: global brainclaw setup has not been completed on this machine.');
-        console.error('Run `brainclaw setup` first, then retry `brainclaw init` from your project root.');
-        process.exit(1);
+    // Auto-create user store if absent (replaces the old "setup required" guard).
+    // The skipSetupRequirement flag and BRAINCLAW_SKIP_SETUP_REQUIREMENT env var
+    // are kept for backward compatibility but are now effectively no-ops —
+    // init always ensures the user store exists before proceeding.
+    if (!hasCompletedSetup()) {
+        ensureUserStore();
     }
     if (containingMemoryStore) {
         console.error(`Error: cannot run \`brainclaw init\` from inside an existing project memory store (${containingMemoryStore}).`);

package/dist/commands/mcp.js

@@ -30,6 +30,8 @@ import { buildEstimationReport } from './estimation-report.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
 import { checkGitPresence, scanGitRepos, parseRoots, parseRepoSelection, parseAgentSelection, runGlobalInstall, initReposAndConfigureAgents, readSetupState, ALL_KNOWN_AGENTS, } from './setup.js';
 import { resolveTargetStore, resolveStoreChain } from '../core/store-resolution.js';
+import { probeForQuickSetup, buildQuickSetupProbeResponse, buildOnboardingPreview } from '../core/setup-flow.js';
+import { ensureUserStore } from '../core/setup-state.js';
 import { readUnseenEvents, buildNotificationSummary } from '../core/event-log.js';
 import { BootstrapInterviewAnswerSchema } from '../core/schema.js';
 export const SCHEMA_VERSION = '0.6.0';
@@ -246,14 +248,17 @@ export const MCP_READ_TOOLS = [
 const MCP_WRITE_TOOLS = [
     {
         name: 'bclaw_setup',
-        description: 'Interactive onboarding wizard — global agent install + multi-repo brainclaw init. Use the resume pattern: call without step to start, then pass step+choice to advance through each stage.',
+        description: 'Interactive onboarding wizard. Two modes: (1) Quick mode (default): probes the current repo and asks project type + topology, then inits. (2) Batch mode: scan root directories and init multiple repos. Call without step to start — brainclaw auto-detects the best mode.',
         inputSchema: {
             type: 'object',
             properties: {
-                step: { type: 'string', description: 'Current step to resume: "project_roots", "repo_selection", or "agent_selection". Omit to start from the beginning.' },
-                choice: { type: 'string', description: 'User choice for the current step (e.g. path list, "all", "detected", or comma-separated numbers).' },
-                roots: { type: 'string', description: 'Comma-separated root paths (required from step "repo_selection" onward to re-scan).' },
-                repo_selection: { type: 'string', description: 'Repo selection choice from previous step (required for "agent_selection" step).' },
+                step: { type: 'string', description: 'Resume step: "quick_init" (quick mode), or "project_roots"/"repo_selection"/"agent_selection" (batch mode). Omit to start.' },
+                choice: { type: 'string', description: 'User choice for the current step.' },
+                project_type: { type: 'string', description: 'Quick mode: "standalone", "workspace", or "linked".' },
+                topology: { type: 'string', description: 'Quick mode: "embedded" (shared via git) or "sidecar" (local only).' },
+                roots: { type: 'string', description: 'Batch mode: comma-separated root paths.' },
+                repo_selection: { type: 'string', description: 'Batch mode: repo selection from previous step.' },
+                mode: { type: 'string', description: 'Force "quick" or "batch" mode. Default: auto-detect.' },
             },
         },
     },
@@ -1112,6 +1117,16 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         const text = args.interview
             ? renderBootstrapInterview(result, audience)
             : renderBootstrapSummary(result);
+        // Extract top-level suggested questions for conversational bootstrap (step 11)
+        const suggestedQuestions = result.importPlan.interview?.questions?.map((q) => ({
+            id: q.id,
+            prompt: q.prompt,
+            rationale: q.rationale,
+            priority: q.priority,
+        })) ?? [];
+        // Separate auto-imports (high confidence) from proposals (need discussion)
+        const autoImports = result.importPlan.suggestions.filter((s) => s.confidence === 'high');
+        const proposals = result.importPlan.suggestions.filter((s) => s.confidence !== 'high');
         return {
             content: [{ type: 'text', text }],
             structuredContent: {
@@ -1127,6 +1142,9 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                 seed_count: result.profile.seed_count,
                 seeds: result.seeds,
                 import_plan: result.importPlan,
+                auto_imports: autoImports,
+                proposals,
+                suggested_questions: suggestedQuestions,
                 last_application: result.lastApplication,
                 reused_profile: result.reusedProfile,
             },
@@ -1571,15 +1589,78 @@ export async function executeMcpToolCall(payload) {
             const choice = args.choice ?? '';
             const rootsArg = args.roots;
             const repoSelectionArg = args.repo_selection;
+            const modeArg = args.mode;
             const env = process.env;
             if (!checkGitPresence()) {
                 return { response: toolResponse({ content: [{ type: 'text', text: 'Git is not installed or not found in PATH. Install git from https://git-scm.com before running brainclaw setup.' }], structuredContent: { error: 'git_not_found' } }, true) };
             }
+            // ─── Quick mode: probe current repo ──────────────────────────────
             if (!step) {
+                // Auto-detect mode: if we're in a git repo, use quick mode unless batch is forced
+                const forceBatch = modeArg === 'batch';
+                if (!forceBatch) {
+                    const probe = probeForQuickSetup(cwd);
+                    if (probe.isGitRepo || probe.alreadyInitialized) {
+                        const response = buildQuickSetupProbeResponse(probe);
+                        return { response: toolResponse({ content: [{ type: 'text', text: response.text }], structuredContent: response.structured }) };
+                    }
+                }
+                // Fall through to batch mode
                 const existingState = readSetupState(env);
                 const alreadyRun = existingState ? `Setup was previously run on ${new Date(existingState.completed_at).toLocaleDateString()}. You can re-run it.` : undefined;
                 return { response: toolResponse({ content: [{ type: 'text', text: [alreadyRun, "Where are the user's project directories? Please ask the user to provide one or more root paths where their git repositories are located (e.g. ~/Projects, C:\\Users\\user\\code)."].filter(Boolean).join('\n\n') }], structuredContent: { pending_question: 'project_roots', prompt: 'Please ask the user: "Where are your projects? Enter one or more root directories (comma-separated):"', ...(alreadyRun ? { already_run: alreadyRun } : {}) } }) };
             }
+            // ─── Quick mode step: init with choices ──────────────────────────
+            if (step === 'quick_init') {
+                const projectType = args.project_type ?? 'standalone';
+                const topology = args.topology ?? 'embedded';
+                // Ensure user store exists
+                ensureUserStore(env);
+                // Map choices to init options
+                const projectMode = projectType === 'workspace' ? 'multi-project' : 'auto';
+                const topologyMode = topology === 'sidecar' ? 'sidecar' : 'embedded';
+                // Run init
+                try {
+                    const { runInit } = await import('./init.js');
+                    await runInit({
+                        yes: true,
+                        cwd,
+                        skipAgentBootstrap: false,
+                        projectMode,
+                        topology: topologyMode,
+                    });
+                }
+                catch (err) {
+                    return { response: toolResponse({ content: [{ type: 'text', text: `Init failed: ${err instanceof Error ? err.message : String(err)}` }], structuredContent: { error: 'init_failed', details: err instanceof Error ? err.message : String(err) } }, true) };
+                }
+                // Detect agent and report
+                const detected = detectAiAgent(env);
+                const summary = [
+                    `✔ Initialized ${cwd.split(/[\\/]/).pop() ?? cwd} (${projectType}, ${topology})`,
+                ];
+                if (detected) {
+                    summary.push(`✔ Agent detected: ${detected.name}`);
+                }
+                summary.push('✔ Reload your agent session to activate brainclaw MCP tools.');
+                // Check if bootstrap is available and generate preview
+                const probe = probeForQuickSetup(cwd);
+                const bootstrapAvailable = probe.hasContent;
+                const preview = buildOnboardingPreview(cwd);
+                return {
+                    response: toolResponse({
+                        content: [{ type: 'text', text: summary.join('\n') + (bootstrapAvailable ? '\n\nThe repo has existing content. Run bclaw_bootstrap to extract initial project context.' : '') + '\n\n' + preview }],
+                        structuredContent: {
+                            setup_complete: true,
+                            project_type: projectType,
+                            topology,
+                            detected_agent: detected?.name ?? null,
+                            bootstrap_available: bootstrapAvailable,
+                            preview,
+                            summary,
+                        },
+                    }),
+                };
+            }
             if (step === 'project_roots') {
                 const roots = parseRoots(choice, env);
                 if (roots.length === 0) {

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