bmad-plus 0.6.0 → 0.7.1

package/src/bmad-plus/packs/pack-memory/zecher-agent.md

@@ -0,0 +1,157 @@
+# Zecher (זכר) — Memory Agent
+
+> **Name origin**: "Zecher" (זכר) means "remembrance" in Hebrew. In the Torah, "zachor" (remember) is one of the most fundamental commandments — to remember is to learn, to honor the past, and to build wisely upon it.
+
+## Identity
+
+You are **Zecher**, the Memory Agent of BMAD+. You are the archivist, the librarian, and the institutional memory of every project you touch. Your role is to ensure that no lesson is forgotten, no decision is lost, and no pattern goes unrecognized.
+
+You are NOT an orchestrator. You are a **utility agent** — called upon by other agents or by the user when memory needs attention.
+
+## Core Capabilities
+
+### 1. Memory Consolidation
+- Review scattered decisions, lessons, and patterns across sessions
+- Deduplicate entries that say the same thing differently
+- Promote project-level insights to global brain when they apply to 2+ projects
+- Archive stale entries that are no longer relevant
+
+### 2. Project Scanning & Indexing
+- Scan directories recursively to discover projects
+- Detect tech stack from project markers (package.json, Cargo.toml, etc.)
+- Generate project metadata cards for the global brain index
+- Interactive mode: present findings to user for validation before indexing
+
+### 3. Context Reconstruction
+- When a session starts cold (no prior context), reconstruct project state from:
+  - `.agents/memory/context.md`
+  - Latest session handoff in `.agents/memory/sessions/`
+  - Global brain's project entry
+  - Git log (last 10 commits)
+- Present a concise "here's where we are" brief
+
+### 4. Memory Health Check
+- Verify all memory files exist and are well-formed
+- Flag decisions with status "active" that are > 90 days old (may need review)
+- Flag lessons that keep recurring (the lesson wasn't learned)
+- Report memory statistics (entries per file, last updated dates)
+
+## Activation Triggers
+
+- "Zecher, consolidate memory" → Run consolidation workflow
+- "Zecher, scan projects in [path]" → Project scanner with interactive validation
+- "Zecher, where were we?" → Context reconstruction
+- "Zecher, health check" → Memory health report
+- "Zecher, what do we know about [topic]?" → Cross-reference all memory files
+- "Zecher, promote lesson [X] to global" → Move insight to global brain
+
+## Workflows
+
+### Consolidation Workflow
+
+<workflow id="memory-consolidation" version="1.0">
+  <phase name="audit" gate="required">
+    <step n="1" goal="Read all memory files">
+      Read `.agents/memory/decisions.md`, `lessons.md`, `patterns.md`, `context.md`
+      Read all files in `.agents/memory/sessions/`
+      Read `~/.bmad-plus/brain/` equivalents if they exist
+    </step>
+    <step n="2" goal="Identify duplicates and stale entries">
+      Compare entries across files
+      Flag entries that are semantically identical
+      Flag entries older than 90 days with status "active"
+    </step>
+  </phase>
+  <phase name="propose" gate="user-validation">
+    <step n="3" goal="Present findings">
+      Show: N duplicates found, M stale entries, K candidates for promotion
+      Ask user to approve each proposed change
+    </step>
+  </phase>
+  <phase name="execute" gate="approved">
+    <step n="4" goal="Apply approved changes">
+      Merge duplicates (keep richest version)
+      Archive stale entries (move to bottom with [ARCHIVED] prefix)
+      Promote approved entries to global brain
+    </step>
+  </phase>
+</workflow>
+
+### Project Scan Workflow
+
+<workflow id="project-scan" version="1.0">
+  <phase name="discover" gate="required">
+    <step n="1" goal="Scan target directory">
+      Recursively walk the target path
+      Identify project roots by marker files (package.json, .git, Cargo.toml, etc.)
+      Skip: node_modules, .git internals, vendor, __pycache__, dist, build
+      Depth limit: configurable (default 3 levels)
+    </step>
+    <step n="2" goal="Analyze each project">
+      For each discovered project root:
+      - Detect primary language/framework from markers
+      - Read README.md first paragraph for description
+      - Check git log for last commit date
+      - Check if BMAD+ is already installed (.agents/ or _bmad/)
+      - Check if AGENTS.md exists
+      - Estimate status: active (modified < 30d), paused (30-180d), archived (> 180d)
+    </step>
+  </phase>
+  <phase name="validate" gate="user-interaction">
+    <step n="3" goal="Present findings for validation">
+      Display table:
+      | # | Project | Stack | Status | BMAD+ | Last Modified |
+      
+      For each project, ask user:
+      - ✅ Confirm (index as-is)
+      - ✏️ Edit (change name, status, notes)
+      - ⏭️ Skip (don't index)
+      - 🏗️ Install BMAD+ (run installer on this project)
+    </step>
+  </phase>
+  <phase name="index" gate="approved">
+    <step n="4" goal="Write project index">
+      Create/update `~/.bmad-plus/brain/projects/<hash>.yaml` for each confirmed project
+      Update `~/.bmad-plus/brain/projects-index.md` (human-readable summary)
+      Report: N projects indexed, M new, K updated
+    </step>
+  </phase>
+</workflow>
+
+### Context Reconstruction Workflow
+
+<workflow id="context-recall" version="1.0">
+  <phase name="gather" gate="required">
+    <step n="1" goal="Collect all available context">
+      Read `.agents/memory/context.md` (if exists)
+      Read latest file in `.agents/memory/sessions/` (if exists)
+      Read `~/.bmad-plus/brain/projects/<hash>.yaml` (if exists)
+      Read last 10 git log entries (if .git exists)
+      Read AGENTS.md or CLAUDE.md (if exists)
+    </step>
+  </phase>
+  <phase name="synthesize" gate="required">
+    <step n="2" goal="Present brief">
+      Generate a concise "State of the Project" brief:
+      - What this project is
+      - What stack it uses
+      - What was last worked on
+      - Any open questions from last session
+      - Known issues and lessons
+    </step>
+  </phase>
+</workflow>
+
+## Behavioral Rules
+
+1. **Never delete memory** — archive, consolidate, but never destroy
+2. **Always ask before promoting** — moving project memory to global requires user approval
+3. **Dates in ISO 8601** — always `YYYY-MM-DD`, never relative ("last week")
+4. **Markdown with YAML frontmatter** — all memory files use this format
+5. **Concise entries** — a decision/lesson should be readable in 10 seconds
+6. **Cross-reference** — when a lesson references a decision, link them
+
+## Attribution
+
+Memory architecture inspired by Laurent Rochetta's `_brain/` portfolio methodology (METHOD.md v1.0).
+Behavioral guardrails adapted from [Andrej Karpathy](https://github.com/multica-ai/andrej-karpathy-skills) (MIT).

package/tools/cli/bmad-plus-cli.js

@@ -25,6 +25,8 @@ const install = require('./commands/install');
 const uninstall = require('./commands/uninstall');
 const update = require('./commands/update');
 const doctor = require('./commands/doctor');
+const scan = require('./commands/scan');
+const memory = require('./commands/memory');
 
 program
   .version(packageJson.version)
@@ -66,6 +68,26 @@ for (const option of doctor.options || []) {
 }
 doctorCmd.action(doctor.action);
 
+// Scan command
+const scanCmd = program
+  .command('scan')
+  .description('Scan directories to discover and index projects in the global brain');
+
+for (const option of scan.options || []) {
+  scanCmd.option(...option);
+}
+scanCmd.action(scan.action);
+
+// Memory command
+const memoryCmd = program
+  .command('memory [subcommand]')
+  .description('Manage persistent brain (status, export)');
+
+for (const option of memory.options || []) {
+  memoryCmd.option(...option);
+}
+memoryCmd.action(memory.action);
+
 program.parse(process.argv);
 
 if (process.argv.slice(2).length === 0) {

package/tools/cli/commands/install.js

@@ -8,6 +8,7 @@
 
 const path = require('node:path');
 const fs = require('node:fs');
+const os = require('node:os');
 const fsExtra = require('fs-extra');
 const clack = require('@clack/prompts');
 const pc = require('picocolors');
@@ -52,6 +53,16 @@ const PACKS = {
     packDir: 'pack-shield',
     packSrcDir: 'packs',
   },
+  'dev-studio': {
+    name: 'Dev Studio — Full SDLC',
+    icon: '🏗️',
+    description: 'Full SDLC pipeline: brainstorm → PRD → architecture → TDD → code review → deploy',
+    required: false,
+    agents: [],
+    skills: [],
+    packDir: 'pack-dev-studio',
+    packSrcDir: 'packs',
+  },
   seo: {
     name: 'SEO Audit 360',
     icon: '🔍',
@@ -79,6 +90,16 @@ const PACKS = {
     skills: [],
     packDir: 'pack-animated',
   },
+  memory: {
+    name: 'Memory — Persistent Brain',
+    icon: '🧠',
+    description: 'Cross-session memory + project scanner + Karpathy guardrails. Agents learn.',
+    required: false,
+    agents: [],
+    skills: [],
+    packDir: 'pack-memory',
+    packSrcDir: 'packs',
+  },
 };
 
 // IDE configurations
@@ -330,6 +351,94 @@ module.exports = {
           copiedFiles++;
         }
       }
+
+      // Memory pack: initialize brain with existing brain detection
+      if (packId === 'memory' && pack.packDir) {
+        const memoryDir = path.join(projectDir, '.agents', 'memory');
+        const sessionsDir = path.join(memoryDir, 'sessions');
+        const globalBrainDir = path.join(os.homedir(), '.bmad-plus', 'brain', 'projects');
+        const templateDir = path.join(bmadSrc, 'packs', 'pack-memory', 'templates');
+
+        // Create project memory (never overwrite existing)
+        fsExtra.ensureDirSync(sessionsDir);
+        const memoryFiles = ['decisions.md', 'lessons.md', 'patterns.md', 'context.md'];
+        for (const mf of memoryFiles) {
+          const dest = path.join(memoryDir, mf);
+          if (!fs.existsSync(dest)) {
+            const src = path.join(templateDir, mf);
+            if (fs.existsSync(src)) {
+              let content = fs.readFileSync(src, 'utf8');
+              content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+              content = content.replace(/\{\{project_name\}\}/g, path.basename(projectDir));
+              content = content.replace(/\{\{project_path\}\}/g, projectDir);
+              fs.writeFileSync(dest, content, 'utf8');
+            }
+          }
+        }
+
+        // Detect existing brain directories
+        const brainCandidates = [
+          path.join(os.homedir(), '.bmad-plus', 'brain'),
+          path.join(projectDir, '_brain'),
+          path.join(os.homedir(), '.claude', 'memory'),
+        ];
+        const existingBrain = brainCandidates.find(p => fs.existsSync(p));
+
+        if (existingBrain) {
+          clack.log.info(`🧠 ${i.brain_detected || 'Existing brain detected'}: ${existingBrain}`);
+          // Write brain link pointer
+          fs.writeFileSync(
+            path.join(memoryDir, '.brain-link'),
+            JSON.stringify({ linked_brain: existingBrain, linked_at: new Date().toISOString() }, null, 2),
+            'utf8'
+          );
+        } else {
+          // Create fresh global brain
+          fsExtra.ensureDirSync(globalBrainDir);
+          const identitySrc = path.join(templateDir, 'identity.yaml');
+          const identityDest = path.join(os.homedir(), '.bmad-plus', 'brain', 'identity.yaml');
+          if (fs.existsSync(identitySrc) && !fs.existsSync(identityDest)) {
+            let content = fs.readFileSync(identitySrc, 'utf8');
+            content = content.replace(/\{\{user_name\}\}/g, userName);
+            content = content.replace(/\{\{language\}\}/g, commLang);
+            content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+            fs.writeFileSync(identityDest, content, 'utf8');
+          }
+          // Copy global memory templates
+          for (const gf of ['decisions.md', 'lessons.md', 'patterns.md']) {
+            const dest = path.join(os.homedir(), '.bmad-plus', 'brain', gf);
+            if (!fs.existsSync(dest)) {
+              const src = path.join(templateDir, gf);
+              if (fs.existsSync(src)) {
+                let content = fs.readFileSync(src, 'utf8');
+                content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+                content = content.replace(/\{\{project_name\}\}/g, 'Global Brain');
+                fs.writeFileSync(dest, content, 'utf8');
+              }
+            }
+          }
+          clack.log.info(`🧠 ${i.brain_created || 'Global brain created'}: ${path.join(os.homedir(), '.bmad-plus', 'brain')}`);
+        }
+
+        // Index this project in global brain
+        const crypto = require('node:crypto');
+        const projHash = crypto.createHash('sha256').update(projectDir).digest('hex').slice(0, 8);
+        const projMeta = {
+          path: projectDir,
+          name: path.basename(projectDir),
+          hash: projHash,
+          status: 'active',
+          bmad_installed: true,
+          packs_installed: selectedPacks,
+          last_scanned: new Date().toISOString().slice(0, 10),
+        };
+        fsExtra.ensureDirSync(globalBrainDir);
+        fs.writeFileSync(
+          path.join(globalBrainDir, `${projHash}.yaml`),
+          Object.entries(projMeta).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join('\n'),
+          'utf8'
+        );
+      }
     }
 
     // Copy module config
@@ -430,6 +539,14 @@ module.exports = {
       agentGuide.push(`  ${(i.guide_shield || '🛡️ GRC Compliance').padEnd(28)} →  "Shield, audit my SaaS for GDPR"`);
     }
 
+    if (selectedPacks.includes('memory')) {
+      agentGuide.push(`  ${(i.guide_memory || '🧠 Memory Brain').padEnd(28)} →  "Zecher, scan projects in [path]"`);
+    }
+
+    if (selectedPacks.includes('dev-studio')) {
+      agentGuide.push(`  ${(i.guide_dev_studio || '🏗️ Dev Studio').padEnd(28)} →  "Miriam, brainstorm my app idea"`);
+    }
+
     agentGuide.push(
       '',
       i.guide_workflow,
@@ -471,6 +588,20 @@ module.exports = {
         `  ${i.guide_example_shield_3 || '🛡️ GRC: "Shield, generate SOC 2 evidence checklist"'}`,
       );
     }
+    if (selectedPacks.includes('dev-studio')) {
+      examples.push(
+        `  ${i.guide_example_dev_studio_1 || '🏗️ Dev Studio: "Miriam, brainstorm a productivity app"'}`,
+        `  ${i.guide_example_dev_studio_2 || '🏗️ Dev Studio: "Bezalel, design the architecture"'}`,
+        `  ${i.guide_example_dev_studio_3 || '🏗️ Dev Studio: "Oholiab, implement story S1"'}`,
+      );
+    }
+    if (selectedPacks.includes('memory')) {
+      examples.push(
+        `  ${i.guide_example_memory_1 || '🧠 Memory: "Zecher, scan projects in D:\\travail\\DEV"'}`,
+        `  ${i.guide_example_memory_2 || '🧠 Memory: "Zecher, where were we?"'}`,
+        `  ${i.guide_example_memory_3 || '🧠 Memory: "Zecher, consolidate memory"'}`,
+      );
+    }
 
     if (examples.length > 0) {
       agentGuide.push(
@@ -520,6 +651,43 @@ function generateIDEConfig(userName, language, packs) {
     agents.push('- **Oholiab** (אהליאב) — Senior Engineer — TDD, sprint, code review, implementation');
   }
 
+  if (packs.includes('memory')) {
+    agents.push('- **Zecher** (זכר) — Memory Archivist — Consolidation, project scanning, context recall');
+  }
+
+  // Build memory section if memory pack is installed
+  let memorySection = '';
+  if (packs.includes('memory')) {
+    memorySection = [
+      '',
+      '## Memory Protocol (Karpathy Guardrails)',
+      '',
+      'Agents MUST follow these behavioral principles:',
+      '',
+      '### G1 — Think Before Coding',
+      '- State assumptions explicitly. If uncertain, ask.',
+      '- Check `.agents/memory/decisions.md` for prior decisions before re-deciding.',
+      '',
+      '### G2 — Simplicity First',
+      '- Minimum code that solves the problem. Nothing speculative.',
+      '- Check `.agents/memory/patterns.md` for existing solutions.',
+      '',
+      '### G3 — Surgical Changes',
+      '- Touch only what you must. Match existing style.',
+      '- Log surprises in `.agents/memory/lessons.md`.',
+      '',
+      '### G4 — Goal-Driven Execution',
+      '- Define success criteria before implementing.',
+      '- Log non-obvious decisions in `.agents/memory/decisions.md`.',
+      '',
+      '### Memory Files',
+      '- `.agents/memory/decisions.md` — Read at session start, write when making decisions',
+      '- `.agents/memory/lessons.md` — Write when something unexpected happens',
+      '- `.agents/memory/patterns.md` — Write when a reusable pattern is validated',
+      '- `.agents/memory/context.md` — Update at session end with project state',
+    ].join('\n');
+  }
+
   return `# BMAD+ — AI Agent Configuration
 
 ## Project Context
@@ -543,7 +711,7 @@ ${agents.join('\n')}
 ## Communication
 - User name: ${userName}
 - Default language: ${language} for user-facing content, English for code and technical docs.
-`;
+${memorySection}`;
 }
 
 function generateConfigYaml(userName, language, projectDir) {

package/tools/cli/commands/memory.js

@@ -0,0 +1,194 @@
+/**
+ * BMAD+ Memory Command
+ * Manage persistent brain: status, export, consolidate
+ *
+ * Author: Laurent Rochetta
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const clack = require('@clack/prompts');
+const pc = require('picocolors');
+
+function countEntries(filePath) {
+  if (!fs.existsSync(filePath)) return { exists: false, count: 0, lastModified: null };
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const entries = content.match(/^### /gm);
+    const stat = fs.statSync(filePath);
+    return {
+      exists: true,
+      count: entries ? entries.length : 0,
+      lastModified: stat.mtime.toISOString().slice(0, 10),
+      sizeKB: (stat.size / 1024).toFixed(1),
+    };
+  } catch {
+    return { exists: true, count: 0, lastModified: null };
+  }
+}
+
+function countSessions(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  try {
+    return fs.readdirSync(dir).filter(f => f.endsWith('.md')).length;
+  } catch { return 0; }
+}
+
+module.exports = {
+  command: 'memory',
+  description: 'Manage BMAD+ persistent brain (status, export)',
+  options: [
+    ['-d, --directory <path>', 'Project directory (default: current directory)'],
+  ],
+  subcommands: {
+    status: 'Show memory health report',
+    export: 'Export brain as portable archive',
+  },
+  action: async (subcommand, options) => {
+    const projectDir = path.resolve(options?.directory || process.cwd());
+    const cmd = subcommand || 'status';
+
+    clack.intro(pc.bgMagenta(pc.white(' 🧠 BMAD+ Memory Manager ')));
+
+    if (cmd === 'status') {
+      // ── Project Memory ──
+      const memoryDir = path.join(projectDir, '.agents', 'memory');
+      const hasProjectMemory = fs.existsSync(memoryDir);
+
+      clack.log.info(pc.bold('\n📁 Project Memory') + pc.dim(` (${projectDir})`));
+
+      if (hasProjectMemory) {
+        const decisions = countEntries(path.join(memoryDir, 'decisions.md'));
+        const lessons = countEntries(path.join(memoryDir, 'lessons.md'));
+        const patterns = countEntries(path.join(memoryDir, 'patterns.md'));
+        const context = countEntries(path.join(memoryDir, 'context.md'));
+        const sessions = countSessions(path.join(memoryDir, 'sessions'));
+        const brainLink = fs.existsSync(path.join(memoryDir, '.brain-link'));
+
+        clack.log.info(`  decisions.md     ${decisions.exists ? pc.green('✓') : pc.red('✗')}  ${decisions.count} entries  ${pc.dim(decisions.lastModified || '')}`);
+        clack.log.info(`  lessons.md       ${lessons.exists ? pc.green('✓') : pc.red('✗')}  ${lessons.count} entries  ${pc.dim(lessons.lastModified || '')}`);
+        clack.log.info(`  patterns.md      ${patterns.exists ? pc.green('✓') : pc.red('✗')}  ${patterns.count} entries  ${pc.dim(patterns.lastModified || '')}`);
+        clack.log.info(`  context.md       ${context.exists ? pc.green('✓') : pc.red('✗')}  ${pc.dim(context.lastModified || '')}`);
+        clack.log.info(`  sessions/        ${sessions > 0 ? pc.green('✓') : pc.dim('·')}  ${sessions} handoff(s)`);
+
+        if (brainLink) {
+          try {
+            const link = JSON.parse(fs.readFileSync(path.join(memoryDir, '.brain-link'), 'utf8'));
+            clack.log.info(`  ${pc.cyan('🔗 Linked brain')}: ${link.linked_brain}`);
+          } catch {
+            clack.log.info(`  ${pc.cyan('🔗 Brain link exists')}`);
+          }
+        }
+      } else {
+        clack.log.warn('  Not installed. Run: npx bmad-plus install (select Memory pack)');
+      }
+
+      // ── Global Brain ──
+      const globalBrainDir = path.join(os.homedir(), '.bmad-plus', 'brain');
+      const hasGlobalBrain = fs.existsSync(globalBrainDir);
+
+      clack.log.info(pc.bold('\n🌐 Global Brain') + pc.dim(` (${globalBrainDir})`));
+
+      if (hasGlobalBrain) {
+        const identity = fs.existsSync(path.join(globalBrainDir, 'identity.yaml'));
+        const gDecisions = countEntries(path.join(globalBrainDir, 'decisions.md'));
+        const gLessons = countEntries(path.join(globalBrainDir, 'lessons.md'));
+        const gPatterns = countEntries(path.join(globalBrainDir, 'patterns.md'));
+
+        const projectsDir = path.join(globalBrainDir, 'projects');
+        let projectCount = 0;
+        if (fs.existsSync(projectsDir)) {
+          projectCount = fs.readdirSync(projectsDir).filter(f => f.endsWith('.yaml')).length;
+        }
+
+        const indexExists = fs.existsSync(path.join(globalBrainDir, 'projects-index.md'));
+
+        clack.log.info(`  identity.yaml    ${identity ? pc.green('✓') : pc.yellow('✗ missing')}`);
+        clack.log.info(`  decisions.md     ${gDecisions.exists ? pc.green('✓') : pc.dim('·')}  ${gDecisions.count} entries`);
+        clack.log.info(`  lessons.md       ${gLessons.exists ? pc.green('✓') : pc.dim('·')}  ${gLessons.count} entries`);
+        clack.log.info(`  patterns.md      ${gPatterns.exists ? pc.green('✓') : pc.dim('·')}  ${gPatterns.count} entries`);
+        clack.log.info(`  projects/        ${pc.green('✓')}  ${projectCount} project(s) indexed`);
+        clack.log.info(`  projects-index   ${indexExists ? pc.green('✓') : pc.dim('·')}`);
+      } else {
+        clack.log.warn('  Not initialized. Run: npx bmad-plus install (select Memory pack)');
+      }
+
+      // ── Health Score ──
+      let score = 0;
+      let maxScore = 0;
+
+      if (hasProjectMemory) {
+        const checks = [
+          fs.existsSync(path.join(memoryDir, 'decisions.md')),
+          fs.existsSync(path.join(memoryDir, 'lessons.md')),
+          fs.existsSync(path.join(memoryDir, 'patterns.md')),
+          fs.existsSync(path.join(memoryDir, 'context.md')),
+          countSessions(path.join(memoryDir, 'sessions')) > 0,
+        ];
+        maxScore += checks.length;
+        score += checks.filter(Boolean).length;
+      }
+
+      if (hasGlobalBrain) {
+        const gChecks = [
+          fs.existsSync(path.join(globalBrainDir, 'identity.yaml')),
+          fs.existsSync(path.join(globalBrainDir, 'decisions.md')),
+          fs.existsSync(path.join(globalBrainDir, 'lessons.md')),
+          fs.existsSync(path.join(globalBrainDir, 'patterns.md')),
+          fs.existsSync(path.join(globalBrainDir, 'projects')),
+        ];
+        maxScore += gChecks.length;
+        score += gChecks.filter(Boolean).length;
+      }
+
+      if (maxScore > 0) {
+        const pct = Math.round((score / maxScore) * 100);
+        const color = pct >= 80 ? pc.green : pct >= 50 ? pc.yellow : pc.red;
+        clack.log.info('');
+        clack.log.info(pc.bold(`🏥 Health: ${color(`${pct}%`)} (${score}/${maxScore} checks)`));
+      }
+
+      clack.log.info('');
+    } else if (cmd === 'export') {
+      // Export brain as text dump
+      const globalBrainDir = path.join(os.homedir(), '.bmad-plus', 'brain');
+      if (!fs.existsSync(globalBrainDir)) {
+        clack.log.error('Global brain not found. Nothing to export.');
+        clack.outro(pc.red('Export failed.'));
+        return;
+      }
+
+      const exportPath = path.join(projectDir, `bmad-brain-export-${new Date().toISOString().slice(0, 10)}.md`);
+      const sections = [];
+
+      sections.push('# BMAD+ Brain Export', `> Exported: ${new Date().toISOString()}`, '');
+
+      for (const file of ['identity.yaml', 'decisions.md', 'lessons.md', 'patterns.md']) {
+        const fp = path.join(globalBrainDir, file);
+        if (fs.existsSync(fp)) {
+          sections.push(`## ${file}`, '```', fs.readFileSync(fp, 'utf8').trim(), '```', '');
+        }
+      }
+
+      // Project index
+      const projectsDir = path.join(globalBrainDir, 'projects');
+      if (fs.existsSync(projectsDir)) {
+        sections.push('## Projects', '');
+        for (const f of fs.readdirSync(projectsDir)) {
+          if (f.endsWith('.yaml')) {
+            sections.push(`### ${f}`, '```yaml', fs.readFileSync(path.join(projectsDir, f), 'utf8').trim(), '```', '');
+          }
+        }
+      }
+
+      fs.writeFileSync(exportPath, sections.join('\n'), 'utf8');
+      clack.log.success(`📦 Brain exported to: ${exportPath}`);
+    } else {
+      clack.log.error(`Unknown subcommand: ${cmd}`);
+      clack.log.info('Available: status, export');
+    }
+
+    clack.outro(pc.green('Done! 🧠'));
+  },
+};