@girardmedia/bootspring 2.0.8 → 2.0.10

package/cli/build.js

@@ -341,7 +341,7 @@ function generateTaskPrompt(task, projectRoot) {
   lines.push('');
 
   if (task.description) {
-    lines.push(`**Description:**`);
+    lines.push('**Description:**');
     lines.push(task.description);
     lines.push('');
   }
@@ -363,7 +363,7 @@ function generateTaskPrompt(task, projectRoot) {
   lines.push('1. Implement the task as described above');
   lines.push('2. Ensure all acceptance criteria are met');
   lines.push('3. Test your implementation');
-  lines.push(`4. When done, run: bootspring build done`);
+  lines.push('4. When done, run: bootspring build done');
 
   return lines.join('\n');
 }

package/cli/generate.js

@@ -11,6 +11,7 @@ const config = require('../core/config');
 const context = require('../core/context');
 const utils = require('../core/utils');
 const gitMemory = require('../intelligence/git-memory');
+const agentsTemplate = require('../generators/templates/agents.template');
 
 /**
  * Generate CLAUDE.md content from config and project state
@@ -283,6 +284,17 @@ ${utils.COLORS.bold}Score:${utils.COLORS.reset} ${validation.score}/${validation
       utils.writeFile(todoPath, todoContent);
       todoSpinner.succeed('Generated todo.md');
     }
+
+    // Generate AGENTS.md for multi-tool compatibility
+    const agentsPath = path.join(cfg._projectRoot, 'AGENTS.md');
+    const agentsSpinner = utils.createSpinner('Generating AGENTS.md').start();
+    try {
+      const agentsContent = agentsTemplate.generate(cfg);
+      utils.writeFile(agentsPath, agentsContent);
+      agentsSpinner.succeed('Generated AGENTS.md (Codex, Cursor, Amp, Kilo)');
+    } catch (error) {
+      agentsSpinner.fail(`Failed to generate AGENTS.md: ${error.message}`);
+    }
   }
 
   console.log(`

package/cli/seed.js

@@ -25,6 +25,8 @@ const config = require('../core/config');
 const utils = require('../core/utils');
 const { runQuestionnaire } = require('../generators/questionnaire');
 const seedTemplate = require('../generators/templates/seed.template');
+const claudeTemplate = require('../generators/templates/claude.template');
+const agentsTemplate = require('../generators/templates/agents.template');
 const scaffold = require('../core/scaffold');
 const projectState = require('../core/project-state');
 const checkpointEngine = require('../core/checkpoint-engine');
@@ -39,6 +41,79 @@ function getIngest() {
   return ingest;
 }
 
+/**
+ * Generate AI context files (CLAUDE.md and AGENTS.md)
+ * @param {string} projectRoot - Project root path
+ * @param {object} scaffoldConfig - Configuration object
+ * @returns {object} Results of generation
+ */
+function generateAIContextFiles(projectRoot, scaffoldConfig) {
+  const results = { claudeMd: false, agentsMd: false, planningAgentsMd: false };
+
+  // Build a config object suitable for the templates
+  const cfg = {
+    project: {
+      name: scaffoldConfig.project?.name || 'My Project',
+      description: scaffoldConfig.project?.description || '',
+      version: scaffoldConfig.project?.version || '0.1.0',
+      status: 'development'
+    },
+    stack: scaffoldConfig.stack || {
+      framework: 'nextjs',
+      language: 'typescript',
+      database: 'postgresql',
+      hosting: 'vercel'
+    },
+    frontend: scaffoldConfig.frontend || {
+      uiLibrary: 'shadcn',
+      styling: 'tailwind'
+    },
+    backend: scaffoldConfig.backend || {
+      orm: 'prisma',
+      auth: 'clerk'
+    },
+    plugins: scaffoldConfig.plugins || {},
+    instructions: scaffoldConfig.instructions || {},
+    workflow: scaffoldConfig.workflow || {},
+    business: scaffoldConfig.business || {}
+  };
+
+  // Generate CLAUDE.md
+  try {
+    const claudePath = path.join(projectRoot, 'CLAUDE.md');
+    const claudeContent = claudeTemplate.generate(cfg);
+    fs.writeFileSync(claudePath, claudeContent);
+    results.claudeMd = true;
+  } catch (error) {
+    utils.print.debug(`Failed to generate CLAUDE.md: ${error.message}`);
+  }
+
+  // Generate AGENTS.md (root level)
+  try {
+    const agentsPath = path.join(projectRoot, 'AGENTS.md');
+    const agentsContent = agentsTemplate.generate(cfg);
+    fs.writeFileSync(agentsPath, agentsContent);
+    results.agentsMd = true;
+  } catch (error) {
+    utils.print.debug(`Failed to generate AGENTS.md: ${error.message}`);
+  }
+
+  // Generate planning/AGENTS.md if planning folder exists
+  const planningDir = path.join(projectRoot, 'planning');
+  if (fs.existsSync(planningDir)) {
+    try {
+      const planningAgentsPath = path.join(planningDir, 'AGENTS.md');
+      const planningAgentsContent = agentsTemplate.generatePlanningAgents(cfg);
+      fs.writeFileSync(planningAgentsPath, planningAgentsContent);
+      results.planningAgentsMd = true;
+    } catch (error) {
+      utils.print.debug(`Failed to generate planning/AGENTS.md: ${error.message}`);
+    }
+  }
+
+  return results;
+}
+
 /**
  * Seed folder structure
  */
@@ -382,9 +457,27 @@ ${utils.COLORS.dim}Interactive project configuration${utils.COLORS.reset}
       utils.print.debug(`Auto-tagging failed: ${err.message}`);
     }
 
+    // Generate AI context files
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, projectConfig);
+    const aiFilesGenerated = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
     console.log(`
 ${utils.COLORS.green}${utils.COLORS.bold}✓ Seed initialized successfully!${utils.COLORS.reset}
 
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset}             - Project specification
+  ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset} - Configuration
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}           - Claude Code context
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}           - Codex/Cursor/Amp context
+
 ${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
   1. Review ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} for your project configuration
   2. Run ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset} to generate project structure
@@ -549,13 +642,33 @@ ${utils.COLORS.bold}Available presets:${utils.COLORS.reset}`);
       }
     }
 
+    // Generate AI context files (CLAUDE.md and AGENTS.md)
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, scaffoldConfig);
+
+    const aiFilesGenerated = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiResults.planningAgentsMd) aiFilesGenerated.push('planning/AGENTS.md');
+
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
     console.log(`
 ${utils.COLORS.green}${utils.COLORS.bold}✓ Scaffold complete!${utils.COLORS.reset}
 
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}  - Context for Claude Code
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}  - Context for Codex, Cursor, Amp, Kilo
+
 ${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
   1. Run ${utils.COLORS.cyan}npm install${utils.COLORS.reset} to install dependencies
   2. Copy ${utils.COLORS.cyan}.env.example${utils.COLORS.reset} to ${utils.COLORS.cyan}.env.local${utils.COLORS.reset}
   3. Run ${utils.COLORS.cyan}npm run dev${utils.COLORS.reset} to start development
+  4. Run ${utils.COLORS.cyan}bootspring build${utils.COLORS.reset} to start building tasks
 `);
   } catch (error) {
     spinner.fail(`Scaffold failed: ${error.message}`);
@@ -807,15 +920,73 @@ ${utils.COLORS.dim}Create SEED.md from your preseed documents${utils.COLORS.rese
     fs.writeFileSync(seedPath, seedContent);
     spinner.succeed('Created SEED.md');
 
+    // Extract tech stack for AI context files
+    const techStack = extractTechStack(docs);
+    const projectName = extractProjectName(docs) || preseedConfig.identity?.name || 'My Project';
+    const tagline = extractTagline(docs) || '';
+
+    const synthConfig = {
+      project: {
+        name: projectName,
+        description: tagline,
+        version: '0.1.0',
+        status: 'development'
+      },
+      stack: {
+        framework: techStack.framework,
+        language: techStack.language,
+        database: techStack.database,
+        hosting: techStack.hosting
+      },
+      frontend: {
+        uiLibrary: techStack.uiLibrary,
+        styling: techStack.styling
+      },
+      backend: {
+        orm: techStack.orm,
+        auth: techStack.auth
+      }
+    };
+
+    // Generate AI context files
+    const aiSpinner = utils.createSpinner('Generating AI context files...').start();
+    const aiResults = generateAIContextFiles(projectRoot, synthConfig);
+    const aiFilesGenerated = [];
+    if (aiResults.claudeMd) aiFilesGenerated.push('CLAUDE.md');
+    if (aiResults.agentsMd) aiFilesGenerated.push('AGENTS.md');
+    if (aiFilesGenerated.length > 0) {
+      aiSpinner.succeed(`Generated ${aiFilesGenerated.join(', ')}`);
+    } else {
+      aiSpinner.warn('Could not generate AI context files');
+    }
+
+    // Also create bootspring.config.js for CLI compatibility
+    const configPath = path.join(projectRoot, 'bootspring.config.js');
+    if (!fs.existsSync(configPath)) {
+      const configSpinner = utils.createSpinner('Creating bootspring.config.js...').start();
+      if (config.save(synthConfig, configPath)) {
+        configSpinner.succeed('Created bootspring.config.js');
+      } else {
+        configSpinner.warn('Could not create bootspring.config.js');
+      }
+    }
+
     console.log(`
 ${utils.COLORS.green}${utils.COLORS.bold}✓ SEED.md synthesized successfully!${utils.COLORS.reset}
 
 ${utils.COLORS.bold}Extracted from:${utils.COLORS.reset}
 ${preseedFiles.map(f => `  • ${f}`).join('\n')}
 
+${utils.COLORS.bold}Generated Files:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset}             - Project specification
+  ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset} - Configuration
+  ${utils.COLORS.cyan}CLAUDE.md${utils.COLORS.reset}           - Claude Code context
+  ${utils.COLORS.cyan}AGENTS.md${utils.COLORS.reset}           - Codex/Cursor/Amp context
+
 ${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
   1. Review ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} - your project spec is ready
   2. Run ${utils.COLORS.cyan}bootspring seed scaffold --preset=nextjs${utils.COLORS.reset} to generate project
+  3. Or run ${utils.COLORS.cyan}bootspring build${utils.COLORS.reset} to start building tasks
 `);
   } catch (error) {
     spinner.fail(`Synthesis failed: ${error.message}`);

package/generators/templates/agents.template.js

@@ -0,0 +1,192 @@
+/**
+ * AGENTS.md Template Generator
+ *
+ * Generates AGENTS.md following the open standard for AI coding agents.
+ * Supported by: OpenAI Codex, Cursor, Amp, Jules (Google), Factory, Kilo Code
+ *
+ * Best practices from https://github.blog/ai-and-ml/github-copilot/how-to-write-a-great-agents-md-lessons-from-over-2500-repositories/
+ *
+ * @package bootspring
+ * @module generators/templates/agents
+ */
+
+/**
+ * Generate root AGENTS.md content from config
+ */
+function generate(config) {
+  const sections = [];
+
+  // Persona - Be specific, not vague
+  sections.push(`# ${config.project.name}`);
+  sections.push('');
+  sections.push(`You are a senior full-stack developer working on ${config.project.name}, a ${formatFramework(config.stack.framework)} application with ${config.stack.language}.`);
+  sections.push('');
+
+  // Commands - Put early
+  sections.push('## Commands');
+  sections.push('');
+  sections.push('```bash');
+  sections.push('# Development');
+  sections.push('npm run dev');
+  sections.push('');
+  sections.push('# Quality checks (run before committing)');
+  sections.push('npm run lint');
+  sections.push('npm run test');
+  sections.push('npm run typecheck');
+  sections.push('');
+  sections.push('# Build tasks');
+  sections.push('bootspring build next    # Get next task');
+  sections.push('bootspring build done    # Mark task complete');
+  sections.push('bootspring build status  # Check progress');
+  sections.push('```');
+  sections.push('');
+
+  // Task System
+  sections.push('## Task System');
+  sections.push('');
+  sections.push('This project uses Bootspring for autonomous task management.');
+  sections.push('');
+  sections.push('1. Check `planning/CURRENT_TASK.md` for the current task');
+  sections.push('2. Implement the task following acceptance criteria');
+  sections.push('3. Run quality checks');
+  sections.push('4. Commit changes');
+  sections.push('5. Run `bootspring build done` to get the next task');
+  sections.push('');
+
+  // Stack - Be specific about versions
+  sections.push('## Stack');
+  sections.push('');
+  sections.push(`- **Framework**: ${formatFramework(config.stack.framework)}`);
+  sections.push(`- **Language**: ${config.stack.language}`);
+  if (config.stack.database !== 'none') {
+    sections.push(`- **Database**: ${config.stack.database}`);
+    if (config.stack.orm) {
+      sections.push(`- **ORM**: ${config.stack.orm}`);
+    }
+  }
+  sections.push('');
+
+  // Code Style
+  sections.push('## Code Style');
+  sections.push('');
+  if (config.stack.framework === 'nextjs') {
+    sections.push('- Use Server Components by default');
+    sections.push('- Use Server Actions for mutations (not API routes)');
+  }
+  sections.push('- Use Zod for input validation');
+  sections.push('- Keep files under 300 lines');
+  sections.push('- Use meaningful variable and function names');
+  sections.push('- Follow existing patterns in the codebase');
+  sections.push('');
+
+  // Git Workflow
+  sections.push('## Git Workflow');
+  sections.push('');
+  sections.push('- Conventional commits: `feat:`, `fix:`, `docs:`, `refactor:`');
+  sections.push('- Atomic commits - one logical change per commit');
+  sections.push('- Run quality checks before committing');
+  sections.push('- Never force push to main');
+  sections.push('');
+
+  // Boundaries - Critical
+  sections.push('## Boundaries');
+  sections.push('');
+  sections.push('**Never:**');
+  sections.push('- Commit secrets, API keys, or credentials');
+  sections.push('- Modify `.env` files with real values');
+  sections.push('- Delete or overwrite migration files');
+  sections.push('- Skip tests to make code compile');
+  sections.push('- Introduce breaking changes without discussion');
+  sections.push('');
+  sections.push('**Always:**');
+  sections.push('- Read existing code before modifying');
+  sections.push('- Run tests after changes');
+  sections.push('- Check for TypeScript errors');
+  sections.push('- Follow the acceptance criteria exactly');
+  sections.push('');
+
+  // Testing
+  sections.push('## Testing');
+  sections.push('');
+  sections.push('- Write tests for new features');
+  sections.push('- Ensure existing tests still pass');
+  sections.push('- Test edge cases and error conditions');
+  sections.push('');
+
+  return sections.join('\n');
+}
+
+/**
+ * Generate planning-specific AGENTS.md for the planning directory
+ */
+function generatePlanningAgents(_config) {
+  const sections = [];
+
+  sections.push('# Planning Directory');
+  sections.push('');
+  sections.push('You are working on build tasks for the MVP. This directory contains build planning files.');
+  sections.push('');
+
+  sections.push('## Current Task');
+  sections.push('');
+  sections.push('Read `CURRENT_TASK.md` for the task you should implement now.');
+  sections.push('');
+
+  sections.push('## Commands');
+  sections.push('');
+  sections.push('```bash');
+  sections.push('bootspring build done    # Mark task complete, get next');
+  sections.push('bootspring build skip    # Skip task, get next');
+  sections.push('bootspring build status  # View progress');
+  sections.push('```');
+  sections.push('');
+
+  sections.push('## Files');
+  sections.push('');
+  sections.push('| File | Purpose |');
+  sections.push('|------|---------|');
+  sections.push('| `CURRENT_TASK.md` | Task to implement now |');
+  sections.push('| `TODO.md` | Full task checklist |');
+  sections.push('| `BUILD_STATE.json` | Build state (do not edit) |');
+  sections.push('| `IMPLEMENTATION_QUEUE.md` | Ordered task queue |');
+  sections.push('| `CONTEXT.md` | Build context summary |');
+  sections.push('');
+
+  sections.push('## Workflow');
+  sections.push('');
+  sections.push('1. Read `CURRENT_TASK.md`');
+  sections.push('2. Implement in the main codebase (not here)');
+  sections.push('3. Ensure acceptance criteria met');
+  sections.push('4. Run `npm run lint && npm run test`');
+  sections.push('5. Commit changes');
+  sections.push('6. Run `bootspring build done`');
+  sections.push('');
+
+  sections.push('## Boundaries');
+  sections.push('');
+  sections.push('- Do NOT edit `BUILD_STATE.json` directly');
+  sections.push('- Do NOT skip quality checks');
+  sections.push('- Do NOT work on multiple tasks at once');
+  sections.push('');
+
+  return sections.join('\n');
+}
+
+// Helper functions
+function formatFramework(framework) {
+  const names = {
+    'nextjs': 'Next.js 14+ (App Router)',
+    'remix': 'Remix',
+    'nuxt': 'Nuxt 3',
+    'sveltekit': 'SvelteKit',
+    'express': 'Express.js',
+    'fastify': 'Fastify',
+    'hono': 'Hono'
+  };
+  return names[framework] || framework;
+}
+
+module.exports = {
+  generate,
+  generatePlanningAgents
+};

package/generators/templates/build-planning.template.js

@@ -56,9 +56,72 @@ function generateAll(projectRoot, docs, tasks, options = {}) {
   fs.writeFileSync(contextPath, context);
   files.context = contextPath;
 
+  // Generate planning/AGENTS.md for AI coding agents
+  const agentsContent = generatePlanningAgents(options);
+  const agentsPath = path.join(planningDir, 'AGENTS.md');
+  fs.writeFileSync(agentsPath, agentsContent);
+  files.agents = agentsPath;
+
   return files;
 }
 
+/**
+ * Generate AGENTS.md for the planning directory
+ * Following the open standard for AI coding agents
+ */
+function generatePlanningAgents(options = {}) {
+  const projectName = options.projectName || 'Project';
+
+  return `# Planning Directory
+
+You are working on build tasks for ${projectName}. This directory contains build planning files.
+
+## Commands
+
+\`\`\`bash
+bootspring build done    # Mark task complete, get next
+bootspring build skip    # Skip current task
+bootspring build status  # View progress
+\`\`\`
+
+## Current Task
+
+Read \`CURRENT_TASK.md\` for the task you should implement now.
+
+## Workflow
+
+1. Read \`CURRENT_TASK.md\`
+2. Implement in the main codebase (not in this folder)
+3. Ensure acceptance criteria are met
+4. Run quality checks: \`npm run lint && npm run test\`
+5. Commit your changes
+6. Run \`bootspring build done\`
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| \`CURRENT_TASK.md\` | Task to implement now |
+| \`TODO.md\` | Full task checklist |
+| \`BUILD_STATE.json\` | Build state (do not edit directly) |
+| \`IMPLEMENTATION_QUEUE.md\` | Ordered task queue |
+| \`CONTEXT.md\` | Build context summary |
+
+## Boundaries
+
+**Never:**
+- Edit \`BUILD_STATE.json\` directly
+- Skip quality checks
+- Work on multiple tasks simultaneously
+- Implement tasks in this planning folder
+
+**Always:**
+- Follow acceptance criteria exactly
+- Run tests before marking complete
+- Commit with conventional commit format
+`;
+}
+
 /**
  * Generate MASTER_PLAN.md
  * @param {object} docs - Source documents

package/generators/templates/claude.template.js

@@ -160,6 +160,36 @@ function generate(config) {
     sections.push('');
   }
 
+  // Autonomous Build System
+  sections.push('## Autonomous Build System');
+  sections.push('');
+  sections.push('Bootspring manages an autonomous task queue for building your MVP.');
+  sections.push('');
+  sections.push('### Check for Tasks');
+  sections.push('');
+  sections.push('If `planning/CURRENT_TASK.md` exists, read it and implement the task.');
+  sections.push('When complete, run `bootspring build done` to get the next task.');
+  sections.push('');
+  sections.push('### MCP Commands (Claude Code)');
+  sections.push('');
+  sections.push('```');
+  sections.push('bootspring_build action=next      # Get next task');
+  sections.push('bootspring_build action=done      # Mark complete, get next');
+  sections.push('bootspring_build action=status    # Check progress');
+  sections.push('```');
+  sections.push('');
+  sections.push('### CLI Commands (Terminal)');
+  sections.push('');
+  sections.push('```bash');
+  sections.push('bootspring build              # Interactive menu');
+  sections.push('bootspring build next         # Get next task');
+  sections.push('bootspring build done         # Mark complete');
+  sections.push('bootspring build status       # Check progress');
+  sections.push('```');
+  sections.push('');
+  sections.push('---');
+  sections.push('');
+
   // Bootspring Commands
   sections.push('## Bootspring Commands');
   sections.push('');
@@ -167,12 +197,13 @@ function generate(config) {
   sections.push('');
   sections.push('| Command | Description |');
   sections.push('|---------|-------------|');
+  sections.push('| `bootspring_build action=next` | Get next build task |');
+  sections.push('| `bootspring_build action=done` | Mark task complete |');
   sections.push('| `bootspring_assist` | Natural language help |');
   sections.push('| `bootspring_agent action=list` | List available experts |');
   sections.push('| `bootspring_todo action=list` | List todos |');
   sections.push('| `bootspring_skill action=search query="..."` | Find patterns |');
   sections.push('| `bootspring_quality gate=pre-commit` | Run quality checks |');
-  sections.push('| `bootspring_orchestrator action=workflow workflow=...` | Start workflow |');
   sections.push('');
   sections.push('---');
   sections.push('');

package/generators/templates/index.js

@@ -7,7 +7,9 @@
 
 module.exports = {
   claude: require('./claude.template'),
+  agents: require('./agents.template'),
   seed: require('./seed.template'),
   planning: require('./planning.template'),
-  content: require('./content.template')
+  content: require('./content.template'),
+  buildPlanning: require('./build-planning.template')
 };

package/mcp/contracts/mcp-contract.v1.json

@@ -1,7 +1,7 @@
 {
   "contractVersion": "v1",
   "packageName": "@girardmedia/bootspring",
-  "packageVersion": "2.0.8",
+  "packageVersion": "2.0.10",
   "tools": [
     {
       "name": "bootspring_assist",
@@ -841,6 +841,39 @@
         },
         "required": []
       }
+    },
+    {
+      "name": "bootspring_build",
+      "description": "Autonomous MVP build system. Get tasks, execute them, mark complete.\n\nUse this tool to:\n- Get the current/next task to work on\n- Mark tasks as complete when done\n- Check build progress\n- Run tasks in a loop until MVP is complete\n\nTypical workflow:\n1. action=next → Get the next task\n2. Implement the task in the codebase\n3. action=done → Mark complete and get next task\n4. Repeat until all tasks done",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "action": {
+            "type": "string",
+            "enum": [
+              "next",
+              "current",
+              "done",
+              "skip",
+              "status",
+              "list",
+              "init"
+            ],
+            "description": "Action to perform:\n- next: Get the next pending task (marks it in_progress)\n- current: Get the current in_progress task\n- done: Mark current task complete, get next task\n- skip: Skip current task, get next task\n- status: Get build progress summary\n- list: List all tasks with status\n- init: Initialize build from seed docs"
+          },
+          "reason": {
+            "type": "string",
+            "description": "Reason for skipping (only for skip action)"
+          },
+          "projectRoot": {
+            "type": "string",
+            "description": "Project root path (auto-detected if not provided)"
+          }
+        },
+        "required": [
+          "action"
+        ]
+      }
     }
   ],
   "resources": [

package/mcp/registry.js

@@ -83,6 +83,7 @@ const prdTool = require('./tools/prd-tool');
 const autopilotTool = require('./tools/autopilot-tool');
 const contentTool = require('./tools/content-tool');
 const suggestTool = require('./tools/suggest-tool');
+const buildTool = require('./tools/build-tool');
 
 // Natural language and context detection
 const natural = require('../natural');
@@ -123,7 +124,8 @@ const TOOLS = [
   prdTool.getToolDefinition(),
   autopilotTool.getToolDefinition(),
   contentTool.getToolDefinition(),
-  suggestTool.getToolDefinition()
+  suggestTool.getToolDefinition(),
+  buildTool.getToolDefinition()
 ];
 
 const RESOURCES = [
@@ -283,6 +285,9 @@ const toolHandlers = {
     config,
     format
   }),
+  bootspring_build: buildTool.createHandler({
+    configModule: config
+  }),
 };
 
 const resourceHandlers = {

package/mcp/tools/build-tool.js

@@ -0,0 +1,504 @@
+/**
+ * MCP Build Tool
+ *
+ * Provides Claude Code with direct access to the bootspring build system.
+ * This enables autonomous task execution within Claude Code sessions.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_build',
+    description: `Autonomous MVP build system. Get tasks, execute them, mark complete.
+
+Use this tool to:
+- Get the current/next task to work on
+- Mark tasks as complete when done
+- Check build progress
+- Run tasks in a loop until MVP is complete
+
+Typical workflow:
+1. action=next → Get the next task
+2. Implement the task in the codebase
+3. action=done → Mark complete and get next task
+4. Repeat until all tasks done`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['next', 'current', 'done', 'skip', 'status', 'list', 'init'],
+          description: `Action to perform:
+- next: Get the next pending task (marks it in_progress)
+- current: Get the current in_progress task
+- done: Mark current task complete, get next task
+- skip: Skip current task, get next task
+- status: Get build progress summary
+- list: List all tasks with status
+- init: Initialize build from seed docs`
+        },
+        reason: {
+          type: 'string',
+          description: 'Reason for skipping (only for skip action)'
+        },
+        projectRoot: {
+          type: 'string',
+          description: 'Project root path (auto-detected if not provided)'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ configModule }) {
+  return async (args) => {
+    const { action, reason, projectRoot: providedRoot } = args;
+
+    // Get project root
+    const cfg = configModule.load();
+    const projectRoot = providedRoot || cfg._projectRoot || process.cwd();
+
+    // Load build modules
+    const buildState = require('../../core/build-state');
+    const { BuildOrchestrator } = require('../../core/build-orchestrator');
+
+    switch (action) {
+      case 'init': {
+        // Initialize build from seed docs
+        const orchestrator = new BuildOrchestrator(projectRoot);
+        await orchestrator.initialize();
+        const state = buildState.load(projectRoot);
+        const stats = buildState.getStats(projectRoot);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              message: 'Build initialized from seed documents',
+              project: state?.projectName || 'Unknown',
+              phase: state?.currentPhase || 'foundation',
+              totalTasks: stats?.total || 0,
+              planningFolder: path.join(projectRoot, 'planning'),
+              nextStep: 'Use action=next to get the first task'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'status': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                initialized: false,
+                message: 'No build state found. Use action=init to initialize.',
+                hint: 'Run: bootspring seed build'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const stats = buildState.getStats(projectRoot);
+        const currentTask = state.implementationQueue.find(t => t.status === 'in_progress');
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              project: state.projectName,
+              phase: state.currentPhase,
+              status: state.status,
+              progress: {
+                completed: stats.completed,
+                pending: stats.pending,
+                inProgress: stats.inProgress,
+                total: stats.total,
+                percent: Math.round(stats.completedPercent)
+              },
+              currentTask: currentTask ? {
+                id: currentTask.id,
+                title: currentTask.title
+              } : null,
+              nextAction: currentTask
+                ? 'Complete the current task, then use action=done'
+                : 'Use action=next to get the next task'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'list': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No build state found',
+                hint: 'Use action=init to initialize'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const tasks = state.implementationQueue.map(t => ({
+          id: t.id,
+          title: t.title,
+          status: t.status,
+          phase: t.phase
+        }));
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              project: state.projectName,
+              tasks: tasks
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'current': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No build state found',
+                hint: 'Use action=init to initialize'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const currentTask = state.implementationQueue.find(t => t.status === 'in_progress');
+        if (!currentTask) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                message: 'No task currently in progress',
+                hint: 'Use action=next to get the next task'
+              }, null, 2)
+            }]
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              task: {
+                id: currentTask.id,
+                title: currentTask.title,
+                description: currentTask.description,
+                phase: currentTask.phase,
+                source: currentTask.source,
+                sourceSection: currentTask.sourceSection,
+                acceptanceCriteria: currentTask.acceptanceCriteria || []
+              },
+              instructions: [
+                'Implement this task in the codebase',
+                'Run quality checks (lint, test)',
+                'Commit your changes',
+                'Use action=done to mark complete'
+              ]
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'next': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No build state found',
+                hint: 'Use action=init to initialize'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Check if there's already an in-progress task
+        const inProgress = state.implementationQueue.find(t => t.status === 'in_progress');
+        if (inProgress) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                message: 'Task already in progress',
+                task: {
+                  id: inProgress.id,
+                  title: inProgress.title,
+                  description: inProgress.description,
+                  acceptanceCriteria: inProgress.acceptanceCriteria || []
+                },
+                hint: 'Complete this task first with action=done, or use action=skip to skip it'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const nextTask = buildState.getNextTask(projectRoot);
+        if (!nextTask) {
+          const stats = buildState.getStats(projectRoot);
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                message: 'All tasks complete!',
+                progress: {
+                  completed: stats.completed,
+                  total: stats.total
+                },
+                celebration: 'MVP build finished!'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Mark as in progress
+        buildState.updateProgress(projectRoot, nextTask.id, 'in_progress');
+
+        // Write to CURRENT_TASK.md
+        writeCurrentTaskFile(projectRoot, nextTask);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              task: {
+                id: nextTask.id,
+                title: nextTask.title,
+                description: nextTask.description,
+                phase: nextTask.phase,
+                source: nextTask.source,
+                sourceSection: nextTask.sourceSection,
+                acceptanceCriteria: nextTask.acceptanceCriteria || []
+              },
+              file: 'planning/CURRENT_TASK.md',
+              instructions: [
+                'Read the task details above',
+                'Implement the task in the codebase',
+                'Ensure acceptance criteria are met',
+                'Run quality checks (lint, test)',
+                'Commit changes with descriptive message',
+                'Use action=done when complete'
+              ]
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'done': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No build state found'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const inProgress = state.implementationQueue.find(t => t.status === 'in_progress');
+        if (!inProgress) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No task currently in progress',
+                hint: 'Use action=next to get a task first'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Mark complete
+        buildState.updateProgress(projectRoot, inProgress.id, 'completed');
+
+        const stats = buildState.getStats(projectRoot);
+        const nextTask = buildState.getNextTask(projectRoot);
+
+        // Auto-queue next task
+        if (nextTask) {
+          buildState.updateProgress(projectRoot, nextTask.id, 'in_progress');
+          writeCurrentTaskFile(projectRoot, nextTask);
+        } else {
+          clearCurrentTaskFile(projectRoot);
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              completed: {
+                id: inProgress.id,
+                title: inProgress.title
+              },
+              progress: {
+                completed: stats.completed,
+                total: stats.total,
+                percent: Math.round(stats.completedPercent)
+              },
+              nextTask: nextTask ? {
+                id: nextTask.id,
+                title: nextTask.title,
+                description: nextTask.description,
+                acceptanceCriteria: nextTask.acceptanceCriteria || []
+              } : null,
+              allComplete: !nextTask,
+              message: nextTask
+                ? `Task complete! Next: ${nextTask.title}`
+                : 'All tasks complete! MVP build finished!'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'skip': {
+        const state = buildState.load(projectRoot);
+        if (!state) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No build state found'
+              }, null, 2)
+            }]
+          };
+        }
+
+        const inProgress = state.implementationQueue.find(t => t.status === 'in_progress');
+        if (!inProgress) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: 'No task to skip',
+                hint: 'Use action=next to get a task first'
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Mark as skipped (back to pending with skip flag)
+        buildState.updateProgress(projectRoot, inProgress.id, 'skipped');
+
+        const nextTask = buildState.getNextTask(projectRoot);
+
+        if (nextTask) {
+          buildState.updateProgress(projectRoot, nextTask.id, 'in_progress');
+          writeCurrentTaskFile(projectRoot, nextTask);
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              skipped: {
+                id: inProgress.id,
+                title: inProgress.title,
+                reason: reason || 'Skipped by user'
+              },
+              nextTask: nextTask ? {
+                id: nextTask.id,
+                title: nextTask.title,
+                description: nextTask.description
+              } : null,
+              message: nextTask
+                ? `Skipped. Next: ${nextTask.title}`
+                : 'No more tasks available'
+            }, null, 2)
+          }]
+        };
+      }
+
+      default:
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              error: `Unknown action: ${action}`,
+              validActions: ['next', 'current', 'done', 'skip', 'status', 'list', 'init']
+            }, null, 2)
+          }]
+        };
+    }
+  };
+}
+
+/**
+ * Write task to planning/CURRENT_TASK.md
+ */
+function writeCurrentTaskFile(projectRoot, task) {
+  const planningDir = path.join(projectRoot, 'planning');
+  if (!fs.existsSync(planningDir)) {
+    fs.mkdirSync(planningDir, { recursive: true });
+  }
+
+  const content = `# Current Task
+
+> Auto-generated by bootspring. Implement this task.
+
+---
+
+## ${task.title}
+
+${task.description || ''}
+
+${task.acceptanceCriteria?.length ? `### Acceptance Criteria
+
+${task.acceptanceCriteria.map(ac => `- [ ] ${ac}`).join('\n')}
+` : ''}
+
+### Source
+
+${task.source}${task.sourceSection ? ` - ${task.sourceSection}` : ''}
+
+---
+
+## Instructions
+
+1. Implement the task as described above
+2. Ensure all acceptance criteria are met
+3. Run quality checks (lint, test)
+4. Commit your changes
+5. Mark complete with: \`bootspring build done\` or MCP action=done
+
+---
+
+*Task ID: ${task.id}*
+*Generated: ${new Date().toISOString()}*
+`;
+
+  fs.writeFileSync(path.join(planningDir, 'CURRENT_TASK.md'), content);
+}
+
+/**
+ * Clear CURRENT_TASK.md
+ */
+function clearCurrentTaskFile(projectRoot) {
+  const taskFile = path.join(projectRoot, 'planning', 'CURRENT_TASK.md');
+  if (fs.existsSync(taskFile)) {
+    fs.unlinkSync(taskFile);
+  }
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
   "keywords": [
     "ai",