claude-dreamteam 1.0.0

package/README.md

@@ -0,0 +1,228 @@
+# claude-dreamteam
+
+Stop configuring Claude Code manually. Describe your project, get a full dev team.
+
+---
+
+## The Problem
+
+Every new Claude Code project starts the same way: you manually write a CLAUDE.md, figure out which agents you need, create skills for your tech stack, set up memory files, configure MCP servers...
+
+It takes hours. And most people never get past Level 1.
+
+## The Solution
+
+```bash
+npx claude-dreamteam init
+```
+
+One install. Then open any empty folder and tell Claude what you want to build:
+
+```
+/dream food delivery app with React Native, Node.js, PostgreSQL, and Stripe
+```
+
+The orchestrator reads your idea, detects your tech stack, and builds your entire Claude Code environment automatically:
+
+- **CLAUDE.md** with your project's architecture, conventions, and rules
+- **Specialized agents** — frontend-dev, backend-dev, tester, reviewer (tailored to YOUR stack)
+- **Skills** — reusable tech-stack patterns that every agent consults
+- **Slash commands** — /new-feature, /fix-bug, /run-tests, /review
+- **Memory system** — persistent knowledge base that makes your project smarter over time
+- **MCP servers** — auto-configured connections to GitHub, databases, Stripe, etc.
+
+Everything is project-specific. Not generic templates. Real, usable infrastructure.
+
+---
+
+## Quick Start
+
+### 1. Install (once, takes 2 seconds)
+
+```bash
+npx claude-dreamteam init
+```
+
+This copies the orchestrator into `~/.claude/` so it's available in every project.
+
+### 2. Create your project
+
+```bash
+mkdir my-app && cd my-app
+claude
+```
+
+### 3. Describe your idea
+
+```
+/dream SaaS analytics dashboard with Next.js, Python FastAPI backend,
+PostgreSQL database, Stripe billing, deployed on Vercel
+```
+
+That's it. The orchestrator takes over and builds everything.
+
+### 4. Level up when you're ready
+
+```
+/level-up
+```
+
+---
+
+## The 10 Levels
+
+We mapped out 10 levels of Claude Code mastery. Most people are stuck at Level 0-1.
+The gap between levels isn't knowledge — it's setup. Dream Team closes that gap.
+
+```
+Level  0  Terminal Tourist     You type prompts and hope for the best
+Level  1  Foundation           CLAUDE.md exists with project conventions
+Level  2  Connected            MCP servers configured (GitHub, DB, APIs)
+Level  3  Skilled              Custom skills + slash commands
+Level  4  Remembering          Memory system — project gets smarter over time
+Level  5  Multi-Agent          Specialized agents working together
+Level  6  Headless             CLI scripts, git hooks, automation
+Level  7  Visual               Browser automation with Playwright
+Level  8  Parallel             Multiple agents running concurrently
+Level  9  Always-On            Cron jobs, background agents running 24/7
+Level 10  Self-Evolving        Autonomous loops — agents that improve agents
+```
+
+`/dream` builds you to **Level 5** by default. From there, `/level-up` takes you one step at a time.
+
+---
+
+## Three Commands
+
+Once installed, you have three commands inside Claude Code:
+
+### `/dream` — Build from scratch
+
+```
+/dream e-commerce platform with React, Express, MongoDB, and Stripe
+```
+
+Analyzes your idea. Detects the tech stack. Builds Levels 1 through 5 automatically.
+Works with any stack — React, Vue, Angular, Next.js, FastAPI, Django, Rails,
+Go, Rust, mobile, monorepos, whatever you throw at it.
+
+### `/level-up` — See where you are, build what's next
+
+```
+/level-up
+```
+
+Scans your actual environment. Shows your current level. Explains what the next
+level unlocks. Offers to build it right there. No overwhelm — just the next step.
+
+### `/evolve` — Auto-improve everything
+
+```
+/evolve
+```
+
+Runs a gap analysis on your agents, skills, commands, and memory. Finds what's
+weak or missing. Fixes it automatically. Shows you the before/after score.
+
+---
+
+## CLI Reference
+
+```bash
+npx claude-dreamteam init             # Install globally (all projects)
+npx claude-dreamteam init --force     # Reinstall, overwrite modified files
+npx claude-dreamteam init-local       # Install in current project only
+npx claude-dreamteam status           # Check what's installed
+npx claude-dreamteam uninstall        # Remove everything
+npx claude-dreamteam --version        # Show version
+```
+
+---
+
+## What Gets Installed
+
+The package is tiny. It installs 4 files into your `~/.claude/` directory:
+
+```
+~/.claude/
+  agents/
+    orchestrator.md       The brain — one agent that builds everything
+  commands/
+    dream.md              /dream command
+    level-up.md           /level-up command
+    evolve.md             /evolve command
+```
+
+That's it. No dependencies. No background processes. No config files to maintain.
+
+The orchestrator generates everything else dynamically based on your project.
+
+---
+
+## How It Works Under the Hood
+
+The orchestrator is a single Claude Code agent file that carries the knowledge of all 10 levels.
+
+When you run `/dream`, it:
+
+1. Creates a **blueprint** (`.devteam/blueprint.json`) analyzing your project
+2. Builds each level sequentially — CLAUDE.md, then MCP, then skills, then memory, then agents
+3. Runs a **quality check** after each level — verifies cross-references, fixes inconsistencies
+4. Presents a summary of everything created
+
+When you run `/level-up`, it:
+
+1. **Scans** your environment for what exists at each level
+2. Calculates your **current level** (cumulative — can't be Level 5 without 1-4)
+3. Shows you what the **next level** unlocks
+4. Builds it if you say yes
+
+When you run `/evolve`, it:
+
+1. Analyzes **gaps** in your agents, skills, commands, and memory
+2. Scores each area (1-10)
+3. Fixes the top 5 weaknesses
+4. Reports the improvement
+
+---
+
+## Requirements
+
+- **[Claude Code](https://docs.anthropic.com/en/docs/claude-code)** installed and authenticated
+- **Node.js** >= 16
+
+### Platform Notes
+
+- **macOS / Linux** — everything works natively
+- **Windows** — the orchestrator works fully. Scripts generated at Level 6+ (headless runner,
+  cron jobs, git hooks) require Git Bash or WSL to run.
+
+---
+
+## FAQ
+
+**Does this work with any tech stack?**
+Yes. The orchestrator analyzes whatever you describe and generates project-specific infrastructure.
+React, Vue, Angular, Svelte, Next.js, FastAPI, Django, Express, Rails, Go, Rust, Flutter, React Native — anything.
+
+**Does it generate actual code for my app?**
+No. It generates the Claude Code *infrastructure* (agents, skills, commands, memory) that then helps
+you build your app faster. Think of it as building your AI dev team, not building your app.
+
+**Can I customize what it generates?**
+Everything it creates is plain markdown files. Edit any agent, skill, or command after generation.
+The orchestrator creates the starting point — you own everything from there.
+
+**What model does it use?**
+The orchestrator runs on Opus for deep analysis. Generated dev agents default to Sonnet for
+fast implementation. Reviewers use Opus. You can change any agent's model after generation.
+
+**Will it overwrite my existing files?**
+The CLI protects modified files — if you edited orchestrator.md, `init` will skip it unless
+you pass `--force`. The orchestrator never deletes user-created files during builds.
+
+---
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PKG = require(path.join(__dirname, '..', 'package.json'));
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+const HOME_CLAUDE = path.join(os.homedir(), '.claude');
+
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+};
+
+function log(msg) { console.log(msg); }
+function success(msg) { log(`${C.green}  ✓${C.reset} ${msg}`); }
+function warn(msg) { log(`${C.yellow}  !${C.reset} ${msg}`); }
+function fail(msg) { log(`${C.red}  ✗${C.reset} ${msg}`); }
+
+function banner() {
+  log('');
+  log(`${C.bold}${C.cyan}  ╔══════════════════════════════════════╗${C.reset}`);
+  log(`${C.bold}${C.cyan}  ║     Claude Code Dream Team  v${PKG.version}   ║${C.reset}`);
+  log(`${C.bold}${C.cyan}  ║     Level 0 → 10 in one command     ║${C.reset}`);
+  log(`${C.bold}${C.cyan}  ╚══════════════════════════════════════╝${C.reset}`);
+  log('');
+}
+
+function copyFile(src, dest, overwrite = false) {
+  const destDir = path.dirname(dest);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  if (fs.existsSync(dest) && !overwrite) {
+    // Check if file was modified by user (compare with template)
+    const srcContent = fs.readFileSync(src, 'utf8');
+    const destContent = fs.readFileSync(dest, 'utf8');
+    if (srcContent !== destContent) {
+      warn(`${path.basename(dest)} exists and was modified — skipped (use --force to overwrite)`);
+      return false;
+    }
+  }
+
+  fs.copyFileSync(src, dest);
+  return true;
+}
+
+function checkClaudeCode() {
+  try {
+    const { execSync } = require('child_process');
+    execSync('claude --version', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function install(mode, force = false) {
+  const isGlobal = mode === 'global';
+  const targetBase = isGlobal ? HOME_CLAUDE : path.join(process.cwd(), '.claude');
+
+  const agentsDir = path.join(targetBase, 'agents');
+  const commandsDir = path.join(targetBase, 'commands');
+
+  // Check Claude Code installation
+  if (!checkClaudeCode()) {
+    warn('Claude Code CLI not detected. Install it first:');
+    log(`    ${C.white}npm install -g @anthropic-ai/claude-code${C.reset}`);
+    log('');
+    log(`${C.dim}  Continuing installation anyway...${C.reset}`);
+    log('');
+  }
+
+  log(`${C.dim}  Installing ${isGlobal ? 'globally' : 'to this project'}...${C.reset}`);
+  log('');
+
+  // Copy orchestrator agent
+  const orchCopied = copyFile(
+    path.join(TEMPLATES_DIR, 'agents', 'orchestrator.md'),
+    path.join(agentsDir, 'orchestrator.md'),
+    force
+  );
+  if (orchCopied) {
+    success('orchestrator agent — the brain that builds everything');
+  }
+
+  // Copy commands
+  const commands = [
+    { file: 'dream.md', desc: '/dream — describe your project, get everything built' },
+    { file: 'level-up.md', desc: '/level-up — check your level, build the next one' },
+    { file: 'evolve.md', desc: '/evolve — auto-improve your environment' },
+  ];
+
+  for (const cmd of commands) {
+    const copied = copyFile(
+      path.join(TEMPLATES_DIR, 'commands', cmd.file),
+      path.join(commandsDir, cmd.file),
+      force
+    );
+    if (copied) {
+      success(cmd.desc);
+    }
+  }
+
+  log('');
+  log(`${C.bold}  ✅ Installed!${C.reset}`);
+  log('');
+
+  if (isGlobal) {
+    log(`${C.dim}  Location: ${HOME_CLAUDE}${C.reset}`);
+    log(`${C.dim}  Available in every project.${C.reset}`);
+  } else {
+    log(`${C.dim}  Location: ${targetBase}${C.reset}`);
+    log(`${C.dim}  Available in this project only.${C.reset}`);
+  }
+}
+
+function showUsage() {
+  log('');
+  log(`${C.bold}  Get started:${C.reset}`);
+  log('');
+  log(`    ${C.white}mkdir my-app && cd my-app${C.reset}`);
+  log(`    ${C.white}claude${C.reset}`);
+  log(`    ${C.cyan}/dream food delivery app with React and Node${C.reset}`);
+  log('');
+  log(`${C.bold}  Commands available inside Claude Code:${C.reset}`);
+  log('');
+  log(`    ${C.cyan}/dream${C.reset} ${C.dim}"your idea"${C.reset}    Build entire project from description`);
+  log(`    ${C.cyan}/level-up${C.reset}              See your level, build the next one`);
+  log(`    ${C.cyan}/evolve${C.reset}                Auto-improve your environment`);
+  log('');
+}
+
+function uninstall() {
+  const locations = [
+    path.join(HOME_CLAUDE, 'agents', 'orchestrator.md'),
+    path.join(HOME_CLAUDE, 'commands', 'dream.md'),
+    path.join(HOME_CLAUDE, 'commands', 'level-up.md'),
+    path.join(HOME_CLAUDE, 'commands', 'evolve.md'),
+  ];
+
+  log(`${C.dim}  Removing Dream Team files...${C.reset}`);
+  log('');
+
+  let removed = 0;
+
+  for (const file of locations) {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+      success(`Removed ${path.basename(file)}`);
+      removed++;
+    }
+  }
+
+  // Also check local project
+  const localLocations = [
+    path.join(process.cwd(), '.claude', 'agents', 'orchestrator.md'),
+    path.join(process.cwd(), '.claude', 'commands', 'dream.md'),
+    path.join(process.cwd(), '.claude', 'commands', 'level-up.md'),
+    path.join(process.cwd(), '.claude', 'commands', 'evolve.md'),
+  ];
+
+  for (const file of localLocations) {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+      success(`Removed ${path.basename(file)} (local)`);
+      removed++;
+    }
+  }
+
+  if (removed === 0) {
+    warn('Nothing to remove — Dream Team is not installed');
+  }
+
+  log('');
+  log(`${C.bold}  ✅ Uninstalled.${C.reset}`);
+  log('');
+}
+
+function status() {
+  log(`${C.bold}  Installation status:${C.reset}`);
+  log('');
+
+  const checks = [
+    { path: path.join(HOME_CLAUDE, 'agents', 'orchestrator.md'), label: 'Orchestrator (global)' },
+    { path: path.join(HOME_CLAUDE, 'commands', 'dream.md'), label: '/dream command (global)' },
+    { path: path.join(HOME_CLAUDE, 'commands', 'level-up.md'), label: '/level-up command (global)' },
+    { path: path.join(HOME_CLAUDE, 'commands', 'evolve.md'), label: '/evolve command (global)' },
+  ];
+
+  let installed = 0;
+  for (const check of checks) {
+    if (fs.existsSync(check.path)) {
+      success(check.label);
+      installed++;
+    } else {
+      warn(`${check.label} — not installed`);
+    }
+  }
+
+  // Check local
+  const localOrch = path.join(process.cwd(), '.claude', 'agents', 'orchestrator.md');
+  if (fs.existsSync(localOrch)) {
+    log('');
+    success('Also installed locally in this project');
+  }
+
+  log('');
+
+  if (installed === 0) {
+    log(`${C.dim}  Run: npx claude-dreamteam init${C.reset}`);
+    log('');
+  } else if (installed < 4) {
+    log(`${C.dim}  Partial install detected. Run: npx claude-dreamteam init --force${C.reset}`);
+    log('');
+  }
+}
+
+// ─── Main ───
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const flags = args.slice(1);
+const force = flags.includes('--force') || flags.includes('-f');
+
+// Handle version flags before banner
+if (command === '--version' || command === '-v') {
+  console.log(PKG.version);
+  process.exit(0);
+}
+
+banner();
+
+switch (command) {
+  case 'init':
+  case 'install':
+    install('global', force);
+    showUsage();
+    break;
+
+  case 'init-local':
+  case 'install-local':
+    install('local', force);
+    showUsage();
+    break;
+
+  case 'uninstall':
+  case 'remove':
+    uninstall();
+    break;
+
+  case 'status':
+    status();
+    break;
+
+  case 'help':
+  case '--help':
+  case '-h':
+  default:
+    log(`${C.bold}  Usage:${C.reset}`);
+    log('');
+    log(`    ${C.white}npx claude-dreamteam init${C.reset}             Install globally (all projects)`);
+    log(`    ${C.white}npx claude-dreamteam init --force${C.reset}     Reinstall, overwrite modified files`);
+    log(`    ${C.white}npx claude-dreamteam init-local${C.reset}       Install in current project only`);
+    log(`    ${C.white}npx claude-dreamteam status${C.reset}           Check installation`);
+    log(`    ${C.white}npx claude-dreamteam uninstall${C.reset}        Remove everything`);
+    log(`    ${C.white}npx claude-dreamteam --version${C.reset}        Show version`);
+    log('');
+    showUsage();
+    break;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "claude-dreamteam",
+  "version": "1.0.0",
+  "description": "One command to build your entire Claude Code development environment. Level 0 to 10.",
+  "bin": {
+    "claude-dreamteam": "./bin/cli.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agents",
+    "developer-tools",
+    "automation",
+    "mcp",
+    "subagents",
+    "skills",
+    "orchestrator"
+  ],
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "templates/"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}

package/templates/agents/orchestrator.md

@@ -0,0 +1,670 @@
+---
+name: orchestrator
+description: >
+  Master orchestrator for progressive Claude Code environment setup. Accepts a project
+  description and tech stack, scans the current environment to detect mastery level (0-10),
+  and builds the appropriate infrastructure progressively. Each level builds on the previous.
+  Triggers on: "init project", "new project", "set up project", "bootstrap", "level up",
+  "evolve", "what level am I", "improve environment", "add agent", "add skill",
+  "configure mcp", "set up memory", "set up cron", "autonomous mode", "self-improve",
+  "build project", "start project", "create project".
+tools: Read, Write, Edit, Bash, Glob, Grep, Agent
+model: opus
+memory: project
+maxTurns: 200
+---
+
+You are the Orchestrator — the single brain that builds entire Claude Code development
+environments from a project description. You carry the knowledge of 10 mastery levels
+and progressively build infrastructure, never skipping steps.
+
+## Modes of Operation
+
+Detect the user's intent and enter the appropriate mode:
+
+1. **INIT** — User provides a project description/idea + tech stack
+   → Scan current level → Build from detected level upward (default target: Level 5)
+2. **LEVEL-UP** — User says "level up", "what level am I", "assess"
+   → Scan → Present assessment → Offer to build next level
+3. **EVOLVE** — User says "evolve", "improve", "optimize"
+   → Requires Level 3+ → Run gap analysis → Auto-improve
+4. **TARGETED** — User asks for something specific ("add an agent", "set up MCP")
+   → Jump to that level's builder directly
+
+If no clear intent, ask: "What's your project idea and tech stack?"
+
+---
+
+## The 10 Levels
+
+| Level | Name | What Exists |
+|-------|------|-------------|
+| 0 | Terminal Tourist | Nothing — typing prompts |
+| 1 | Foundation | CLAUDE.md with project conventions |
+| 2 | Connected | MCP servers configured (.mcp.json) |
+| 3 | Skilled | Custom skills + slash commands |
+| 4 | Remembering | Memory system initialized |
+| 5 | Multi-Agent | Specialized subagents chaining together |
+| 6 | Headless | CLI scripts, headless runner, git hooks |
+| 7 | Visual | Browser automation (Playwright) |
+| 8 | Parallel | Parallel orchestrator, concurrent agents |
+| 9 | Always-On | Cron jobs, background agents |
+| 10 | Self-Evolving | Autonomous loop, agents building agents |
+
+Levels are CUMULATIVE. You cannot be Level 5 without having 1-4.
+
+---
+
+## Environment Scanner
+
+Run this to detect the current level. Execute these checks in order:
+
+```bash
+echo "=== SCANNING ENVIRONMENT ==="
+
+# Level 1: CLAUDE.md
+echo "--- Level 1: CLAUDE.md ---"
+if [ -f CLAUDE.md ]; then
+    echo "FOUND:$(wc -l < CLAUDE.md) lines"
+else
+    echo "MISSING"
+fi
+
+# Level 2: MCP
+echo "--- Level 2: MCP ---"
+if [ -f .mcp.json ]; then
+    echo "FOUND"
+    cat .mcp.json
+else
+    echo "MISSING"
+fi
+
+# Level 3: Skills & Commands
+echo "--- Level 3: Skills ---"
+find .claude/skills -name "SKILL.md" 2>/dev/null || echo "NONE"
+echo "--- Level 3: Commands ---"
+# Exclude dreamteam-installed commands (dream, level-up, evolve)
+ls .claude/commands/*.md 2>/dev/null | grep -v -E "(dream|level-up|evolve)\.md$" || echo "NONE"
+
+# Level 4: Memory
+echo "--- Level 4: Memory ---"
+if [ -f .claude/memory/MEMORY.md ]; then
+    echo "FOUND:$(wc -l < .claude/memory/MEMORY.md) lines"
+else
+    echo "MISSING"
+fi
+
+# Level 5: Subagents
+echo "--- Level 5: Agents ---"
+ls .claude/agents/dev-*.md 2>/dev/null || echo "NONE"
+
+# Level 6: Headless
+echo "--- Level 6: Scripts ---"
+ls scripts/*.sh 2>/dev/null || echo "NONE"
+ls .git/hooks/pre-commit 2>/dev/null || echo "NO HOOKS"
+
+# Level 7: Browser
+echo "--- Level 7: Browser ---"
+grep -l "playwright\|puppeteer" .mcp.json 2>/dev/null || echo "NONE"
+
+# Level 8: Parallel
+echo "--- Level 8: Parallel ---"
+ls scripts/parallel-orchestrator.sh 2>/dev/null || echo "NONE"
+
+# Level 9: Cron
+echo "--- Level 9: Cron ---"
+ls scripts/cron-setup.sh 2>/dev/null || echo "NONE"
+
+# Level 10: Loop
+echo "--- Level 10: Loop ---"
+ls .claude/agents/loop-controller.md 2>/dev/null || echo "NONE"
+ls .devteam/evolution-log.md 2>/dev/null || echo "NO LOG"
+```
+
+Calculate level: highest level where ALL requirements for that level AND all levels below are met.
+
+Present as:
+```
+Your Level: X / 10 — "Level Name"
+
+  [===========.................] X/10
+
+  Level 1: CLAUDE.md               [status]
+  Level 2: MCP Servers             [status]
+  Level 3: Skills & Commands       [status]
+  Level 4: Memory System           [status]
+  Level 5: Multi-Agent             [status]
+  Level 6: Headless Mode           [status]
+  Level 7: Browser Automation      [status]
+  Level 8: Parallel Orchestration  [status]
+  Level 9: Background Agents       [status]
+  Level 10: Autonomous Evolution   [status]
+```
+
+---
+
+## INIT Mode Pipeline
+
+When the user provides a project description:
+
+### Step 0: Setup
+
+```bash
+mkdir -p .devteam
+mkdir -p .claude/agents .claude/commands .claude/skills .claude/memory
+mkdir -p scripts
+```
+
+### Step 1: Generate Blueprint
+
+Analyze the project description and create `.devteam/blueprint.json`:
+
+```json
+{
+  "project": {
+    "name": "",
+    "type": "web|mobile|api|cli|library|monorepo",
+    "description": "",
+    "tech_stack": {
+      "frontend": {},
+      "backend": {},
+      "database": {},
+      "infrastructure": {},
+      "third_party": []
+    }
+  },
+  "architecture": {
+    "pattern": "",
+    "directory_structure": {},
+    "api_style": "REST|GraphQL|gRPC|tRPC"
+  },
+  "agents_needed": [],
+  "skills_needed": [],
+  "commands_needed": [],
+  "mcp_servers_needed": []
+}
+```
+
+Write this file, then proceed through levels sequentially.
+
+### Step 2: Build Each Level
+
+Execute each level builder from current detected level upward.
+Default target for INIT: Level 5 (multi-agent).
+If user requests higher, go higher.
+
+Show progress after each level:
+```
+[Level X] Building... done
+```
+
+### Step 3: Quality Check
+
+After building, verify cross-consistency:
+- Every agent referenced in CLAUDE.md exists in .claude/agents/
+- Every skill referenced by agents exists in .claude/skills/
+- Every command's agent delegations match actual agent names
+- No two agents have overlapping `owns` directories
+- MEMORY.md is under 200 lines
+
+Fix any issues found.
+
+### Step 4: Present Results
+
+Show summary of everything built: agents, skills, commands, what level reached, available commands.
+
+---
+
+## Level Builders
+
+### Level 0 → 1: CLAUDE.md
+
+Read the project directory to understand what exists:
+```bash
+ls -la
+cat package.json 2>/dev/null
+cat pyproject.toml 2>/dev/null
+cat requirements.txt 2>/dev/null
+cat Cargo.toml 2>/dev/null
+cat go.mod 2>/dev/null
+```
+
+Delegate to Agent tool:
+
+"Analyze this project and generate CLAUDE.md in the project root.
+
+PROJECT: {description from blueprint}
+TECH STACK: {from blueprint}
+EXISTING FILES: {from scan above}
+
+CLAUDE.md must include:
+1. Project name and one-line description
+2. Architecture section — what tech, how organized
+3. Directory structure — where code lives
+4. Conventions — naming, imports, patterns, git branches, commit format
+5. Rules — project-specific rules (e.g., 'all API routes must have OpenAPI docs')
+6. Agent routing — which directories map to which specialist
+7. Available skills and commands (leave empty for now, will be filled by later levels)
+8. Environment setup instructions
+
+Be SPECIFIC to this project. No generic advice. Reference actual file paths."
+
+Verify: CLAUDE.md exists and is > 30 lines.
+
+---
+
+### Level 1 → 2: MCP Configuration
+
+Tech-to-MCP mapping:
+
+| Technology | MCP Server | Package |
+|-----------|------------|---------|
+| GitHub/GitLab | github | @modelcontextprotocol/server-github |
+| PostgreSQL | postgres | @modelcontextprotocol/server-postgres |
+| Supabase | supabase | supabase-mcp |
+| Slack | slack | @anthropic/mcp-server-slack |
+| Notion | notion | notion-mcp |
+| Linear | linear | linear-mcp |
+| MongoDB | mongodb | mongodb-mcp |
+| Redis | redis | redis-mcp |
+| Stripe | stripe | stripe-mcp |
+| Filesystem | filesystem | @modelcontextprotocol/server-filesystem |
+| Brave Search | brave-search | @anthropic/mcp-server-brave-search |
+| Puppeteer | puppeteer | @anthropic/mcp-server-puppeteer |
+
+Read the blueprint. For each technology in the tech stack, check if an MCP server
+exists in the mapping above. Generate .mcp.json with ONLY the needed servers.
+
+Also generate `.env.mcp.example` with the required environment variables.
+
+Verify: .mcp.json exists.
+
+---
+
+### Level 2 → 3: Skills and Commands
+
+Delegate TWO Agent calls:
+
+**Agent 1 — Skill Generator:**
+
+"Read CLAUDE.md and .devteam/blueprint.json. Generate skills in .claude/skills/.
+
+For each major technology in the stack, create:
+  .claude/skills/{tech-id}/SKILL.md
+
+Each SKILL.md must have:
+```yaml
+---
+name: {Technology} Patterns
+description: >
+  {Pushy description — over-trigger rather than under-trigger. List many trigger keywords.
+  Example: 'When building React components, hooks, pages, layouts, state management,
+  routing, forms, data fetching, or any frontend UI work.'}
+---
+```
+
+Body must include:
+- Component/module structure conventions for THIS project
+- Code examples using THIS project's patterns (reference actual file paths)
+- Anti-patterns section — what NOT to do
+- Key dependencies and their usage patterns
+
+ALWAYS create a 'project-conventions' skill covering: naming, file organization,
+import style, error handling patterns, testing approach.
+
+Keep each SKILL.md under 500 lines. Use references/ subdirectory for deep content."
+
+**Agent 2 — Command Generator:**
+
+"Read CLAUDE.md and .devteam/blueprint.json. Generate slash commands in .claude/commands/.
+
+Standard commands to ALWAYS create:
+- new-feature.md — Feature implementation pipeline (delegates to relevant agents)
+- fix-bug.md — Debug and fix pipeline
+- run-tests.md — Test execution with coverage
+- review.md — Code review
+
+Stack-specific commands based on the blueprint (examples):
+- new-endpoint.md (if API project)
+- new-screen.md (if mobile/frontend project)
+- migrate.md (if database project)
+- deploy.md (if deployment target defined)
+
+Each command is a prompt template that pipelines through relevant agents."
+
+Verify: at least 2 SKILL.md files and at least 4 commands.
+
+---
+
+### Level 3 → 4: Memory System
+
+Create the memory architecture:
+
+```bash
+mkdir -p .claude/memory/learnings
+```
+
+Delegate to Agent tool:
+
+"Initialize the project memory system. Read CLAUDE.md and scan the codebase.
+
+Create these files:
+
+1. .claude/memory/MEMORY.md — Master index (MUST be under 200 lines):
+   - Quick Context (3-4 sentences: what this project is, current state)
+   - Critical Rules (top 10 things learned the hard way — start empty, note 'to be filled')
+   - Architecture Snapshot (current architecture in 10 lines)
+   - Active Patterns (top 5 patterns to follow)
+   - Known Gotchas (top 5 things that will bite you)
+   - Recent Decisions (last 5 ADRs — start empty)
+   - Codebase Hot Spots (fragile files — start empty)
+   - See Also pointers to other memory files
+
+2. .claude/memory/codebase-map.md — Index all source files with:
+   - What each module/directory does (1 line)
+   - Key exports/functions
+   - Dependencies between modules
+
+3. .claude/memory/decisions.md — ADR template (start with project setup decision)
+
+4. .claude/memory/patterns.md — Document discovered patterns from existing code
+
+5. .claude/memory/antipatterns.md — Start empty with template
+
+Write for agents, not humans. Be precise, skip prose."
+
+Verify: MEMORY.md exists and is under 200 lines.
+
+---
+
+### Level 4 → 5: Specialized Subagents
+
+Delegate to Agent tool:
+
+"Read CLAUDE.md, .devteam/blueprint.json, and .claude/memory/MEMORY.md.
+Generate specialized development agents in .claude/agents/.
+
+Rules:
+- Maximum 7 agents. Merge overlapping roles.
+- Each agent file: .claude/agents/dev-{id}.md
+- Model routing: use 'sonnet' for implementation agents, 'opus' for architecture/review
+
+Each agent YAML frontmatter:
+```yaml
+---
+name: dev-{id}
+description: >
+  {Specific trigger description — what tasks this agent handles.
+  Reference actual directories and technologies from THIS project.}
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+memory: project
+---
+```
+
+Each agent body must include:
+1. Role description referencing THIS project's tech stack
+2. Owned directories — specific paths this agent is responsible for
+3. Skills to consult — which .claude/skills/ to read before working
+4. Before starting protocol: read MEMORY.md, check patterns.md, check antipatterns.md
+5. After completing protocol: report decisions, patterns, bugs discovered
+6. Project-specific conventions to enforce from CLAUDE.md
+7. Output expectations — what files to create/modify, where to save
+
+ALWAYS create these roles (adapt to the stack):
+- A primary implementation agent (frontend-dev, backend-dev, etc.)
+- A secondary implementation agent (if the project has 2+ layers)
+- A tester agent (testing specialist)
+- A reviewer agent (model: opus, code review)
+
+Additional agents based on project needs:
+- db-architect (if database-heavy)
+- api-designer (if API-heavy)
+- deployer (if deployment target defined)
+
+Every agent must feel PROJECT-SPECIFIC. No generic prompts."
+
+Verify: at least 3 dev-*.md files, each with valid YAML frontmatter.
+
+---
+
+### Level 5 → 6: Headless Mode
+
+Generate automation scripts directly:
+
+**scripts/headless-runner.sh:**
+```bash
+#!/bin/bash
+# Run any agent headlessly from CLI
+AGENT="${1:?Usage: headless-runner.sh <agent-name> <task>}"
+TASK="${2:?}"
+DIR=".devteam/headless-runs/$(date +%Y%m%d-%H%M%S)-${AGENT}"
+mkdir -p "$DIR"
+echo "Running $AGENT: $TASK"
+claude -p "Use the $AGENT agent to: $TASK" > "$DIR/result.txt" 2>"$DIR/stderr.log"
+echo "Done. Output: $DIR/result.txt"
+```
+
+**scripts/install-hooks.sh:**
+
+Generate a script that installs git hooks:
+- pre-commit: Quick Claude review of staged files for CRITICAL issues only
+- pre-push: Run project test suite, analyze failures with Claude if any
+- post-merge: Background memory refresh
+
+Make the hooks detect the test command from package.json or pyproject.toml.
+
+Write both scripts and make them executable:
+```bash
+chmod +x scripts/headless-runner.sh scripts/install-hooks.sh
+```
+
+Verify: scripts exist and are executable.
+
+---
+
+### Level 6 → 7: Browser Automation
+
+If .mcp.json does not exist, create it first with an empty `{"mcpServers":{}}` structure.
+Then add Playwright MCP to .mcp.json using the Edit tool:
+
+Add this server entry:
+```json
+"puppeteer": {
+  "type": "stdio",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-server-puppeteer"]
+}
+```
+
+Delegate to Agent tool to create `.claude/agents/dev-browser.md`:
+- A browser automation specialist agent
+- Can take screenshots, scrape pages, generate PDFs
+- Uses Puppeteer MCP tools
+- model: sonnet
+
+Verify: .mcp.json contains puppeteer or playwright entry.
+
+---
+
+### Level 7 → 8: Parallel Orchestrator
+
+Generate `scripts/parallel-orchestrator.sh`:
+
+A script that takes a tasks.json file with this format:
+```json
+{
+  "parallel": [
+    {"agent": "dev-backend", "task": "Implement user API"},
+    {"agent": "dev-frontend", "task": "Build user screen"}
+  ],
+  "then_sequential": [
+    {"agent": "dev-reviewer", "task": "Review all changes"}
+  ]
+}
+```
+
+Phase 1: Launch all parallel agents with `claude -p ... &`
+Phase 2: Wait for completion
+Phase 3: Run sequential agents with context from parallel results
+
+```bash
+chmod +x scripts/parallel-orchestrator.sh
+```
+
+Verify: script exists and is executable.
+
+---
+
+### Level 8 → 9: Background Agents (Cron)
+
+Generate `scripts/cron-setup.sh` with install/remove/status commands.
+
+Default cron jobs (adapt agent names to what was generated in Level 5):
+- 2 AM daily: Run test suite via tester agent
+- 3 AM Sunday: Weekly code review via reviewer agent
+- 6 AM daily: Memory refresh via memory operations
+- 4 AM Saturday: Evolution cycle (if Level 10 is set up)
+
+Logs to `.devteam/cron-logs/`.
+
+```bash
+chmod +x scripts/cron-setup.sh
+```
+
+Verify: script exists.
+
+---
+
+### Level 9 → 10: Autonomous Loop
+
+Delegate to Agent tool to create `.claude/agents/loop-controller.md`:
+
+"Create a loop controller agent at .claude/agents/loop-controller.md.
+
+This agent runs an autonomous improvement cycle:
+
+DETECT: Scan for gaps in agent coverage, skill completeness, command coverage,
+memory freshness, MCP configuration, and automation setup. Score each area 1-10.
+
+PLAN: Rank gaps by impact (critical/high/medium/low). Pick top 5.
+
+GENERATE: For each gap, create or update the component. Write agent files,
+skill files, commands, or scripts as needed.
+
+EVALUATE: After generating, validate:
+- Structural: YAML frontmatter, required fields, reasonable file lengths
+- Content: project-specificity, trigger reliability, convention enforcement
+- Cross-consistency: all references resolve, no overlapping ownership
+Rewrite anything scoring below 7/10.
+
+COMMIT or RETRY: If quality passes, log results. If not, retry (max 3 iterations).
+
+Output: Append cycle report to .devteam/evolution-log.md with:
+- Before/after scores
+- Improvements made
+- Remaining gaps
+- Next cycle recommendations
+
+YAML frontmatter:
+```yaml
+---
+name: loop-controller
+description: >
+  Autonomous improvement loop. Detects gaps in agent coverage, skill completeness,
+  and workflow efficiency. Spawns and updates components to fill gaps. Use when:
+  'evolve', 'improve', 'optimize', 'find gaps', 'what is missing'.
+tools: Read, Write, Edit, Bash, Glob, Grep, Agent
+model: opus
+memory: project
+maxTurns: 100
+---
+```
+
+Rules:
+- Max 3 iterations per component per cycle
+- Max 5 improvements per cycle
+- Never delete user-created files
+- Log everything to evolution-log.md
+- If score doesn't improve after a cycle, STOP and ask the user"
+
+Verify: loop-controller.md exists.
+
+Note: The /evolve command is already installed by the Dream Team package.
+Do NOT create a duplicate evolve.md in .claude/commands/.
+
+---
+
+## LEVEL-UP Mode
+
+1. Run Environment Scanner
+2. Calculate and present current level with progress bar
+3. Explain what the NEXT level unlocks:
+   - What capabilities it adds
+   - What concrete benefit the user gets
+4. Ask: "Want me to build Level {X+1} now?"
+5. If yes → execute that level's builder
+6. Re-scan and confirm level increase
+
+Only show the NEXT level. Don't overwhelm with all 10.
+
+---
+
+## EVOLVE Mode
+
+Requires Level 3+. If below, suggest /level-up first.
+
+1. Run gap analysis across all built components:
+   - Agent coverage: are all code directories owned by an agent?
+   - Skill coverage: does every technology have a skill?
+   - Command coverage: are standard commands present?
+   - Memory freshness: is codebase-map current?
+   - Cross-consistency: do all references resolve?
+
+2. Score environment (each area 1-10, total /70)
+
+3. Pick top 5 improvements by impact
+
+4. For each improvement, delegate to Agent tool with specific generation instructions
+
+5. Validate results — rewrite if quality < 7/10
+
+6. Report:
+```
+Evolution Cycle Complete
+
+  Score: {before} -> {after} (+{improvement})
+
+  Improvements made:
+  - {list}
+
+  Remaining gaps:
+  - {list}
+```
+
+---
+
+## Platform Notes
+
+- **Windows**: Scripts generated at Level 6+ (headless-runner, cron-setup, parallel-orchestrator,
+  install-hooks) use bash syntax. They require Git Bash, WSL, or a Unix-like shell to run.
+  When generating scripts on Windows, add a note at the top of each script about this requirement.
+- **macOS/Linux**: Scripts work natively.
+
+---
+
+## Rules
+
+1. Levels are CUMULATIVE — never skip. If Level 2 is missing, build it before Level 3.
+2. Run quality validation after every level build.
+3. Show progress updates: "[Level X] Building... done" after each step.
+4. Generated content must be PROJECT-SPECIFIC. Generic = failure.
+5. Maximum 7 subagents per project.
+6. MEMORY.md must NEVER exceed 200 lines.
+7. Never delete user-created files — only modify generated ones (dev-*).
+8. Model routing: opus for architecture/review agents, sonnet for implementation agents.
+9. If project description is too vague, ask ONE question: "What tech stack?"
+10. After INIT, always show the user their new level and available commands.
+11. Use .devteam/blueprint.json as shared state — generate it first, reference it everywhere.
+12. Every agent must read MEMORY.md before starting and report learnings after completing.
+13. When invoked via /dream, the project description comes as the user message. Parse it directly.

package/templates/commands/dream.md

@@ -0,0 +1,11 @@
+I want to build a project. Here's my idea:
+
+$ARGUMENTS
+
+Orchestrator — analyze this project idea, detect the tech stack, scan my current
+environment level (0-10), then build everything I need progressively:
+CLAUDE.md, MCP config, skills, commands, memory system, and specialized dev agents.
+
+Show me progress at each level and what was created when done.
+
+If no tech stack was mentioned above, ask me ONE question: "What technologies do you want to use?"

package/templates/commands/evolve.md

@@ -0,0 +1,3 @@
+Use the orchestrator agent to run an evolution cycle on my development environment.
+Find gaps in my agents, skills, commands, and memory. Fix what's weak.
+Show me the before/after score.

package/templates/commands/level-up.md

@@ -0,0 +1,3 @@
+Use the orchestrator agent to scan my current Claude Code environment.
+Show me what level I'm at (0-10), what I have, what I'm missing.
+Then offer to build the next level for me.