brain-tree-ai 0.1.1 → 0.1.2

package/dist/commands/init.js

@@ -7,118 +7,925 @@ const DEFAULT_MCP_URL = 'https://braintree-mcp-production.up.railway.app/sse';
 // Brain commands that get installed to ~/.claude/commands/
 const BRAIN_COMMANDS = [
     {
-        name: 'init-vault.md',
-        content: `# Initialize Vault
+        name: 'init-brain.md',
+        content: `# Initialize Brain
 
-Create a new brain vault for your project using BrainTree MCP tools.
+You are setting up a brand new BrainTree brain for the user. A brain is a living, structured knowledge base that organizes everything about a project, goal, or domain. It is powered by the BrainTree MCP server. All file operations MUST go through the MCP tools (never the local filesystem).
 
-## Steps
+This command is a guided, multi-step conversation. Each question adapts based on the previous answer. Ask ONE question at a time. Do NOT rush through the phases.
 
-1. Ask the user what they're building (project name, description, tech stack)
-2. Use MCP \`write_file\` to create VAULT-INDEX.md
-3. Use MCP \`write_file\` to create department index files
-4. Use MCP \`write_file\` to create Execution-Plan.md
-5. Use MCP \`create_handoff\` to log the initialization session
-6. Print summary of created vault structure
+## Phase 1: Role Discovery
+
+Start with a friendly welcome, then ask the FIRST question:
+
+"Welcome to BrainTree! I'm going to help you set up your brain, a living knowledge base that keeps everything about your work organized and actionable.
+
+Let's start with the most important question:"
+
+**Question 1** (present as a numbered list):
+
+"What best describes your role?"
+1. Solo founder building from scratch
+2. Technical founder (I code, need help with everything else)
+3. Non-technical founder (I have the vision, need technical execution)
+4. Team lead / Engineering manager
+5. Product Manager
+6. Marketing / Growth
+7. Customer Success / Support
+8. Other (tell me your role)
+
+Wait for their answer. Their role shapes EVERYTHING that follows. Do NOT proceed until you have a clear answer.
+
+## Phase 2: Goals & Identity
+
+**Question 2** (open-ended, this is the most important input):
+
+Based on their role, ask a tailored version of this question. Adapt the phrasing to their role:
+
+- Solo founder: "Tell me about what you're building. What stage are you at? What's your biggest challenge right now? The more context you give me, the smarter your brain will be."
+- Technical founder: "What are you building and what's your tech stack? Where do you need the most help beyond coding?"
+- Non-technical founder: "What's your vision? What problem are you solving and for whom? What have you done so far?"
+- Team lead: "What does your team build? How big is the team? What's your current biggest operational challenge?"
+- Product Manager: "What product do you manage? What's your team size and structure? What are your current priorities?"
+- Marketing: "What company or product are you marketing? What channels are you focused on? What are your goals this quarter?"
+- Customer Success: "What product do you support? How big is your customer base? What's your biggest retention challenge?"
+- Other: "Tell me about yourself, your work, and what you want this brain to help you with."
+
+Let them write as much as they want. This is where the magic happens. Acknowledge what they shared and summarize it back: "Here's what I understand: [summary]. Does that sound right?"
+
+Wait for confirmation before proceeding.
+
+## Phase 3: Context Source Discovery
+
+**Question 3**:
+
+"Now let's make your brain smart from day one. Do you have any existing context I can pull from?"
+
+Present as a numbered list:
+1. Local folder(s) on your computer (share the path and I'll read through everything)
+2. URLs or web pages (docs, wikis, competitor sites, anything)
+3. Paste text directly (specs, notes, plans, meeting notes, anything goes)
+4. Nothing yet, starting fresh
+
+**MCP Detection** (do this automatically, no need to ask):
+Check what MCP servers are available in the current session. If you detect useful ones beyond the BrainTree MCP (e.g., GitHub, Slack, Notion, Linear, Figma, Google Drive, file system access), proactively suggest them:
+
+"I also notice you have [MCP name] connected. Want me to pull relevant context from there too?"
+
+For each source the user provides:
+- **Local folders**: Read through files systematically. Summarize what you find. Identify the most relevant content.
+- **URLs**: Fetch and extract relevant content using web tools.
+- **Pasted text**: Acknowledge and organize it.
+- **MCP sources**: Use the available MCP tools to explore and pull relevant data.
+
+After exploring all sources, present a summary: "Here's what I gathered from your sources: [organized summary]. I'll weave this into your brain structure."
+
+## Phase 4: Structure Preview
+
+Based on everything learned in Phases 1-3, design a custom brain structure. The structure MUST be tailored to the user's role and goals.
+
+### Structure Principles:
+- Do NOT default to a corporate department structure unless the user is explicitly building a company/startup
+- Name folders in the user's language (a PM thinks in "Discovery", "Specs", "Roadmap" not "02_Product", "03_Marketing")
+- Keep it between 5-10 top-level folders. Less is more.
+- ALWAYS include: Assets/, Handoffs/, Templates/
+- If the user is building something with phases, include an Execution Plan
+- If the user has an ongoing role, include working rhythms or processes
+
+### Structure Templates by Role (use as starting points, customize based on actual goals):
+
+**Solo Founder / Building a Product:**
+\`\`\`
+Vision/           - Identity, pitch, target users, problem/solution
+Build/            - Architecture, tech stack, implementation notes
+Product/          - Features, user flows, specs, decisions
+Go-To-Market/     - Launch plan, channels, messaging, content
+Operations/       - Processes, tools, hiring, budget
+Assets/           - Images, videos, PDFs, mockups, screenshots
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Technical Founder:**
+\`\`\`
+Architecture/     - System design, diagrams, tech decisions
+Services/         - Service docs, APIs, schemas, integrations
+Product/          - Feature specs, user stories, roadmap
+Runbooks/         - Deploy guides, operational procedures
+Research/         - Spikes, POCs, technology evaluations
+Assets/           - Diagrams, screenshots, recordings
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Non-Technical Founder:**
+\`\`\`
+Vision/           - Mission, values, pitch, brand identity
+Product/          - Features, user experience, requirements
+Business/         - Market research, competitors, partnerships
+Marketing/        - Content, social media, campaigns, SEO
+Finance/          - Budget, revenue model, funding
+Assets/           - Mockups, brand assets, pitch decks
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Product Manager:**
+\`\`\`
+Strategy/         - Product vision, OKRs, competitive landscape
+Discovery/        - User research, interviews, pain points
+Roadmap/          - Current quarter, backlog, prioritization
+Specs/            - Feature specs (one per feature)
+Stakeholders/     - Engineering, design, leadership alignment
+Metrics/          - KPIs, experiments, dashboards
+Assets/           - Screenshots, mockups, recordings
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Marketing / Growth:**
+\`\`\`
+Strategy/         - Positioning, messaging, brand voice
+Campaigns/        - Campaign briefs, results, learnings
+Content/          - Content calendar, posts, email sequences
+Channels/         - Per-channel strategy (social, email, paid, SEO)
+Audience/         - Personas, segments, research
+Analytics/        - Performance data, attribution, funnel analysis
+Assets/           - Brand assets, creatives, videos
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Customer Success:**
+\`\`\`
+Accounts/         - Key account profiles, health scores
+Playbooks/        - Onboarding, renewal, expansion, churn prevention
+Feedback/         - Customer feedback, feature requests, NPS
+Processes/        - Escalation paths, SLAs, workflows
+Knowledge-Base/   - FAQs, troubleshooting, documentation
+Metrics/          - Retention, NRR, CSAT, health scores
+Assets/           - Training materials, recordings
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Team Lead / Engineering Manager:**
+\`\`\`
+Team/             - Members, roles, growth plans, 1:1 notes
+Architecture/     - System design, tech debt, ADRs
+Planning/         - Sprint plans, capacity, roadmap alignment
+Processes/        - Code review, on-call, incident response
+Hiring/           - Job descriptions, interview guides, pipeline
+Metrics/          - Velocity, quality, team health
+Assets/           - Diagrams, org charts, presentations
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Trader / Finance:**
+\`\`\`
+Strategies/       - Trading strategies, backtests, edge definitions
+Trade-Log/        - Trade journal, entries, exits, reviews
+Market-Research/  - Macro, sectors, earnings, catalysts
+Risk-Management/  - Position sizing, stop rules, risk limits
+Watchlists/       - Tickers, setups, alerts
+Performance/      - P&L tracking, analytics, equity curve
+Assets/           - Charts, screenshots, data exports
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+**Student / Researcher:**
+\`\`\`
+Courses/          - Course notes, syllabi, assignments
+Research/         - Papers, literature reviews, methodology
+Projects/         - Project plans, deliverables, timelines
+Notes/            - Lecture notes, reading notes, summaries
+Resources/        - Links, tools, references, datasets
+Schedule/         - Deadlines, milestones, calendar
+Assets/           - Papers, slides, diagrams, data
+Handoffs/         - Session continuity notes
+Templates/        - Reusable note structures
+\`\`\`
+
+If the user's role doesn't match any template, create a fully custom structure.
+
+**Present the structure as an interactive preview:**
+
+Show the full folder tree with brief descriptions for each folder. Then:
+
+1. Explicitly highlight the Assets folder: "The **Assets/** folder is where you can drop images, videos, PDFs, and any other files. I can analyze all of them, including screenshots, mockups, screen recordings, documents, and data files."
+
+2. Ask: "Would you like to add, remove, or rename any folders before I build it?"
+
+Wait for confirmation before proceeding.
+
+## Phase 5: Build
+
+Create all brain files using the BrainTree MCP tools.
+
+### Step 1: Create CLAUDE.md
+This is the brain's DNA. Every AI agent reads this file first. Use \`write_file\` to create \`CLAUDE.md\` at the brain root.
+
+CLAUDE.md must include ALL of these sections:
+
+\`\`\`
+# [Brain Name] - Agent Instructions
+
+## What Is This Brain?
+[2-3 sentences: what this brain is for, written as context for an AI seeing it for the first time]
+
+## Owner
+- **Role**: [user's role]
+- **Context**: [key context from their answers, summarized]
+- **Goals**: [primary goals extracted from the conversation]
+
+## Brain Structure
+[Full map of folders with one-line descriptions]
+
+## Conventions
+- Use [[wikilinks]] for all cross-references between notes
+- Keep files concise and actionable
+- Tag files with relevant hashtags for discoverability
+- Check Assets/ for related images, videos, PDFs when working on any task
+- Update Handoffs/ at the end of every work session
+- Reference the Execution Plan as the source of truth for build order (if applicable)
+
+## Assets
+The Assets/ folder contains images, videos, PDFs, and other media. When working on any task, check Assets/ for related materials. You can analyze images, read PDFs, and process any file dropped there.
+
+## Agent Personas
+Available specialized agents in .claude/agents/:
+[List each agent: name and one-line purpose]
+
+## Commands
+- /init-brain - Initialize a new brain
+- /brain-resume - Resume from where you left off
+- /brain-wrap-up - End session with proper handoff
+- /brain-status - View progress dashboard
+- /brain-plan [step] - Plan a specific step
+- /brain-sprint - Plan the week's work
+- /brain-sync - Health check and sync
+- /brain-feature [name] - Plan a new feature
+\`\`\`
+
+### Step 2: Create Agent Personas
+Use \`write_file\` to create 2-4 agent persona files in \`.claude/agents/\`. Each persona must be specifically useful for THIS user's role and goals. Reference the user's actual project and context in each persona.
+
+Each persona file:
+\`\`\`
+# [Agent Name]
+
+## Purpose
+[One sentence: what this agent does for this specific user]
+
+## Expertise
+[What this agent knows, specific to the user's domain and project]
+
+## Approach
+[How this agent thinks, communicates, and works]
+
+## When to Use
+[Specific scenarios where this agent is the right choice]
+
+## Instructions
+[Detailed instructions for operating in this brain, referencing actual folders and files]
+\`\`\`
+
+**Select personas based on role** (adapt to actual goals, these are starting points):
+
+Solo Founder:
+- builder.md: Full-stack implementation, ships code, makes technical decisions
+- strategist.md: Product thinking, prioritization, business model, go-to-market
+- researcher.md: Market analysis, competitor intel, user insights, validation
+- writer.md: Copy, content, docs, pitch materials, social media
+
+Technical Founder:
+- architect.md: System design, tech decisions, scalability planning
+- product.md: Feature prioritization, user stories, product-market fit
+- devops.md: Infrastructure, CI/CD, monitoring, deployment
+- growth.md: Launch strategy, marketing, user acquisition
+
+Non-Technical Founder:
+- product.md: Feature definition, user experience, requirements
+- business.md: Market research, competitive analysis, business model
+- marketing.md: Brand, content, social media, launch campaigns
+- hiring.md: Team building, job descriptions, interview process
+
+Product Manager:
+- analyst.md: Data analysis, metrics, experiment design, dashboards
+- spec-writer.md: Feature specs, PRDs, acceptance criteria, user stories
+- researcher.md: User interview synthesis, competitive analysis, market trends
+- facilitator.md: Stakeholder alignment, decision documentation, trade-offs
+
+Marketing / Growth:
+- content-creator.md: Blog posts, social media, email campaigns, copywriting
+- analyst.md: Campaign performance, funnel analysis, attribution modeling
+- strategist.md: Positioning, messaging, channel strategy, brand voice
+- seo.md: Search optimization, keyword research, content planning
+
+Customer Success:
+- account-manager.md: Account health, renewal strategies, expansion playbooks
+- analyst.md: Churn analysis, NPS trends, customer health scoring
+- content.md: Help docs, onboarding guides, training materials
+- process.md: Workflow optimization, escalation procedures, SLA management
+
+Team Lead:
+- architect.md: System design, tech debt assessment, architecture decisions
+- planner.md: Sprint planning, task breakdown, dependency mapping
+- people.md: 1:1 prep, growth plans, hiring pipeline, team health
+- reviewer.md: Code review guidance, quality standards, best practices
+
+Trader / Finance:
+- analyst.md: Market analysis, sector research, earnings analysis
+- risk.md: Position sizing, risk management, portfolio allocation
+- journal.md: Trade review, pattern recognition, performance analysis
+- researcher.md: Macro trends, catalyst identification, data analysis
+
+Student / Researcher:
+- tutor.md: Concept explanation, study strategies, problem solving
+- writer.md: Paper writing, citations, literature review synthesis
+- planner.md: Project planning, deadline management, task breakdown
+- reviewer.md: Draft feedback, argument analysis, fact checking
+
+IMPORTANT: Every persona MUST reference the user's actual project, goals, and brain structure. Generic personas are useless. Write them as if they were custom-built for this specific user.
+
+### Step 3: Create BRAIN-INDEX.md
+Use \`write_file\` to create \`BRAIN-INDEX.md\` at the brain root. This is the master navigation file. Include:
+- Brain name and description
+- Creation date
+- Owner/role
+- A linked table of contents to every folder index
+- A "Quick Links" section for the most important files
+- Session log section (starts with "Session 0: Brain Initialized")
+
+### Step 4: Create folder index files
+For each folder in the structure, use \`write_file\` to create an index file (e.g., \`Vision/README.md\`). Each index should:
+- Describe the folder's purpose in context of THIS user's project
+- List what will go in it
+- Include wikilinks (\`[[filename]]\`) to planned content files
+- Be concise (20-40 lines max)
+
+### Step 5: Create Assets/README.md
+Always create this file:
+
+\`\`\`
+# Assets
+
+Drop any files here that you want your AI agents to understand.
+
+## Supported Formats
+- Images (PNG, JPG, SVG): screenshots, mockups, diagrams, whiteboard photos
+- Videos (MP4, MOV): recordings, demos, user sessions, presentations
+- PDFs: documents, reports, contracts, research papers
+- Data (CSV, JSON, Excel): datasets, exports, analytics
+
+## How It Works
+When you or an agent works on a task, this folder is checked for related materials.
+You can also point an agent here directly: "analyze the mockup in Assets/homepage-v2.png"
+
+## Naming Convention
+Use descriptive names: competitor-pricing-screenshot.png not IMG_4521.png
+\`\`\`
+
+### Step 6: Create Execution Plan or Working Rhythms
+If the user is building something with clear phases (product, project, course), create \`Execution-Plan.md\` with:
+- Numbered phases with milestones
+- Steps with: step ID, title, description, status (not_started), dependencies
+- Parallel groups where applicable
+
+If the brain is ongoing/operational, create \`Working-Rhythms.md\` with:
+- Daily/weekly/monthly recurring workflows
+- Review cadences
+- Templates for recurring tasks
+
+### Step 7: Create Templates
+Use \`write_file\` to create 2-3 templates in \`Templates/\`:
+- A general note template
+- A domain-specific template based on the user's role
+- A decision log template
+
+### Step 8: Seed initial content
+Using context gathered in Phase 3, create real content files in the relevant folders:
+- Specs, plans, research organized into the right locations
+- Content from MCP sources placed appropriately
+- Competitive analysis, tech stack docs, whatever was gathered
+
+This is what makes the brain feel alive from day one.
+
+## Phase 6: Handoff
+
+1. Use \`create_handoff\` with session_number 0, a summary of what was created, and content that includes:
+   - The brain structure
+   - Context gathered and where it was placed
+   - Agent personas created
+   - Recommended first steps for the next session
+   - Key files to read when resuming
+
+2. Present a final summary to the user:
+   - Show the complete file tree with counts
+   - List agent personas and their purposes
+   - Highlight the Assets folder: "Remember, you can drop images, videos, and documents in Assets/ and I can analyze them."
+   - Highlight CLAUDE.md: "Your brain has a CLAUDE.md that tells any AI agent how to work here."
+   - End with: "Your brain is ready! Run /brain-resume to start your first real work session."
 `,
     },
     {
         name: 'brain-resume.md',
-        content: `# Resume Work
+        content: `# Resume Brain Session
+
+You are helping the user resume work on their BrainTree brain. This is the most important command because it is how every work session starts. Your goal is to give the user a crystal-clear picture of where they are and exactly what to do next. Do NOT just dump status. Be a strategic advisor.
+
+## Step 1: Load Context
+
+Run these MCP calls to gather the full picture:
+
+1. \`get_latest_handoff()\` to read the last session's summary, what was done, what was recommended next, and which files to focus on.
+2. \`get_execution_plan()\` to see overall progress across all phases and steps.
+3. \`list_unblocked_steps()\` to find all steps that are ready to work on right now (no blockers).
+4. \`list_departments()\` to understand the brain's structure and which areas have content.
+
+## Step 2: Read Key Files
+
+Based on the handoff's "files to read" recommendation, use \`read_file()\` on the 2-4 most important files for the current context. This gives you the detailed state, not just summaries.
+
+## Step 3: Present Targeted Status
+
+Present a focused status report. Structure it exactly like this:
+
+### Last Session Recap
+"In your last session (Session N), you [concise summary of what was accomplished]. You left off at [specific point]."
+
+If there were blockers or open questions from the last session, highlight them here.
+
+### Current Progress
+Show a brief progress overview. Use ASCII progress bars for phases:
+\`\`\`
+Phase 1: Setup        [========--] 80%  (7/9 steps)
+Phase 2: Core Build   [===-------] 30%  (3/10 steps)
+Phase 3: Launch       [----------]  0%  (0/5 steps)
+\`\`\`
+
+### Recommended Next Steps
+This is the most critical part. Be specific and actionable:
+
+"The highest priority next step is **[Step X.Y: Title]** because [reason: it unblocks the most work / it is on the critical path / it was recommended in the last handoff]."
+
+For each recommended step (up to 3), include:
+- What the step involves (1-2 sentences)
+- Which brain files are relevant (list specific paths)
+- Estimated complexity (small / medium / large)
+
+### Parallel Opportunities
+If multiple unblocked steps can run simultaneously, highlight this: "Steps X.Y and X.Z can run in parallel. Want me to set up a team for parallel execution?"
 
-Resume development from where you left off using BrainTree MCP tools.
+## Step 4: Ask What to Work On
 
-## Steps
+Present the options as a numbered list and ask the user to pick:
 
-1. Use MCP \`get_latest_handoff\` to understand last session context
-2. Use MCP \`list_unblocked_steps\` to find available work
-3. Use MCP \`get_execution_plan\` for overall progress
-4. Present status summary and ask what to work on
+1. [Recommended step] (highest priority)
+2. [Another unblocked step]
+3. [Another unblocked step]
+4. Something else (describe what you want to work on)
+
+Wait for the user's choice before proceeding. Once they choose, dive into the work immediately.
 `,
     },
     {
         name: 'brain-wrap-up.md',
-        content: `# Wrap Up Session
+        content: `# Wrap Up Brain Session
+
+You are closing out a work session on the user's BrainTree brain. This is one of the most important commands because it ensures continuity between sessions. A good wrap-up means the next /brain-resume will be seamless. A bad one means lost context and wasted time.
+
+Your job: audit everything that happened, update the brain to reflect reality, and create a comprehensive handoff.
+
+## Step 1: Audit the Session
+
+Before writing anything, figure out what happened this session:
+
+1. Review your conversation history to identify:
+   - Files that were created or modified (in the brain or in the codebase)
+   - Steps from the execution plan that progressed or completed
+   - Decisions that were made and their rationale
+   - Blockers that were discovered
+   - Ideas or insights that came up
+   - Any context the user shared that should be preserved
+
+2. Use \`list_departments()\` to identify which departments/areas of the brain were touched.
+
+## Step 2: Update Department Files
+
+For each department/area that was touched during the session:
+
+1. Use \`read_file()\` to read the department's index or relevant content files.
+2. Use \`write_file()\` to update those files with:
+   - New content created during the session (e.g., if you wrote marketing copy, save it to the Marketing folder)
+   - Updated status information
+   - New wikilinks to newly created files
+   - Notes on decisions or changes made
+
+Be thorough. If the session involved work across multiple areas (e.g., frontend code + marketing content + infrastructure setup), update ALL relevant files in the brain.
+
+Examples:
+- Built a landing page? Update RnD/Frontend/ with component details and Marketing/ with copy/messaging.
+- Wrote social media content for 5 platforms? Create or update files in Marketing/Content/ for each platform.
+- Set up CI/CD? Update RnD/Infrastructure/ or Runbooks/ with the pipeline details.
+- Had a strategy discussion? Update Product/Strategy/ or Business/ with the decisions.
+
+## Step 3: Update Execution Plan
+
+Use \`get_execution_plan()\` to see the current plan, then for each step that progressed:
+
+- Use \`update_step(step_id, "completed")\` for finished steps. Include a brief note of what was done in the tasks field.
+- Use \`update_step(step_id, "in_progress")\` for steps that were started but not finished. Include what remains in the tasks field.
+- Use \`update_step(step_id, "blocked", "reason")\` for steps that hit a blocker.
+
+## Step 4: Create Handoff
+
+Use \`create_handoff()\` with a comprehensive handoff. The content MUST include all of these sections:
+
+### Summary
+A 2-3 sentence overview of the session.
+
+### What Was Done
+Bullet list of concrete accomplishments:
+- Files created/modified (with paths)
+- Features built or content created
+- Configurations changed
+- Issues resolved
+
+### Decisions Made
+Document any decisions and their rationale. Future sessions need to know WHY things were done a certain way.
+
+### Blockers and Open Questions
+Anything unresolved that the next session needs to address.
+
+### Recommended Next Steps
+Specific, actionable items for the next session. Ordered by priority. Include which files to read first and which execution plan steps to tackle.
+
+### Files to Read on Resume
+List the 3-5 most important files the next session should read to get up to speed quickly.
+
+## Step 5: Update BRAIN-INDEX
+
+Use \`read_file()\` on BRAIN-INDEX.md, then \`write_file()\` to:
+- Add a session log entry (Session N: [date] - [brief summary])
+- Update any department status indicators if they changed
+- Update progress percentage if applicable
 
-End your work session and create a handoff using BrainTree MCP tools.
+## Step 6: Present Summary
 
-## Steps
+Show the user a clean summary:
+- Session number and duration
+- Key accomplishments (bullet list)
+- Brain files updated (count and list)
+- Execution plan progress (before and after)
+- What to do next session
 
-1. Summarize what was done this session
-2. Use MCP \`update_step\` to mark completed steps
-3. Use MCP \`create_handoff\` with session summary
-4. List recommended next steps
+End with: "Your brain is up to date. Run /brain-resume next time to pick up right where you left off."
 `,
     },
     {
         name: 'brain-status.md',
-        content: `# Project Status
+        content: `# Brain Status Dashboard
 
-Check overall project progress using BrainTree MCP tools.
+Generate a comprehensive status dashboard for the user's BrainTree brain. This should feel like opening a project dashboard, giving an instant, visual overview of everything.
 
-## Steps
+## Step 1: Gather Data
 
-1. Use MCP \`get_execution_plan\` for phase progress
-2. Use MCP \`list_departments\` for department overview
-3. Use MCP \`list_handoffs\` for recent session history
-4. Present dashboard with progress bars and stats
+Run all of these MCP calls to collect the full picture:
+
+1. \`get_execution_plan()\` for phase-by-phase progress
+2. \`list_departments()\` for department structure and file counts
+3. \`list_handoffs()\` for session history
+4. \`get_graph()\` for the knowledge graph stats (nodes, edges, connectivity)
+
+## Step 2: Present the Dashboard
+
+Format the output as a rich ASCII dashboard. Include all of these sections:
+
+### Execution Plan Progress
+Show each phase with an ASCII progress bar and step counts:
+\`\`\`
+Phase 0: Foundation    [==========] 100%  (5/5 steps done)
+Phase 1: Core Build    [======----]  60%  (6/10 steps done)
+Phase 2: Launch Prep   [==--------]  20%  (2/10 steps done)
+Phase 3: Post-Launch   [----------]   0%  (0/8 steps done)
+
+Overall: [=====-----] 39% complete (13/33 steps)
+\`\`\`
+
+### Currently In Progress
+List any steps with status "in_progress":
+- Step X.Y: Title (started Session N)
+
+### Blocked Steps
+List any steps with status "blocked" and their blockers.
+
+### Unblocked and Ready
+List steps that can be started right now (from \`list_unblocked_steps()\`).
+
+### Department Overview
+Show each department with file count and a brief status:
+\`\`\`
+Department          Files  Status
+00_Company          4      Healthy
+01_RnD              12     Active (last updated Session 5)
+02_Product          3      Needs attention
+03_Marketing        0      Empty
+...
+\`\`\`
+
+### Knowledge Graph Stats
+From the graph data:
+- Total nodes (files)
+- Total edges (wikilinks)
+- Average connections per file
+- Orphan files (no incoming or outgoing links)
+- Most connected files (top 3)
+
+### Session Timeline
+Show the last 5 sessions from handoffs:
+\`\`\`
+Session 5  (2025-01-15)  Built authentication flow
+Session 4  (2025-01-14)  Set up database schema
+Session 3  (2025-01-13)  Designed landing page
+...
+\`\`\`
+
+### Recommendations
+Based on the data, suggest 1-2 actions:
+- If there are orphan files, suggest linking them
+- If a department is empty, suggest populating it
+- If progress has stalled on a phase, highlight the blocking steps
+- If the user has not had a session recently, welcome them back
 `,
     },
     {
         name: 'brain-plan.md',
-        content: `# Plan Step
+        content: `# Plan a Brain Step
+
+Help the user plan the implementation of a specific execution plan step. This command breaks a high-level step into concrete, actionable tasks and prepares everything needed to execute.
+
+## Step 1: Identify the Step
+
+If the user specified a step (e.g., "/brain-plan 2.3"), use that. Otherwise:
+
+1. Use \`get_execution_plan()\` to show available steps.
+2. Use \`list_unblocked_steps()\` to highlight which ones are ready.
+3. Ask the user which step they want to plan. Present as a numbered list of unblocked steps.
+
+Wait for the user to choose before proceeding.
+
+## Step 2: Gather Context
+
+Once the step is identified:
+
+1. Use \`get_execution_plan()\` to get the step's full details: title, description, dependencies, and current status.
+2. Use \`list_departments()\` to see which departments are relevant.
+3. Use \`read_file()\` on 2-4 relevant brain files that provide context for this step. For example:
+   - The department index for the area this step belongs to
+   - Any existing specs or plans related to this step
+   - The BRAIN-INDEX for overall context
+4. If the step has dependencies, use \`read_file()\` on files related to completed prerequisite steps to understand what has already been built.
+
+## Step 3: Create the Plan
+
+Break the step down into concrete implementation tasks. For each task:
+
+1. **Title**: What needs to be done (one sentence)
+2. **Details**: How to do it (specific files to create/modify, tools to use, acceptance criteria)
+3. **Effort**: Small (< 30 min) / Medium (30-90 min) / Large (> 90 min)
+4. **Order**: Which tasks depend on others
+
+Present the plan as a numbered checklist the user can review.
+
+## Step 4: Save the Plan
 
-Plan implementation for a specific execution plan step using BrainTree MCP tools.
+1. Use \`write_file()\` to save the plan to the appropriate department folder in the brain. Name the file clearly (e.g., \`01_RnD/Plan-Step-2.3-Auth-System.md\`).
+2. Use \`update_step(step_id, "in_progress")\` to mark the step as started. Include the task breakdown in the tasks field.
+3. If the plan references any existing brain files, use \`write_file()\` to add wikilinks back to the plan file from those files.
 
-## Steps
+## Step 5: Guide Execution
 
-1. Use MCP \`get_execution_plan\` to get the step details
-2. Use MCP \`read_file\` to read relevant vault files
-3. Break down the step into concrete implementation tasks
-4. Use MCP \`update_step\` to set status to in_progress
+Ask the user if they want to start executing the plan now. If yes:
+- Start with the first task
+- Work through them sequentially (or suggest parallel execution if tasks are independent)
+- After each task, check it off and move to the next
+
+If no, confirm the plan is saved and they can come back to it later.
 `,
     },
     {
         name: 'brain-sprint.md',
-        content: `# Sprint Planning
+        content: `# Brain Sprint Planning
+
+Help the user plan their week's work by organizing unblocked steps into a focused sprint. This brings structured agile-style planning to the brain.
+
+## Step 1: Gather Current State
+
+1. Use \`list_unblocked_steps()\` to find all steps that are ready to work on.
+2. Use \`get_execution_plan()\` to get full context on each step and the overall plan.
+3. Use \`get_latest_handoff()\` to see where the last session left off and what was recommended.
+4. Use \`list_departments()\` to understand which areas of the brain are active.
+
+## Step 2: Analyze and Group
+
+For each unblocked step, determine:
+- **Effort estimate**: S (1-2 hours), M (half day), L (full day), XL (multi-day)
+- **Priority**: Critical (blocks many things), High (on the main path), Medium (nice to have), Low (can wait)
+- **Parallel group**: Which steps can run simultaneously without conflicts
+
+Group the steps into logical work blocks.
+
+## Step 3: Propose the Sprint
+
+Present a sprint plan for the week. Format it clearly:
+
+\`\`\`
+SPRINT PLAN: Week of [date]
+
+Goal: [One sentence describing the sprint objective]
+
+Day 1-2: [Theme]
+  [ ] Step X.Y: Title (effort: M, priority: Critical)
+  [ ] Step X.Z: Title (effort: S, priority: High)
+      ^ Can run in parallel with X.Y
+
+Day 3-4: [Theme]
+  [ ] Step A.B: Title (effort: L, priority: High)
+      Depends on: Step X.Y completion
 
-Plan the week's work using BrainTree MCP tools.
+Day 5: [Theme / Buffer]
+  [ ] Step C.D: Title (effort: S, priority: Medium)
+  [ ] Buffer time for overflow or unexpected work
 
-## Steps
+Total effort: ~X steps across N parallel groups
+\`\`\`
 
-1. Use MCP \`list_unblocked_steps\` to find available work
-2. Use MCP \`get_execution_plan\` for context
-3. Group steps by parallel opportunity
-4. Assign priorities and estimate effort
+Include:
+- A clear sprint goal (what will be true at the end of the week)
+- Logical grouping by theme or dependency
+- Parallel execution opportunities highlighted
+- Buffer time for unexpected work
+
+## Step 4: Confirm and Save
+
+Ask the user to review and adjust:
+- "Would you like to add, remove, or reprioritize any steps?"
+- "Is this the right amount of work for the week?"
+
+Once confirmed:
+1. Use \`write_file()\` to save the sprint plan to the brain (e.g., \`Execution-Plan-Sprint-[date].md\` or in an appropriate folder).
+2. Summarize the sprint and wish the user a productive week.
+3. Suggest starting with "/brain-plan [first step]" to plan the first task in detail.
 `,
     },
     {
         name: 'brain-sync.md',
-        content: `# Vault Sync
+        content: `# Brain Sync
+
+Audit and synchronize the brain's content to ensure everything is consistent, connected, and up to date. Think of this as a health check for the knowledge graph.
+
+## Step 1: Full Inventory
+
+1. Use \`list_files()\` to get a complete list of all files in the brain.
+2. Use \`list_departments()\` to see the expected structure.
+3. Use \`get_graph()\` to get the full node and edge map (files and their wikilink connections).
+4. Use \`get_execution_plan()\` to check plan state.
+
+## Step 2: Identify Issues
+
+Analyze the data to find problems:
+
+### Orphan Files
+Files with no incoming or outgoing wikilinks. These are disconnected from the knowledge graph.
+- List each orphan file
+- Suggest which files should link to it
+
+### Broken Wikilinks
+Wikilinks that point to files that do not exist.
+- List each broken link and which file contains it
+- Suggest creating the missing file or fixing the link
+
+### Empty Departments
+Folders/departments that exist in the structure but have no content files (only an index).
+- List each empty department
+- Suggest whether it should be populated or removed
+
+### Stale Content
+Use \`read_file()\` on a sample of files to check if content is outdated:
+- Files that reference steps marked as "not_started" that are actually completed
+- Files with placeholder text ("TODO", "TBD", "Coming soon")
+- Index files that do not reflect the actual files in their folder
 
-Sync vault files with the latest project state using BrainTree MCP tools.
+### Execution Plan Drift
+Compare the execution plan status with reality:
+- Steps marked "in_progress" that may have been completed (based on handoff history)
+- Steps marked "not_started" that have related content already created
 
-## Steps
+## Step 3: Fix Issues
 
-1. Use MCP \`list_files\` to see current vault contents
-2. Use MCP \`list_departments\` for department overview
-3. Update any stale files using MCP \`write_file\`
-4. Verify wikilinks are consistent using MCP \`get_graph\`
+For each issue found, take action:
+
+1. **Orphan files**: Use \`write_file()\` to add wikilinks from relevant files to connect the orphan.
+2. **Broken links**: Use \`write_file()\` to either create the missing target file or fix the link in the source file.
+3. **Empty departments**: Ask the user if they want to seed content or remove the folder.
+4. **Stale content**: Use \`write_file()\` to update outdated files with current information.
+5. **Plan drift**: Use \`update_step()\` to correct any mismatched statuses.
+
+Ask before making destructive changes (removing files or departments). Additive changes (adding links, creating missing files) can be done directly.
+
+## Step 4: Report
+
+Present a sync report:
+
+\`\`\`
+BRAIN SYNC REPORT
+
+Files scanned:    45
+Issues found:     7
+Issues fixed:     5
+Issues remaining: 2 (need user input)
+
+Orphan files:      2 found, 2 linked
+Broken wikilinks:  3 found, 3 fixed
+Empty departments: 1 found (user to decide)
+Stale content:     1 found, 0 fixed (need user input)
+Plan drift:        0 found
+
+Graph health: Good
+  Nodes: 45  |  Edges: 78  |  Avg connections: 3.5
+\`\`\`
+
+Use \`search_content()\` to verify that key terms (project name, product name, key concepts) are consistent across files.
 `,
     },
     {
         name: 'brain-feature.md',
-        content: `# New Feature
+        content: `# Brain Feature Planning
+
+Help the user plan and track a new feature from idea through implementation using the brain as the source of truth.
+
+## Step 1: Understand the Feature
+
+Ask the user to describe the feature they want to build or add. Get:
+- What it does (user-facing behavior)
+- Why it matters (business/product value)
+- Any technical constraints or preferences
+
+If the user gave a description with the command (e.g., "/brain-feature add dark mode"), use that as the starting point and ask clarifying questions only if needed.
+
+## Step 2: Research Existing Context
+
+Search the brain for anything related:
+
+1. Use \`search_content(query)\` with keywords from the feature description to find related files.
+2. Use \`read_file()\` on the top 3-5 results to understand existing context.
+3. Use \`get_execution_plan()\` to see if this feature maps to an existing step or is entirely new.
+4. Use \`get_backlinks()\` on any relevant files to discover connected context.
+
+Summarize what you found: "Here is what your brain already knows about this area: [summary]. This feature [overlaps with / is independent of] existing work."
+
+## Step 3: Create Feature Spec
+
+Use \`write_file()\` to create a feature spec in the appropriate brain folder (e.g., \`02_Product/Features/Feature-Dark-Mode.md\` or \`Ideas/Feature-Trading-Alerts.md\`).
+
+The spec should include:
+- **Title**: Feature name
+- **Status**: Planning
+- **Summary**: One paragraph description
+- **Motivation**: Why this feature matters
+- **User Stories**: 2-3 key user stories or use cases
+- **Requirements**: Specific, testable requirements
+- **Technical Approach**: High-level implementation plan
+- **Dependencies**: What this feature depends on
+- **Open Questions**: Anything still unclear
+- **Related Files**: Wikilinks to related brain files
+
+## Step 4: Update the Brain
+
+1. If the feature maps to an existing execution plan step, use \`update_step()\` to mark it as in_progress.
+2. If it is a new feature not in the plan, ask the user if they want to add it to the execution plan.
+3. Use \`read_file()\` on the relevant department index, then \`write_file()\` to add a wikilink to the new feature spec.
+4. Use \`read_file()\` on BRAIN-INDEX.md, then \`write_file()\` to add the feature to any relevant sections.
+
+## Step 5: Guide Implementation
+
+Ask the user if they want to start implementing now. If yes:
+
+1. Break the feature into implementation tasks (from the spec's technical approach).
+2. Work through each task, using the brain files for reference.
+3. After completing significant parts, use \`write_file()\` to update the feature spec's status and add implementation notes.
 
-Plan and implement a new feature using BrainTree MCP tools.
+If no, confirm the spec is saved and suggest next steps: "The feature spec is saved at [path]. You can come back to it anytime. I would suggest tackling this in your next sprint."
 
-## Steps
+## Step 6: Wrap Up
 
-1. Use MCP \`read_file\` to read relevant existing files
-2. Create a feature spec using MCP \`write_file\`
-3. Update execution plan using MCP \`update_step\`
-4. Implement the feature
-5. Create handoff using MCP \`create_handoff\`
+When the feature work is done (or paused):
+1. Use \`write_file()\` to update the feature spec with current status and any implementation notes.
+2. If applicable, use \`update_step()\` to update the execution plan.
+3. Use \`create_handoff()\` to log the feature work in the session handoff.
 `,
     },
 ];
@@ -239,7 +1046,7 @@ export async function initCommand(options) {
     console.log();
     console.log('  Next steps:');
     console.log('    1. Open Claude Code in your project directory');
-    console.log('    2. Type /init-vault to create your brain');
+    console.log('    2. Type /init-brain to create your brain');
     console.log('    3. Start building with AI-powered project management');
     console.log();
 }

package/dist/commands/init.js.map

@@ -1 +1 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brain-tree-ai",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CLI to set up BrainTree (brain-tree.ai) for Claude Code — AI-native project management",
   "type": "module",
   "main": "dist/index.js",