appiq-solution 1.0.1 → 1.0.3

package/appiq-installer.js

@@ -22,13 +22,20 @@ class AppiqSolutionInstaller {
     this.config = {
       version: "1.0.0",
       projectType: null, // 'greenfield' or 'brownfield'
-      techStack: {},
+      techStack: {
+        platform: null, // 'flutter', 'web', 'fullstack', 'api'
+        isFlutter: false,
+        hasUI: false,
+        database: null,
+        libraries: []
+      },
       selectedIDEs: [],
       projectName: null,
       projectIdea: null,
       targetUsers: null,
       projectPlan: null,
       planApproved: false,
+      mcpConfigs: {},
     };
   }
 
@@ -39,32 +46,47 @@ class AppiqSolutionInstaller {
     console.log(chalk.dim("https://github.com/Viktor-Hermann/APPIQ-METHOD\n"));
 
     try {
-      // Phase 1: Projekt-Typ Detection
-      await this.detectProjectType();
-      
-        // Phase 2: Projektidee erfassen
-        await this.collectProjectIdea();
+              // Phase 1: Projekt-Typ Detection
+        await this.detectProjectType();
+
+        // Phase 1.5: Tech Stack Detection (Flutter, Web, etc.)
+        await this.detectTechStack();
+
+      // Phase 2: Projektidee erfassen
+      await this.collectProjectIdea();
 
-        // Phase 3: IDE Selection (MULTISELECT)
+      // Phase 3: IDE Selection (MULTISELECT)
       await this.selectIDE();
-      
-        // Phase 4: Projektplan erstellen
-        await this.createProjectPlan();
 
-        // Phase 5: Plan-Freigabe
-        await this.approvePlan();
+      // Phase 4: Projektplan erstellen
+      await this.createProjectPlan();
 
-                // Phase 6: Installation
-      await this.performInstallation();
-      
-        // Phase 7: One-Click Setup
-      await this.setupOneClickWorkflows();
-      
-        // Phase 8: Agent-Orchestrierung vorbereiten
-        await this.setupAgentOrchestration();
+      // Phase 5: Plan-Freigabe
+      await this.approvePlan();
+
+              // Phase 6: Installation
+        await this.performInstallation();
 
-        // Phase 9: Simple Instructions
-      await this.showSimpleInstructions();
+        // Phase 7: MCP Configuration Setup
+        await this.setupMCPConfigurations();
+
+                // Phase 8: BMAD Core Configuration Setup
+        await this.setupBMADCoreConfig();
+
+        // Phase 9: Document Templates & Dependencies
+        await this.setupDocumentTemplates();
+
+        // Phase 10: Agent Dependencies System (+ Flutter Agents)
+        await this.setupAgentDependencies();
+
+        // Phase 11: BMAD Orchestration (Full Flow)
+        await this.setupBMADOrchestration();
+
+        // Phase 12: One-Click Setup
+        await this.setupOneClickWorkflows();
+
+        // Phase 13: Simple Instructions
+        await this.showSimpleInstructions();
     } catch (error) {
       console.error(chalk.red("❌ Installation failed:"), error.message);
       process.exit(1);
@@ -73,7 +95,7 @@ class AppiqSolutionInstaller {
 
   async detectProjectType() {
     console.log(chalk.yellow("🔍 Projekt-Analyse..."));
-    
+
     // Auto-Detection
     const hasPackageJson = fs.existsSync(
       path.join(this.projectRoot, "package.json")
@@ -83,15 +105,15 @@ class AppiqSolutionInstaller {
     );
     const hasExistingCode = this.hasExistingSourceCode();
     const hasDocumentation = this.hasExistingDocumentation();
-    
+
     let suggestedType = "greenfield";
     let reason = "Neues Projekt erkannt";
-    
+
     if (hasExistingCode || hasDocumentation) {
       suggestedType = "brownfield";
       reason = "Existierenden Code/Dokumentation gefunden";
     }
-    
+
     console.log(chalk.gray(`💡 Analyse: ${reason}`));
     console.log(
       chalk.gray(
@@ -102,7 +124,7 @@ class AppiqSolutionInstaller {
         }`
       )
     );
-    
+
     // User Confirmation
     const { projectType } = await inquirer.prompt([
       {
@@ -128,7 +150,7 @@ class AppiqSolutionInstaller {
         default: suggestedType,
       },
     ]);
-    
+
     this.config.projectType = projectType;
     console.log(
       chalk.green(
@@ -141,227 +163,1787 @@ class AppiqSolutionInstaller {
     );
   }
 
-  async selectIDE() {
-    console.log(chalk.yellow("🛠️ IDE Auswahl"));
-    console.log(chalk.bold.yellow.bgRed(" ⚠️  MULTISELECT: Verwenden Sie SPACEBAR zum Auswählen mehrerer IDEs! "));
-    console.log(chalk.gray("Wählen Sie ALLE IDEs aus, die Sie nutzen:\n"));
+  async selectIDE() {
+    console.log(chalk.yellow("🛠️ IDE Auswahl"));
+    console.log(
+      chalk.bold.yellow.bgRed(
+        " ⚠️  MULTISELECT: Verwenden Sie SPACEBAR zum Auswählen mehrerer IDEs! "
+      )
+    );
+    console.log(chalk.gray("Wählen Sie ALLE IDEs aus, die Sie nutzen:\n"));
+
+    const { ides } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "ides",
+        message:
+          "🎯 Welche IDEs nutzen Sie? (SPACEBAR = auswählen, ENTER = bestätigen)",
+        choices: [
+          { name: "🔵 Cursor", value: "cursor" },
+          { name: "🟣 Claude Code CLI", value: "claude-code" },
+          { name: "🟢 Windsurf", value: "windsurf" },
+          { name: "🔶 VS Code + Cline", value: "cline" },
+          { name: "🟠 Trae", value: "trae" },
+          { name: "🔴 Roo Code", value: "roo" },
+          { name: "🟪 Gemini CLI", value: "gemini" },
+          { name: "⚫ GitHub Copilot", value: "github-copilot" },
+        ],
+        validate: (input) => {
+          if (input.length === 0) {
+            return "Bitte wählen Sie mindestens eine IDE aus!";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    this.config.selectedIDEs = ides;
+    const ideNames = ides.map((ide) => this.getIDEName(ide)).join(", ");
+    console.log(chalk.green(`✅ IDEs: ${ideNames}\n`));
+  }
+
+  async detectTechStack() {
+    console.log(chalk.yellow("🔍 Tech Stack Detection"));
+    console.log(chalk.gray("Analysiere Projekt-Umgebung und Tech Stack...\n"));
+
+    // Check for Flutter
+    const isFlutter = fs.existsSync(path.join(this.projectRoot, 'pubspec.yaml'));
+    
+    // Check for existing web frameworks
+    const hasPackageJson = fs.existsSync(path.join(this.projectRoot, 'package.json'));
+    let webFramework = null;
+    
+    if (hasPackageJson) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(this.projectRoot, 'package.json'), 'utf8'));
+        if (packageJson.dependencies) {
+          const deps = Object.keys(packageJson.dependencies);
+          if (deps.includes('next')) webFramework = 'next.js';
+          else if (deps.includes('react')) webFramework = 'react';
+          else if (deps.includes('vue')) webFramework = 'vue';
+          else if (deps.includes('@nuxt/core')) webFramework = 'nuxt.js';
+          else if (deps.includes('@angular/core')) webFramework = 'angular';
+        }
+      } catch (e) {
+        // ignore package.json parsing errors
+      }
+    }
+
+    // Auto-detect or ask user
+    if (isFlutter) {
+      console.log(chalk.green("✅ Flutter Projekt erkannt!"));
+      this.config.techStack.platform = 'flutter';
+      this.config.techStack.isFlutter = true;
+      this.config.techStack.hasUI = true;
+      console.log(chalk.cyan("   → Dart MCP Server wird konfiguriert"));
+      console.log(chalk.cyan("   → Flutter Clean Architecture Agents werden geladen\n"));
+    } else if (webFramework) {
+      console.log(chalk.green(`✅ ${webFramework} Projekt erkannt!`));
+      this.config.techStack.platform = 'web';
+      this.config.techStack.hasUI = true;
+      console.log(chalk.cyan("   → shadcn/ui + v0.dev Integration wird konfiguriert\n"));
+    } else {
+      // Ask user for platform
+      const { platform } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "platform",
+          message: "🎯 Welchen Tech Stack verwenden Sie?",
+          choices: [
+            { name: "📱 Flutter Mobile App", value: "flutter" },
+            { name: "🌐 Web App (React/Next.js/Vue)", value: "web" },
+            { name: "🚀 Fullstack (Frontend + Backend)", value: "fullstack" },
+            { name: "⚡ API/Backend Only", value: "api" },
+            { name: "🤷 Noch nicht sicher", value: "unknown" },
+          ],
+        },
+      ]);
+
+      this.config.techStack.platform = platform;
+      this.config.techStack.isFlutter = platform === 'flutter';
+      this.config.techStack.hasUI = ['flutter', 'web', 'fullstack'].includes(platform);
+      
+      if (platform === 'flutter') {
+        console.log(chalk.cyan("   → Dart MCP Server wird konfiguriert"));
+        console.log(chalk.cyan("   → Flutter Clean Architecture Agents werden geladen"));
+      } else if (platform === 'web' || platform === 'fullstack') {
+        console.log(chalk.cyan("   → shadcn/ui + v0.dev Integration wird konfiguriert"));
+      }
+      console.log('');
+    }
+  }
+
+  async collectProjectIdea() {
+    console.log(chalk.yellow("💡 Projektidee erfassen"));
+    console.log(chalk.gray("Beschreiben Sie Ihr Projekt-Vorhaben:\n"));
+
+    const { projectIdea, projectName, targetUsers } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "projectName",
+        message: "🏷️ Wie soll Ihr Projekt heißen?",
+        validate: (input) =>
+          input.length > 0 ? true : "Bitte geben Sie einen Projektnamen ein!",
+      },
+      {
+        type: "editor",
+        name: "projectIdea",
+        message: "💡 Beschreiben Sie Ihre Projektidee (detailliert):",
+        validate: (input) =>
+          input.length > 10
+            ? true
+            : "Bitte beschreiben Sie Ihr Projekt ausführlicher!",
+      },
+      {
+        type: "input",
+        name: "targetUsers",
+        message: "👥 Wer sind Ihre Zielgruppen/User?",
+        validate: (input) =>
+          input.length > 0 ? true : "Bitte beschreiben Sie Ihre Zielgruppe!",
+      },
+    ]);
+
+    this.config.projectName = projectName;
+    this.config.projectIdea = projectIdea;
+    this.config.targetUsers = targetUsers;
+
+    console.log(chalk.green(`✅ Projektidee erfasst: "${projectName}"\n`));
+  }
+
+  async createProjectPlan() {
+    console.log(chalk.yellow("📋 Projektplan wird erstellt..."));
+    console.log(chalk.gray("Basierend auf Ihrer Idee und dem Projekt-Typ\n"));
+
+    // Hier würde normalerweise die team-fullstack.yaml verwendet
+    const plan = this.generateProjectPlan();
+    this.config.projectPlan = plan;
+
+    console.log(chalk.cyan("📋 Ihr Projektplan:"));
+    console.log(chalk.white("─".repeat(50)));
+    console.log(plan);
+    console.log(chalk.white("─".repeat(50) + "\n"));
+  }
+
+  async approvePlan() {
+    const { approved, changes } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "approved",
+        message: "✅ Sind Sie mit diesem Plan zufrieden?",
+        default: true,
+      },
+      {
+        type: "input",
+        name: "changes",
+        message:
+          "📝 Welche Änderungen möchten Sie? (oder ENTER für keine Änderungen)",
+        when: (answers) => !answers.approved,
+      },
+    ]);
+
+    if (!approved && changes) {
+      console.log(chalk.yellow("📝 Plan wird angepasst..."));
+      this.config.planChanges = changes;
+      // Hier würde Plan angepasst werden
+      console.log(chalk.green("✅ Plan wurde angepasst!\n"));
+    } else {
+      console.log(
+        chalk.green("✅ Plan freigegeben - Entwicklung kann starten!\n")
+      );
+    }
+
+    this.config.planApproved = true;
+  }
+
+  generateProjectPlan() {
+    const { projectType, projectName, projectIdea, targetUsers } = this.config;
+
+    return `🎯 PROJEKTPLAN: ${projectName}
+
+📊 PROJEKT-TYP: ${
+      projectType === "greenfield"
+        ? "Greenfield (Neues Projekt)"
+        : "Brownfield (Bestehendes Projekt)"
+    }
+👥 ZIELGRUPPE: ${targetUsers}
+
+💡 PROJEKTIDEE:
+${projectIdea}
+
+🚀 ENTWICKLUNGS-PIPELINE:
+${
+  projectType === "greenfield"
+    ? `
+1. 📋 PO (Product Owner) → PRD erstellen
+2. 🏗️ Architect → System-Architektur designen  
+3. 🎨 UX Expert → UI/UX Design
+4. 📝 Story Master → User Stories aufbrechen
+5. 💻 Developer → Features implementieren
+6. ✅ QA Expert → Testing & Validierung
+7. 📊 SM (Scrum Master) → Sprint-Koordination
+`
+    : `
+1. 📋 PO → Bestehende Dokumentation analysieren
+2. 🏗️ Architect → Architektur-Review
+3. 📝 Story Master → Neue Features planen
+4. 💻 Developer → Features in bestehende Basis integrieren
+5. ✅ QA Expert → Regression Testing
+6. 📊 SM → Change Management
+`
+}
+
+🎮 ONE-CLICK BEFEHLE:
+- /start → Gesamten Workflow starten
+- /plan → Detailplanung
+- /develop → Entwicklung beginnen
+- /review → Code Review
+- /deploy → Deployment vorbereiten`;
+  }
+
+  async setupBMADCoreConfig() {
+    console.log(chalk.yellow("⚙️ BMAD Core Configuration einrichten..."));
+
+    // Create .bmad-core directory
+    const bmadCoreDir = path.join(this.appiqPath, ".bmad-core");
+    if (!fs.existsSync(bmadCoreDir)) {
+      fs.mkdirSync(bmadCoreDir, { recursive: true });
+    }
+
+    // Create core-config.yaml
+    const coreConfigPath = path.join(bmadCoreDir, "core-config.yaml");
+    fs.writeFileSync(coreConfigPath, this.generateCoreConfig());
+
+    // Create technical-preferences.md
+    const techPrefsPath = path.join(bmadCoreDir, "data");
+    if (!fs.existsSync(techPrefsPath)) {
+      fs.mkdirSync(techPrefsPath, { recursive: true });
+    }
+    fs.writeFileSync(
+      path.join(techPrefsPath, "technical-preferences.md"),
+      this.generateTechnicalPreferences()
+    );
+
+    console.log(chalk.green("✅ BMAD Core Configuration bereit!\n"));
+  }
+
+  async setupDocumentTemplates() {
+    console.log(chalk.yellow("📄 Document Templates & Struktur einrichten..."));
+
+    // Create docs directory structure
+    const docsDir = path.join(this.projectRoot, "docs");
+    const archDir = path.join(docsDir, "architecture");
+    const storiesDir = path.join(docsDir, "stories");
+
+    [docsDir, archDir, storiesDir].forEach((dir) => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+
+    // Create templates
+    const templatesDir = path.join(this.appiqPath, "templates");
+    if (!fs.existsSync(templatesDir)) {
+      fs.mkdirSync(templatesDir, { recursive: true });
+    }
+
+    // PRD Template
+    fs.writeFileSync(
+      path.join(templatesDir, "prd-template.md"),
+      this.generatePRDTemplate()
+    );
+
+    // Architecture Template
+    fs.writeFileSync(
+      path.join(templatesDir, "architecture-template.md"),
+      this.generateArchitectureTemplate()
+    );
+
+    // Story Template
+    fs.writeFileSync(
+      path.join(templatesDir, "story-template.md"),
+      this.generateStoryTemplate()
+    );
+
+    // Create initial PRD if planning is complete
+    if (this.config.planApproved) {
+      fs.writeFileSync(path.join(docsDir, "prd.md"), this.generateInitialPRD());
+    }
+
+    console.log(chalk.green("✅ Document Templates erstellt!\n"));
+  }
+
+  async setupAgentDependencies() {
+    console.log(chalk.yellow("🔗 Agent Dependencies System einrichten..."));
+
+    const agentsDir = path.join(this.appiqPath, "agents");
+    const tasksDir = path.join(this.appiqPath, "tasks");
+    const dataDir = path.join(this.appiqPath, "data");
+
+    // Create directories
+    [tasksDir, dataDir].forEach((dir) => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+
+    // Create BMAD Knowledge Base
+    fs.writeFileSync(
+      path.join(dataDir, "bmad-kb.md"),
+      this.generateBMADKnowledgeBase()
+    );
+
+    // Create essential tasks
+    fs.writeFileSync(
+      path.join(tasksDir, "create-doc.md"),
+      this.generateCreateDocTask()
+    );
+    fs.writeFileSync(
+      path.join(tasksDir, "shard-doc.md"),
+      this.generateShardDocTask()
+    );
+    fs.writeFileSync(
+      path.join(tasksDir, "validate-story.md"),
+      this.generateValidateStoryTask()
+    );
+
+    // Add Flutter-specific agents if Flutter project
+    if (this.config.techStack.isFlutter) {
+      await this.addFlutterAgents();
+    }
+
+    // Update agents with proper dependencies
+    await this.updateAgentsWithDependencies();
+
+    console.log(chalk.green("✅ Agent Dependencies System bereit!\n"));
+  }
+
+  async setupBMADOrchestration() {
+    console.log(chalk.yellow("🎭 BMAD Full Orchestration einrichten..."));
+
+    // Create orchestration config based on BMAD Flow
+    const orchestrationConfig = {
+      planningPhase: {
+        agents: ["analyst", "pm", "ux-expert", "architect", "po"],
+        workflow:
+          this.config.projectType === "greenfield"
+            ? "greenfield-planning"
+            : "brownfield-planning",
+      },
+      developmentPhase: {
+        agents: ["sm", "po", "dev", "qa"],
+        workflow: "core-development-cycle",
+      },
+      transitions: {
+        planningToIDE: "document-sharding",
+        criticalCommitPoints: ["before-next-story", "after-qa-approval"],
+      },
+    };
+
+    // Generate BMAD Orchestration
+    const orchestrationPath = path.join(
+      this.appiqPath,
+      "bmad-orchestration.yaml"
+    );
+    fs.writeFileSync(
+      orchestrationPath,
+      this.generateBMADOrchestration(orchestrationConfig)
+    );
+
+    // Create workflow guides
+    const workflowsDir = path.join(this.appiqPath, "workflows");
+    if (!fs.existsSync(workflowsDir)) {
+      fs.mkdirSync(workflowsDir, { recursive: true });
+    }
+
+    fs.writeFileSync(
+      path.join(workflowsDir, "planning-workflow.md"),
+      this.generatePlanningWorkflow()
+    );
+    fs.writeFileSync(
+      path.join(workflowsDir, "development-cycle.md"),
+      this.generateDevelopmentCycle()
+    );
+    fs.writeFileSync(
+      path.join(workflowsDir, "document-sharding.md"),
+      this.generateDocumentSharding()
+    );
+
+    console.log(chalk.green("✅ BMAD Full Orchestration bereit!\n"));
+  }
+
+  generateCoreConfig() {
+    return `# BMAD Core Configuration
+# Built with ❤️ based on Bmad-Method
+
+project:
+  name: ${this.config.projectName || "Unbenanntes Projekt"}
+  type: ${this.config.projectType}
+  created: ${new Date().toISOString()}
+
+# Files that dev agent should ALWAYS load into context
+devLoadAlwaysFiles:
+  - docs/architecture/coding-standards.md
+  - docs/architecture/tech-stack.md
+  - docs/architecture/project-structure.md
+
+# Document paths configuration
+documentPaths:
+  prd: "docs/prd.md"
+  architecture: "docs/architecture.md"
+  stories: "docs/stories/"
+  templates: "appiq-solution/templates/"
+
+# Agent dependencies configuration
+dependencies:
+  templates:
+    - prd-template.md
+    - architecture-template.md
+    - story-template.md
+  tasks:
+    - create-doc.md
+    - shard-doc.md
+    - validate-story.md
+  data:
+    - bmad-kb.md
+    - technical-preferences.md
+`;
+  }
+
+  generateTechnicalPreferences() {
+    return `# Technical Preferences
+
+*Diese Datei hilft PM und Architect dabei, Ihre bevorzugten Design-Patterns und Technologien zu berücksichtigen.*
+
+## Projekt: ${this.config.projectName || "Unbenanntes Projekt"}
+**Platform:** ${this.config.techStack.platform || 'nicht definiert'}
+
+### Bevorzugte Technologien
+
+${this.config.techStack.isFlutter ? `
+**📱 Flutter Mobile Development:**
+- **Framework:** Flutter 3.35+ (beta), Dart 3.9+
+- **Architecture:** Clean Architecture with Feature-based structure
+- **State Management:** Cubit/BLoC pattern (preferred), Riverpod (alternative)
+- **Dependency Injection:** GetIt + Injectable
+- **Code Generation:** Freezed, Build Runner
+- **Backend Integration:** Firebase, Supabase, REST APIs, GraphQL
+- **Testing:** Unit Testing, Widget Testing, Integration Testing, Golden Tests
+
+**🔌 Flutter MCP Integration:**
+- **Dart MCP Server:** Automatisch konfiguriert für AI-Assistenten
+- **Hot Reload:** Via MCP für Live-Development
+- **Package Management:** pub.dev Integration via MCP
+- **Error Analysis:** Automatische Fehlererkennung via MCP
+
+**📦 Recommended Packages:**
+- **UI:** Material 3, Cupertino (iOS-style)
+- **Navigation:** go_router
+- **HTTP:** dio
+- **Local Storage:** shared_preferences, hive
+- **Image:** cached_network_image
+` : ''}
+
+${this.config.techStack.platform === 'web' || this.config.techStack.platform === 'fullstack' ? `
+**🌐 Web Development:**
+- **Framework:** React/Next.js, Vue/Nuxt, Angular
+- **UI Library:** shadcn/ui (preferred), v0.dev components, Material-UI, Chakra UI
+- **Styling:** Tailwind CSS, CSS-in-JS, SCSS
+- **AI Design:** v0.dev für Rapid Prototyping
+
+**🎨 shadcn/ui + v0.dev Integration:**
+- **Design System:** shadcn/ui als Basis-Komponenten
+- **AI-Generated Components:** v0.dev für schnelle UI-Erstellung
+- **Customization:** Tailwind CSS für individuelle Anpassungen
+- **Accessibility:** Radix-UI Primitives als Basis
+` : ''}
+
+${this.config.projectType === "greenfield" && !this.config.techStack.isFlutter ? `
+**Backend:**
+- Runtime: Node.js, Python, Go
+- Framework: Express, FastAPI, Gin
+- Database: PostgreSQL, MongoDB, Redis
+
+**DevOps:**
+- Deployment: Vercel, Railway, AWS
+- CI/CD: GitHub Actions, GitLab CI
+- Monitoring: Sentry, LogRocket
+` : ''}
+
+${this.config.projectType === "brownfield" ? `
+**Bestehende Technologien erweitern:**
+- Kompatibilität mit bestehender Code-Basis beachten
+- Minimale neue Dependencies
+- Schrittweise Migration wenn nötig
+` : ''}
+
+### Design Patterns
+${this.config.techStack.isFlutter ? `
+- **Clean Architecture** (Presentation → Domain → Data)
+- **Feature-based Structure** (/features/auth, /features/dashboard)
+- **Repository Pattern** für Datenaccess
+- **Cubit Pattern** für State Management
+- **SOLID Principles** anwenden
+` : `
+- **Architektur:** Clean Architecture, Hexagonal, MVC
+- **Code Style:** DRY, SOLID Principles, KISS
+${this.config.techStack.hasUI ? '- **Design System:** shadcn/ui für konsistente UI' : ''}
+`}
+
+### Testing & Quality
+${this.config.techStack.isFlutter ? `
+- **Dart Analysis:** Very strict linting rules
+- **Flutter Lints:** Official Flutter linting package
+- **Testing:** Minimum 80% code coverage
+- **Golden Tests:** UI consistency tests
+- **Integration Tests:** End-to-end testing
+` : `
+- **Testing:** TDD/BDD, Unit + Integration Tests
+- **Documentation:** README-driven, Inline Comments
+- **Code Quality:** ESLint + Prettier (wenn applicable)
+${this.config.techStack.hasUI ? '- **Component Testing:** Storybook für Component Documentation' : ''}
+`}
+
+### AI-Integration & MCP
+${this.config.techStack.isFlutter ? `
+- **Dart MCP Server:** Für direkten AI-Zugriff auf Flutter Tools
+- **Flutter DevTools:** MCP-basierte AI-Assistenz
+- **Package Discovery:** AI-gestützte pub.dev Suche
+- **Code Analysis:** Automatische Fehlererkennung und -behebung
+` : ''}
+${this.config.techStack.hasUI && !this.config.techStack.isFlutter ? `
+- **v0.dev Integration:** AI-generierte UI-Komponenten
+- **shadcn/ui Library:** KI-optimierte Component Library
+- **Design Tokens:** Konsistente AI-generierte Designs
+` : ''}
+
+### Coding Standards
+- **Naming:** ${this.config.techStack.isFlutter ? 'lowerCamelCase für Variablen, PascalCase für Classes' : 'camelCase für Variablen, PascalCase für Components'}
+- **Files:** ${this.config.techStack.isFlutter ? 'snake_case für Dart Dateien' : 'kebab-case für Dateien, PascalCase für Components'}
+- **Functions:** Kleine, fokussierte Funktionen (<50 Zeilen)
+- **Comments:** Erkläre WARUM, nicht WAS
+
+### Präferenzen
+- **Performance:** Optimierung vor Abstraktion
+- **Security:** Security-by-Design
+- **Accessibility:** ${this.config.techStack.isFlutter ? 'Flutter Accessibility Widget support' : 'WCAG 2.1 AA Standard'}
+- **Mobile:** Mobile-First Approach
+
+---
+*Platform: ${this.config.techStack.platform}*
+*MCP Configured: ${this.config.techStack.isFlutter ? 'Dart MCP ✅' : 'Standard'}*
+*Aktualisiert: ${new Date().toLocaleDateString("de-DE")}*
+`;
+  }
+
+  generatePRDTemplate() {
+    return `# Product Requirements Document (PRD)
+
+## Projekt: [PROJECT_NAME]
+
+### 1. Problem Statement
+*Welches Problem lösen wir?*
+
+### 2. Solution Overview  
+*Wie lösen wir das Problem?*
+
+### 3. Target Users
+*Wer sind unsere Zielgruppen?*
+
+### 4. Functional Requirements (FRs)
+*Was muss das System können?*
+
+#### 4.1 Core Features
+- [ ] Feature 1
+- [ ] Feature 2
+
+#### 4.2 Advanced Features  
+- [ ] Advanced Feature 1
+- [ ] Advanced Feature 2
+
+### 5. Non-Functional Requirements (NFRs)
+*Wie gut muss das System funktionieren?*
+
+#### 5.1 Performance
+- Response Time: < 200ms
+- Throughput: [SPECIFY]
+
+#### 5.2 Security
+- Authentication: [METHOD]
+- Authorization: [RBAC/ABAC]
+
+#### 5.3 Scalability
+- Users: [NUMBER]
+- Data: [VOLUME]
+
+### 6. User Stories & Epics
+
+#### Epic 1: [EPIC_NAME]
+- **Story 1.1:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+- **Story 1.2:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+
+#### Epic 2: [EPIC_NAME]  
+- **Story 2.1:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+- **Story 2.2:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+
+### 7. Success Metrics
+*Wie messen wir Erfolg?*
+
+- Metric 1: [DEFINITION]
+- Metric 2: [DEFINITION]
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateArchitectureTemplate() {
+    return `# System Architecture
+
+## Projekt: [PROJECT_NAME]
+
+### 1. Architecture Overview
+*High-level Systemübersicht*
+
+### 2. Technology Stack
+
+#### Frontend
+- Framework: [FRAMEWORK]
+- State Management: [STATE_MANAGEMENT]
+- Styling: [STYLING_SOLUTION]
+
+#### Backend
+- Runtime: [RUNTIME]
+- Framework: [FRAMEWORK]
+- Database: [DATABASE]
+
+#### Infrastructure
+- Hosting: [HOSTING_PLATFORM]
+- CI/CD: [CI_CD_SOLUTION]
+
+### 3. System Components
+
+#### 3.1 Frontend Components
+- Component Library
+- State Management
+- Routing
+- API Layer
+
+#### 3.2 Backend Services
+- API Layer
+- Business Logic
+- Data Access Layer
+- External Integrations
+
+### 4. Data Models
+
+#### User Model
+\`\`\`
+{
+  id: string
+  email: string
+  name: string
+  createdAt: Date
+}
+\`\`\`
+
+### 5. API Design
+
+#### Authentication
+- POST /api/auth/login
+- POST /api/auth/register
+- POST /api/auth/logout
+
+#### Core Resources
+- GET /api/[resource]
+- POST /api/[resource]
+- PUT /api/[resource]/:id
+- DELETE /api/[resource]/:id
+
+### 6. Security Considerations
+- Authentication Strategy
+- Authorization Model
+- Data Validation
+- Rate Limiting
+
+### 7. Performance Considerations
+- Caching Strategy
+- Database Optimization
+- CDN Usage
+- Lazy Loading
+
+### 8. Deployment Architecture
+- Development Environment
+- Staging Environment
+- Production Environment
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateStoryTemplate() {
+    return `# User Story: [STORY_TITLE]
+
+## Story Details
+**Als** [USER_TYPE]  
+**möchte ich** [ACTION]  
+**um** [BENEFIT]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Technical Tasks
+- [ ] Task 1: [DESCRIPTION]
+- [ ] Task 2: [DESCRIPTION]
+- [ ] Task 3: [DESCRIPTION]
+
+## Definition of Done
+- [ ] Code implemented and tested
+- [ ] Unit tests written and passing
+- [ ] Integration tests passing
+- [ ] Code reviewed and approved
+- [ ] Documentation updated
+- [ ] Deployed to staging
+- [ ] User acceptance testing completed
+
+## Dependencies
+- [ ] Dependency 1
+- [ ] Dependency 2
+
+## Estimation
+**Story Points:** [POINTS]  
+**Estimated Hours:** [HOURS]
+
+## Notes
+*Zusätzliche Notizen und Überlegungen*
+
+---
+**Sprint:** [SPRINT_NUMBER]  
+**Assigned to:** [DEVELOPER]  
+**Status:** [TODO/IN_PROGRESS/REVIEW/DONE]
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateInitialPRD() {
+    const { projectName, projectIdea, targetUsers, projectType } = this.config;
+
+    return `# Product Requirements Document (PRD)
+
+## Projekt: ${projectName}
+
+### 1. Problem Statement
+${projectIdea}
+
+### 2. Target Users
+${targetUsers}
+
+### 3. Project Type
+${
+  projectType === "greenfield"
+    ? "✨ Greenfield (Neues Projekt)"
+    : "🔧 Brownfield (Bestehendes Projekt)"
+}
+
+### 4. Functional Requirements (FRs)
+*Diese Sektion wird durch den PM Agent vervollständigt*
+
+#### 4.1 Core Features
+- [ ] Feature wird durch PM definiert
+
+### 5. Non-Functional Requirements (NFRs)
+*Diese Sektion wird durch den Architect Agent vervollständigt*
+
+### 6. User Stories & Epics
+*Diese Sektion wird durch den Story Master Agent vervollständigt*
+
+---
+**Status:** 📋 Planning Phase Complete - Ready for PM Agent  
+**Nächster Schritt:** PM Agent für detaillierte Requirements  
+**Created:** ${new Date().toLocaleDateString("de-DE")}
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateBMADKnowledgeBase() {
+    return `# BMAD Knowledge Base
+
+## The BMad Planning + Execution Workflow
+
+### Planning Workflow (Web UI or Powerful IDE Agents)
+1. **Analyst** (Optional): Market Research, Competitor Analysis, Project Brief
+2. **PM**: Create PRD from Brief with FRs, NFRs, Epics & Stories
+3. **UX Expert** (Optional): Create Front End Spec, Generate UI Prompts
+4. **Architect**: Create Architecture from PRD + UX Spec
+5. **PO**: Run Master Checklist, validate document alignment
+
+### Critical Transition: Web UI → IDE
+- Copy documents to project (docs/prd.md, docs/architecture.md)
+- Switch to IDE
+- **PO**: Shard Documents (CRITICAL STEP)
+- Begin Development Cycle
+
+### Core Development Cycle (IDE)
+1. **SM**: Review previous story dev/QA notes
+2. **SM**: Draft next story from sharded epic + architecture
+3. **PO**: Validate story draft (optional)
+4. **User Approval** of story
+5. **Dev**: Sequential task execution, implement tasks + tests
+6. **Dev**: Run all validations, mark ready for review
+7. **User Verification**: Request QA or approve
+8. **QA**: Senior dev review + active refactoring (if requested)
+9. **IMPORTANT**: Verify all regression tests and linting pass
+10. **IMPORTANT**: COMMIT CHANGES BEFORE PROCEEDING
+11. Mark story as done, loop back to SM
+
+### Key Principles
+- **Document Sharding**: Critical step after planning phase
+- **Context Management**: Keep files lean and focused
+- **Commit Regularly**: Save work frequently, especially after QA
+- **Agent Selection**: Use appropriate agent for each task
+- **Dependencies**: Each agent loads only what it needs
+
+### Special Agents
+- **BMad-Master**: Can do any task except story implementation
+- **BMad-Orchestrator**: Heavy-weight agent for web bundles only
+
+### Technical Configuration
+- **core-config.yaml**: devLoadAlwaysFiles configuration
+- **technical-preferences.md**: Bias PM/Architect recommendations
+- **Dependencies**: templates, tasks, data for each agent
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateCreateDocTask() {
+    return `# Create Document Task
+
+## Purpose
+Create structured documents following BMAD templates and standards.
+
+## Usage
+This task helps agents create consistent, well-structured documents.
+
+## Process
+1. **Identify Document Type**: PRD, Architecture, Story, etc.
+2. **Load Template**: Use appropriate template from templates/
+3. **Gather Requirements**: Collect all necessary information
+4. **Fill Template**: Replace placeholders with actual content
+5. **Validate Structure**: Ensure all sections are complete
+6. **Save Document**: Store in correct location (docs/)
+
+## Templates Available
+- prd-template.md
+- architecture-template.md
+- story-template.md
+
+## Best Practices
+- Follow template structure exactly
+- Replace ALL placeholders
+- Include creation date and status
+- Link to related documents
+- Use consistent formatting
+
+## Output Location
+- PRD: docs/prd.md
+- Architecture: docs/architecture.md
+- Stories: docs/stories/[story-name].md
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateShardDocTask() {
+    return `# Document Sharding Task
+
+## Purpose
+**CRITICAL STEP**: Break down large documents into focused, manageable pieces for agents.
+
+## When to Use
+- After planning phase completion
+- Before beginning development cycle
+- When switching from Web UI to IDE
+
+## Process
+1. **Identify Source Document**: Usually PRD or Architecture
+2. **Analyze Structure**: Find natural breaking points
+3. **Create Focused Files**: Each file serves one purpose
+4. **Maintain References**: Link shards together
+5. **Update devLoadAlwaysFiles**: Configure core-config.yaml
+
+## Sharding Strategy
+
+### PRD Sharding
+- **Core Requirements**: docs/requirements/core.md
+- **User Stories**: docs/stories/ (individual files)
+- **Success Metrics**: docs/metrics.md
+
+### Architecture Sharding
+- **Tech Stack**: docs/architecture/tech-stack.md
+- **Coding Standards**: docs/architecture/coding-standards.md
+- **Project Structure**: docs/architecture/project-structure.md
+- **API Design**: docs/architecture/api-design.md
+- **Data Models**: docs/architecture/data-models.md
+
+## Critical Points
+- **Lean Files**: Each shard should be focused and minimal
+- **Dev Context**: Sharded files go into devLoadAlwaysFiles
+- **Agent Performance**: Smaller context = better performance
+- **Maintainability**: Easier to update specific aspects
+
+## Post-Sharding
+1. Update core-config.yaml devLoadAlwaysFiles
+2. Verify all shards are accessible
+3. Test agent context loading
+4. Begin development cycle
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateValidateStoryTask() {
+    return `# Validate Story Task
+
+## Purpose
+Ensure user stories align with PRD, architecture, and project goals.
+
+## When to Use
+- Before story implementation begins
+- When SM drafts new stories
+- When stories are modified
+
+## Validation Checklist
+
+### Story Structure
+- [ ] Clear user role defined
+- [ ] Specific action described
+- [ ] Business value stated
+- [ ] Acceptance criteria present
+
+### Technical Alignment
+- [ ] Aligns with architecture decisions
+- [ ] Fits within tech stack constraints
+- [ ] Dependencies identified
+- [ ] Implementation feasible
+
+### Business Alignment
+- [ ] Supports PRD objectives
+- [ ] Addresses user needs
+- [ ] Measurable outcomes
+- [ ] Priority justified
+
+### Quality Gates
+- [ ] Testable acceptance criteria
+- [ ] Definition of done complete
+- [ ] Effort estimation reasonable
+- [ ] Risk assessment done
+
+## Process
+1. **Load References**: PRD, Architecture, related stories
+2. **Check Structure**: Verify story template compliance
+3. **Validate Alignment**: Against PRD and architecture
+4. **Assess Dependencies**: Identify blockers or prerequisites
+5. **Review Quality**: Ensure story is ready for development
+6. **Provide Feedback**: Clear recommendations for improvements
+
+## Common Issues
+- Vague acceptance criteria
+- Missing technical dependencies
+- Misalignment with architecture
+- Unrealistic scope or effort
+
+## Output
+- **Validation Status**: Pass/Fail with reasons
+- **Recommendations**: Specific improvements needed
+- **Dependencies**: List of prerequisites
+- **Risk Assessment**: Potential implementation challenges
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  async addFlutterAgents() {
+    console.log(chalk.cyan("    📱 Adding Flutter-specific agents..."));
+    
+    const agentsDir = path.join(this.appiqPath, "agents");
+    const flutterExpansionPath = path.join(__dirname, '..', 'expansion-packs', 'bmad-flutter-mobile-dev', 'agents');
+    
+    // Check if Flutter expansion pack exists
+    if (!fs.existsSync(flutterExpansionPath)) {
+      console.log(chalk.yellow("    ⚠️  Flutter expansion pack not found - creating basic Flutter agents"));
+      await this.createBasicFlutterAgents();
+      return;
+    }
+
+    // Copy Flutter agents from expansion pack
+    const flutterAgents = [
+      'flutter-ui-agent.md',
+      'flutter-cubit-agent.md', 
+      'flutter-data-agent.md',
+      'flutter-domain-agent.md',
+      'shared-components-agent.md'
+    ];
+
+    for (const agentFile of flutterAgents) {
+      const sourcePath = path.join(flutterExpansionPath, agentFile);
+      const targetPath = path.join(agentsDir, agentFile);
+      
+      if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, targetPath);
+        console.log(chalk.green(`      ✅ ${agentFile} hinzugefügt`));
+      }
+    }
+
+    // Create Flutter-specific data files
+    const dataDir = path.join(this.appiqPath, "data");
+    const flutterDataPath = path.join(__dirname, '..', 'expansion-packs', 'bmad-flutter-mobile-dev', 'data');
+    
+    if (fs.existsSync(path.join(flutterDataPath, 'flutter-development-guidelines.md'))) {
+      fs.copyFileSync(
+        path.join(flutterDataPath, 'flutter-development-guidelines.md'),
+        path.join(dataDir, 'flutter-development-guidelines.md')
+      );
+      console.log(chalk.green("      ✅ Flutter development guidelines hinzugefügt"));
+    }
+  }
+
+  async createBasicFlutterAgents() {
+    console.log(chalk.gray("    🔨 Creating basic Flutter agents..."));
+    
+    const agentsDir = path.join(this.appiqPath, "agents");
+    
+    // Basic Flutter UI Agent
+    const flutterUIAgent = this.generateBasicFlutterUIAgent();
+    fs.writeFileSync(path.join(agentsDir, 'flutter-ui-agent.md'), flutterUIAgent);
+    
+    // Basic Flutter State Management Agent
+    const flutterStateAgent = this.generateBasicFlutterStateAgent();
+    fs.writeFileSync(path.join(agentsDir, 'flutter-cubit-agent.md'), flutterStateAgent);
+    
+    console.log(chalk.green("      ✅ Basic Flutter agents created"));
+  }
+
+  generateBasicFlutterUIAgent() {
+    return `# Flutter UI Agent
+
+Du bist ein spezialisierter Flutter UI Agent, der sich auf die Erstellung von benutzerfreundlichen und responsive Mobile UI-Komponenten fokussiert.
+
+## Rolle & Verantwortung
+
+- **UI Design & Implementation:** Erstelle schöne, Material 3 konforme Flutter UIs
+- **Widget Composition:** Verwende effiziente Widget-Hierarchien
+- **Responsive Design:** Sichere Kompatibilität für verschiedene Bildschirmgrößen
+- **Accessibility:** Implementiere barrierefreie UI-Komponenten
+
+## Expertise
+
+### Flutter UI Frameworks
+- **Material 3:** Modernes Material Design
+- **Cupertino:** iOS-native Looks
+- **Custom Widgets:** Individuelle UI-Komponenten
+
+### Best Practices
+- **Widget Keys:** Für Testability und Performance
+- **Const Constructors:** Memory-Optimierung  
+- **Build Method Optimization:** Verhindere unnecessary rebuilds
+- **Theme Integration:** Konsistente Design Systems
+
+## Tech Stack Integration
+
+**Platform:** ${this.config.techStack.platform}
+**MCP:** ${this.config.techStack.isFlutter ? 'Dart MCP Server ✅' : 'Standard'}
+
+### Dart MCP Tools
+- Hot Reload via MCP
+- Widget Inspection via AI
+- pub.dev Package Discovery
+- Runtime Error Analysis
+
+## Workflow Integration
+
+**Planning Phase:** Arbeite mit UX Expert an UI Specs
+**Development Phase:** Implementiere UI basierend auf Cubit State
+**Testing Phase:** Golden Tests für UI Consistency
+
+---
+*Built with ❤️ based on Bmad-Method*
+*Flutter Clean Architecture + Dart MCP Integration*
+`;
+  }
+
+  generateBasicFlutterStateAgent() {
+    return `# Flutter Cubit State Management Agent
+
+Du bist ein spezialisierter Flutter State Management Agent mit Fokus auf Cubit/BLoC Pattern und Clean Architecture.
+
+## Rolle & Verantwortung
+
+- **State Management:** Implementiere Cubit/BLoC Pattern
+- **Clean Architecture:** Separation of Concerns (Presentation → Domain → Data)
+- **Dependency Injection:** GetIt + Injectable Setup
+- **Event Handling:** User Interactions und API Calls
+
+## Expertise
+
+### State Management
+- **Cubit:** Simple State Management für UI
+- **BLoC:** Complex Business Logic mit Events
+- **Riverpod:** Alternative State Management (if needed)
+
+### Architecture Patterns
+- **Clean Architecture:** Feature-based Structure
+- **Repository Pattern:** Data Access Layer
+- **Use Cases:** Business Logic Layer
+- **Dependency Injection:** Loose Coupling
+
+## Tech Stack Integration
+
+**Platform:** ${this.config.techStack.platform}
+**MCP:** ${this.config.techStack.isFlutter ? 'Dart MCP Server ✅' : 'Standard'}
+
+### Code Generation
+- **Freezed:** Immutable Data Classes
+- **Injectable:** Dependency Injection Setup
+- **Build Runner:** Code Generation Pipeline
+
+## Workflow Integration
+
+**Planning Phase:** Definiere State Structure mit Domain Agent
+**Development Phase:** Implementiere Business Logic
+**Testing Phase:** Unit Tests für Cubits und Use Cases
+
+---
+*Built with ❤️ based on Bmad-Method*
+*Flutter Clean Architecture + Dart MCP Integration*
+`;
+  }
+
+  async updateAgentsWithDependencies() {
+    console.log(chalk.gray("    🔗 Updating agents with BMAD dependencies..."));
+
+    const agentsDir = path.join(this.appiqPath, "agents");
+    const agents = fs.readdirSync(agentsDir);
+
+    for (const agentFile of agents) {
+      const agentPath = path.join(agentsDir, agentFile);
+      let content = fs.readFileSync(agentPath, "utf8");
+
+      // Add BMAD dependencies section to each agent
+      const dependenciesSection = `
+
+## 🔗 BMAD Dependencies
+
+### Templates
+- prd-template.md
+- architecture-template.md  
+- story-template.md
+
+### Tasks
+- create-doc.md
+- shard-doc.md
+- validate-story.md
+
+### Data
+- bmad-kb.md
+- technical-preferences.md
+
+### Configuration
+- core-config.yaml (devLoadAlwaysFiles)
+
+## 🎯 BMAD Workflow Integration
+
+**Planning Phase:** Web UI → IDE Transition → Document Sharding  
+**Development Phase:** SM → PO → Dev → QA → Loop  
+**Critical Points:** Commit before proceeding, verify tests passing
+
+`;
+
+      // Add dependencies section before the final line
+      const lines = content.split("\n");
+      const lastLine = lines.pop(); // Remove last line
+      lines.push(dependenciesSection);
+      lines.push(lastLine); // Add last line back
+
+      fs.writeFileSync(agentPath, lines.join("\n"));
+    }
+  }
+
+  generateBMADOrchestration(config) {
+    return `# BMAD Full Orchestration
+# Built with ❤️ based on Bmad-Method
+
+project:
+  name: ${this.config.projectName}
+  type: ${this.config.projectType}
+  plan_approved: ${this.config.planApproved}
+  created: ${new Date().toISOString()}
+
+# BMAD Planning Phase (Web UI/Powerful IDE)
+planning_phase:
+  workflow: ${config.planningPhase.workflow}
+  agents:
+${config.planningPhase.agents.map((agent) => `    - ${agent}`).join("\n")}
+  
+  flow:
+    1: "analyst → research & project brief (optional)"
+    2: "pm → create PRD from brief"
+    3: "ux-expert → create frontend spec (optional)"
+    4: "architect → create architecture from PRD + UX"
+    5: "po → run master checklist & validate alignment"
+
+# Critical Transition: Web UI → IDE
+transition:
+  type: ${config.transitions.planningToIDE}
+  requirements:
+    - "Copy docs/prd.md and docs/architecture.md to project"
+    - "Switch to IDE"
+    - "PO: Shard documents (CRITICAL)"
+    - "Update core-config.yaml devLoadAlwaysFiles"
+
+# BMAD Development Phase (IDE Only)
+development_phase:
+  workflow: ${config.developmentPhase.workflow}
+  agents:
+${config.developmentPhase.agents.map((agent) => `    - ${agent}`).join("\n")}
+  
+  cycle:
+    1: "sm → review previous story dev/QA notes"
+    2: "sm → draft next story from sharded epic + architecture"
+    3: "po → validate story draft (optional)"
+    4: "user → approve story"
+    5: "dev → sequential task execution + implementation"
+    6: "dev → run all validations, mark ready for review"
+    7: "user → verify (request QA or approve)"
+    8: "qa → senior dev review + active refactoring (if requested)"
+    9: "CRITICAL → verify regression tests + linting pass"
+    10: "CRITICAL → COMMIT CHANGES BEFORE PROCEEDING"
+    11: "mark story done → loop back to sm"
+
+# Critical Commit Points
+commit_points:
+${config.transitions.criticalCommitPoints
+  .map((point) => `  - ${point}`)
+  .join("\n")}
+
+# IDE Integration
+ides:
+${this.config.selectedIDEs
+  .map(
+    (ide) => `  - name: ${this.getIDEName(ide)}
+    config_path: ${this.getIDEConfig(ide).dir}
+    file_format: ${this.getIDEConfig(ide).suffix}`
+  )
+  .join("\n")}
+
+# Context Management
+context:
+  dev_always_files:
+    - docs/architecture/coding-standards.md
+    - docs/architecture/tech-stack.md
+    - docs/architecture/project-structure.md
+  
+  agent_dependencies:
+    templates: ["prd-template.md", "architecture-template.md", "story-template.md"]
+    tasks: ["create-doc.md", "shard-doc.md", "validate-story.md"]
+    data: ["bmad-kb.md", "technical-preferences.md"]
+
+---
+*Powered by Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generatePlanningWorkflow() {
+    return `# BMAD Planning Workflow
+
+## Übersicht
+Die Planungsphase folgt einem strukturierten Workflow, idealerweise in Web UI für Kosteneffizienz.
+
+## Planning Flow
+
+### 1. Start: Projektidee
+- Grundlegendes Konzept definiert
+- Problem identifiziert
+
+### 2. Analyst (Optional)
+**Brainstorming:**
+- Marktforschung
+- Konkurrenzanalyse  
+- Projekt Brief erstellen
+
+### 3. Project Manager (PM)
+**PRD Erstellung:**
+- PRD aus Brief erstellen (Fast Track)
+- ODER interaktive PRD Erstellung (mehr Fragen)
+- Functional Requirements (FRs)
+- Non-Functional Requirements (NFRs)
+- Epics & Stories definieren
+
+### 4. UX Expert (Optional)
+**Frontend Specification:**
+- Frontend Spec erstellen
+- UI Prompts für Lovable/V0 generieren (optional)
+
+### 5. System Architect  
+**Architektur Design:**
+- Architektur aus PRD erstellen
+- ODER aus PRD + UX Spec erstellen
+- Tech Stack definieren
+- System Components planen
+
+### 6. Product Owner (PO)
+**Master Checklist:**
+- Dokumenten-Alignment prüfen
+- Epics & Stories aktualisieren (falls nötig)
+- PRD/Architektur anpassen (falls nötig)
+
+## Kritischer Übergang: Web UI → IDE
+
+### ⚠️ WICHTIG: Transition Point
+Sobald PO Dokumenten-Alignment bestätigt:
+
+1. **Dokumente kopieren**: docs/prd.md und docs/architecture.md
+2. **IDE wechseln**: Projekt in bevorzugter Agentic IDE öffnen  
+3. **Document Sharding**: PO Agent zum Shard der Dokumente verwenden
+4. **Development beginnen**: Core Development Cycle starten
+
+## Qualitäts-Gates
+
+### Planning Complete Criteria
+- [ ] PRD vollständig und genehmigt
+- [ ] Architektur vollständig und genehmigt
+- [ ] UX Spec (falls erforderlich) genehmigt
+- [ ] Alle Dokumente sind aligned
+- [ ] Epics und Stories definiert
+- [ ] Übergang zu IDE vorbereitet
+
+## Nächste Schritte
+Nach Planning Complete → **Document Sharding** → **Development Cycle**
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateDevelopmentCycle() {
+    return `# BMAD Core Development Cycle
+
+## Übersicht
+Strukturierter Entwicklungsworkflow in der IDE nach abgeschlossener Planungsphase.
+
+## Voraussetzungen
+- ✅ Planning Phase abgeschlossen
+- ✅ Dokumente in Projekt kopiert (docs/prd.md, docs/architecture.md)
+- ✅ **Document Sharding** durch PO Agent durchgeführt
+- ✅ IDE-Setup komplett
+
+## Development Cycle Flow
+
+### 1. Scrum Master (SM)
+**Story Vorbereitung:**
+- Review previous story dev/QA notes
+- Draft next story from sharded epic + architecture
+- Berücksichtigt technical dependencies
+- Erstellt realistische task breakdown
+
+### 2. Product Owner (PO) - Optional
+**Story Validation:**
+- Validate story draft against artifacts
+- Überprüft alignment mit PRD
+- Bestätigt business value
+- Kann übersprungen werden bei erfahrenen Teams
+
+### 3. User Approval
+**Story Freigabe:**
+- ✅ **Approved**: Weiter zu Development
+- ❌ **Needs Changes**: Zurück zu SM für Anpassungen
+
+### 4. Developer (Dev)
+**Implementation:**
+- Sequential task execution
+- Implement tasks + tests
+- Run all validations
+- Mark ready for review + add notes
+- Dokumentiert implementation decisions
+
+### 5. User Verification
+**Review Decision:**
+- 🔍 **Request QA Review**: Weiter zu QA Agent
+- ✅ **Approve Without QA**: Direkt zu Final Checks
+- ❌ **Needs Fixes**: Zurück zu Dev
+
+### 6. QA Agent (Optional)
+**Quality Assurance:**
+- Senior dev review + active refactoring
+- Review code, refactor, add tests
+- Document notes and improvements
+- **Decision**: Needs Dev Work OR Approved
+
+### 7. Final Checks - ⚠️ CRITICAL
+**Vor dem Abschluss:**
+- ✅ Verify ALL regression tests passing
+- ✅ Verify ALL linting passing  
+- ✅ Code review completed (if QA was used)
+- ✅ Documentation updated
+
+### 8. Commit - ⚠️ SUPER CRITICAL
+**WICHTIG: COMMIT YOUR CHANGES BEFORE PROCEEDING!**
+- Git add & commit all changes
+- Include meaningful commit message
+- Push to repository
+
+### 9. Story Complete
+**Mark als Done:**
+- Story status → DONE
+- Loop back to SM for next story
+
+## Critical Points
+
+### ⚠️ Commit Points
+- **After QA Approval**: Always commit before marking done
+- **Before Next Story**: Clean state for next iteration
+
+### 🎯 Quality Gates
+- All tests passing
+- Linting clean
+- Code reviewed (if QA used)
+- Documentation current
+
+### 📊 Context Management
+- Keep relevant files only in context
+- Use sharded documents
+- Maintain lean, focused files
+
+## Best Practices
+- **Small Stories**: Keep stories manageable (< 1 week)
+- **Regular Commits**: Commit frequently during development
+- **Test First**: Write tests before or with implementation
+- **Document Decisions**: Record architectural decisions
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateDocumentSharding() {
+    return `# Document Sharding Guide
 
-    const { ides } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "ides",
-        message: "🎯 Welche IDEs nutzen Sie? (SPACEBAR = auswählen, ENTER = bestätigen)",
-        choices: [
-          { name: "🔵 Cursor", value: "cursor" },
-          { name: "🟣 Claude Code CLI", value: "claude-code" },
-          { name: "🟢 Windsurf", value: "windsurf" },
-          { name: "🔶 VS Code + Cline", value: "cline" },
-          { name: "🟠 Trae", value: "trae" },
-          { name: "🔴 Roo Code", value: "roo" },
-          { name: "🟪 Gemini CLI", value: "gemini" },
-          { name: "⚫ GitHub Copilot", value: "github-copilot" },
-        ],
-        validate: (input) => {
-          if (input.length === 0) {
-            return "Bitte wählen Sie mindestens eine IDE aus!";
-          }
-          return true;
-        },
-      },
-    ]);
+## ⚠️ CRITICAL STEP
+Document Sharding ist ein **essentieller Schritt** im BMAD Flow nach der Planungsphase.
 
-    this.config.selectedIDEs = ides;
-    const ideNames = ides.map(ide => this.getIDEName(ide)).join(", ");
-    console.log(chalk.green(`✅ IDEs: ${ideNames}\n`));
+## Wann Document Sharding durchführen?
+- ✅ Nach Planning Phase Completion
+- ✅ Beim Übergang von Web UI zu IDE  
+- ✅ Vor Beginn des Development Cycles
+- ✅ Wenn Dokumente zu groß für Agent-Context werden
+
+## Warum Document Sharding?
+- **Performance**: Kleinere Context = bessere Agent-Performance
+- **Focus**: Jede Datei dient einem spezifischen Zweck
+- **Maintainability**: Einfacher zu aktualisieren und zu verwalten
+- **Agent Efficiency**: Agents laden nur was sie brauchen
+
+## Sharding Process
+
+### 1. PRD Sharding
+**Source**: docs/prd.md  
+**Target Structure**:
+\`\`\`
+docs/
+├── requirements/
+│   ├── core.md              # Core functional requirements
+│   ├── non-functional.md    # NFRs (performance, security)
+│   └── success-metrics.md   # KPIs and success criteria
+├── stories/
+│   ├── epic-1-auth/
+│   │   ├── story-1-1-login.md
+│   │   └── story-1-2-register.md
+│   └── epic-2-dashboard/
+│       └── story-2-1-overview.md
+\`\`\`
+
+### 2. Architecture Sharding  
+**Source**: docs/architecture.md  
+**Target Structure**:
+\`\`\`
+docs/architecture/
+├── tech-stack.md           # Technology decisions
+├── coding-standards.md     # Code style and patterns  
+├── project-structure.md    # File/folder organization
+├── api-design.md          # REST/GraphQL API specs
+├── data-models.md         # Database schema
+├── security.md            # Security considerations
+└── deployment.md          # Deployment architecture
+\`\`\`
+
+## Sharding Guidelines
+
+### File Size
+- **Target**: < 50 lines per sharded file
+- **Maximum**: < 100 lines per sharded file
+- **Focus**: One concern per file
+
+### Naming Convention
+- **kebab-case**: tech-stack.md, coding-standards.md
+- **Descriptive**: Clear purpose from filename
+- **Consistent**: Follow project conventions
+
+### Content Rules
+- **Atomic**: Each file covers one topic completely
+- **Self-contained**: Can be understood independently
+- **Linked**: Reference related files when needed
+- **Lean**: Remove fluff, keep essentials
+
+## Post-Sharding Configuration
+
+### 1. Update core-config.yaml
+\`\`\`yaml
+devLoadAlwaysFiles:
+  - docs/architecture/coding-standards.md
+  - docs/architecture/tech-stack.md  
+  - docs/architecture/project-structure.md
+\`\`\`
+
+### 2. Verify Agent Access
+- Test that agents can load sharded files
+- Ensure all references are correct
+- Validate file paths in configuration
+
+### 3. Update Templates
+- Modify templates to reference sharded structure
+- Update agent prompts to use sharded files
+- Test template generation
+
+## Quality Checks
+
+### ✅ Sharding Complete Criteria
+- [ ] All large documents sharded
+- [ ] Each shard < 100 lines
+- [ ] devLoadAlwaysFiles updated
+- [ ] Agent dependencies resolved
+- [ ] File references working
+- [ ] Templates updated
+
+### 🚨 Common Mistakes
+- **Too Large**: Shards still too big (>100 lines)
+- **Too Small**: Over-sharding (many 5-line files)
+- **Broken Links**: References to old unified files
+- **Missing Config**: devLoadAlwaysFiles not updated
+
+## After Sharding
+1. **Test Agent Loading**: Verify agents can access all needed files
+2. **Begin Development**: Start Core Development Cycle
+3. **Monitor Performance**: Watch for context issues
+4. **Refine as Needed**: Adjust sharding based on usage
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
   }
 
-  async collectProjectIdea() {
-    console.log(chalk.yellow("💡 Projektidee erfassen"));
-    console.log(chalk.gray("Beschreiben Sie Ihr Projekt-Vorhaben:\n"));
+  async setupMCPConfigurations() {
+    console.log(chalk.yellow("🔌 MCP (Model Context Protocol) Setup"));
+    console.log(chalk.gray("Konfiguriere MCP Server für AI-Assistenten...\n"));
 
-    const { projectIdea, projectName, targetUsers } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "projectName",
-        message: "🏷️ Wie soll Ihr Projekt heißen?",
-        validate: (input) => input.length > 0 ? true : "Bitte geben Sie einen Projektnamen ein!"
-      },
-      {
-        type: "editor",
-        name: "projectIdea",
-        message: "💡 Beschreiben Sie Ihre Projektidee (detailliert):",
-        validate: (input) => input.length > 10 ? true : "Bitte beschreiben Sie Ihr Projekt ausführlicher!"
-      },
-      {
-        type: "input",
-        name: "targetUsers",
-        message: "👥 Wer sind Ihre Zielgruppen/User?",
-        validate: (input) => input.length > 0 ? true : "Bitte beschreiben Sie Ihre Zielgruppe!"
-      }
-    ]);
+    // Flutter/Dart MCP specific setup
+    if (this.config.techStack.isFlutter) {
+      console.log(chalk.cyan("🎯 Dart MCP Server für Flutter wird konfiguriert..."));
+      await this.setupDartMCPServer();
+    }
 
-    this.config.projectName = projectName;
-    this.config.projectIdea = projectIdea;
-    this.config.targetUsers = targetUsers;
+    // Web/Fullstack MCP setup
+    if (this.config.techStack.platform === 'web' || this.config.techStack.platform === 'fullstack') {
+      console.log(chalk.cyan("🌐 Web MCP Konfiguration..."));
+      await this.setupWebMCPServer();
+    }
 
-    console.log(chalk.green(`✅ Projektidee erfasst: "${projectName}"\n`));
+    // Configure MCP for each selected IDE
+    for (const ide of this.config.selectedIDEs) {
+      await this.configureMCPForIDE(ide);
+    }
+
+    console.log(chalk.green("✅ MCP Configuration abgeschlossen!\n"));
   }
 
-  async createProjectPlan() {
-    console.log(chalk.yellow("📋 Projektplan wird erstellt..."));
-    console.log(chalk.gray("Basierend auf Ihrer Idee und dem Projekt-Typ\n"));
+  async setupDartMCPServer() {
+    // Create Dart MCP configuration for Flutter projects
+    const dartMCPConfig = {
+      dart: {
+        command: "dart",
+        args: [
+          "mcp-server",
+          "--experimental-mcp-server"
+        ]
+      }
+    };
 
-    // Hier würde normalerweise die team-fullstack.yaml verwendet
-    const plan = this.generateProjectPlan();
-    this.config.projectPlan = plan;
+    this.config.mcpConfigs.dart = dartMCPConfig;
 
-    console.log(chalk.cyan("📋 Ihr Projektplan:"));
-    console.log(chalk.white("─".repeat(50)));
-    console.log(plan);
-    console.log(chalk.white("─".repeat(50) + "\n"));
+    // Generate setup instructions
+    const mcpInstructionsPath = path.join(this.appiqPath, 'mcp-setup-instructions.md');
+    fs.writeFileSync(mcpInstructionsPath, this.generateDartMCPInstructions());
+    
+    console.log(chalk.green("   ✅ Dart MCP Server Konfiguration erstellt"));
+    console.log(chalk.gray("   → mcp-setup-instructions.md mit Anweisungen erstellt"));
   }
 
-  async approvePlan() {
-    const { approved, changes } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "approved",
-        message: "✅ Sind Sie mit diesem Plan zufrieden?",
-        default: true
-      },
-      {
-        type: "input",
-        name: "changes",
-        message: "📝 Welche Änderungen möchten Sie? (oder ENTER für keine Änderungen)",
-        when: (answers) => !answers.approved
+  async setupWebMCPServer() {
+    // Web/shadcn/v0.dev specific MCP setup if needed
+    console.log(chalk.green("   ✅ Web MCP Konfiguration vorbereitet"));
+  }
+
+  async configureMCPForIDE(ide) {
+    const ideConfig = this.getIDEConfig(ide);
+    const mcpPath = this.getMCPConfigPath(ide);
+    
+    if (mcpPath && this.config.mcpConfigs.dart) {
+      // Create IDE-specific MCP config
+      const ideMCPDir = path.dirname(path.join(this.projectRoot, mcpPath));
+      if (!fs.existsSync(ideMCPDir)) {
+        fs.mkdirSync(ideMCPDir, { recursive: true });
       }
-    ]);
 
-    if (!approved && changes) {
-      console.log(chalk.yellow("📝 Plan wird angepasst..."));
-      this.config.planChanges = changes;
-      // Hier würde Plan angepasst werden
-      console.log(chalk.green("✅ Plan wurde angepasst!\n"));
-    } else {
-      console.log(chalk.green("✅ Plan freigegeben - Entwicklung kann starten!\n"));
+      const mcpConfigContent = this.generateMCPConfigForIDE(ide);
+      fs.writeFileSync(path.join(this.projectRoot, mcpPath), mcpConfigContent);
+      
+      console.log(chalk.green(`   ✅ ${this.getIDEName(ide)} MCP konfiguriert`));
     }
+  }
 
-    this.config.planApproved = true;
+  getMCPConfigPath(ide) {
+    const mcpPaths = {
+      cursor: '.cursor/mcp.json',
+      'claude-code': null, // Uses Gemini CLI config
+      windsurf: '.windsurf/mcp.json',
+      cline: null, // Uses VS Code config
+      trae: '.trae/mcp.json',
+      roo: '.roo/mcp.json',
+      gemini: '.gemini/settings.json',
+      'github-copilot': null, // Uses VS Code settings
+    };
+    return mcpPaths[ide];
   }
 
-  generateProjectPlan() {
-    const { projectType, projectName, projectIdea, targetUsers } = this.config;
-    
-    return `🎯 PROJEKTPLAN: ${projectName}
+  generateMCPConfigForIDE(ide) {
+    if (ide === 'gemini') {
+      return JSON.stringify({
+        mcpServers: this.config.mcpConfigs
+      }, null, 2);
+    } else {
+      return JSON.stringify({
+        mcpServers: this.config.mcpConfigs
+      }, null, 2);
+    }
+  }
 
-📊 PROJEKT-TYP: ${projectType === 'greenfield' ? 'Greenfield (Neues Projekt)' : 'Brownfield (Bestehendes Projekt)'}
-👥 ZIELGRUPPE: ${targetUsers}
+  generateDartMCPInstructions() {
+    return `# 🚀 Dart MCP Server Setup für Flutter Projekte
 
-💡 PROJEKTIDEE:
-${projectIdea}
+*Built with ❤️ based on Bmad-Method*
 
-🚀 ENTWICKLUNGS-PIPELINE:
-${projectType === 'greenfield' ? `
-1. 📋 PO (Product Owner) → PRD erstellen
-2. 🏗️ Architect → System-Architektur designen  
-3. 🎨 UX Expert → UI/UX Design
-4. 📝 Story Master → User Stories aufbrechen
-5. 💻 Developer → Features implementieren
-6. ✅ QA Expert → Testing & Validierung
-7. 📊 SM (Scrum Master) → Sprint-Koordination
-` : `
-1. 📋 PO → Bestehende Dokumentation analysieren
-2. 🏗️ Architect → Architektur-Review
-3. 📝 Story Master → Neue Features planen
-4. 💻 Developer → Features in bestehende Basis integrieren
-5. ✅ QA Expert → Regression Testing
-6. 📊 SM → Change Management
-`}
+## ⚡ Was ist der Dart MCP Server?
 
-🎮 ONE-CLICK BEFEHLE:
-- /start → Gesamten Workflow starten
-- /plan → Detailplanung
-- /develop → Entwicklung beginnen
-- /review → Code Review
-- /deploy → Deployment vorbereiten`;
-  }
+Der Dart MCP Server ermöglicht AI-Assistenten direkten Zugriff auf:
+- **Analyse und Fehlerbehebung** in Ihrem Code
+- **Interaktion mit laufender App** (Hot Reload, Widget-Inspektion)
+- **pub.dev Suche** nach passenden Packages
+- **Dependency Management** in pubspec.yaml
+- **Test-Ausführung** und Analyse
 
-  async setupAgentOrchestration() {
-    console.log(chalk.yellow("🎭 Agent-Orchestrierung vorbereiten..."));
-    
-    // Team-Fullstack.yaml Integration
-    const orchestrationConfig = {
-      agents: ['po', 'architect', 'ux-expert', 'story-master', 'developer', 'qa-expert', 'sm'],
-      workflows: this.config.projectType === 'greenfield' ? 
-        ['greenfield-fullstack.yaml', 'greenfield-ui.yaml', 'greenfield-service.yaml'] :
-        ['brownfield-fullstack.yaml', 'brownfield-ui.yaml', 'brownfield-service.yaml'],
-      planApproved: this.config.planApproved
-    };
+## 🔧 Setup für Ihre IDEs
 
-    // Orchestrierung-Datei erstellen
-    const orchestrationPath = path.join(this.appiqPath, 'orchestration.yaml');
-    fs.writeFileSync(orchestrationPath, this.generateOrchestrationConfig(orchestrationConfig));
+### ${this.config.selectedIDEs.includes('cursor') ? '✅ Cursor' : '❌ Cursor (nicht ausgewählt)'}
+${this.config.selectedIDEs.includes('cursor') ? `
+**Automatisch konfiguriert!** ✅
+- Datei: \`.cursor/mcp.json\`
+- Bereit für Verwendung
+` : ''}
 
-    console.log(chalk.green("✅ Agent-Orchestrierung vorbereitet!\n"));
-  }
+### ${this.config.selectedIDEs.includes('claude-code') ? '✅ Claude Code CLI' : '❌ Claude Code CLI (nicht ausgewählt)'}
+${this.config.selectedIDEs.includes('claude-code') ? `
+**Setup-Schritte:**
+1. \`gemini\` CLI installieren falls noch nicht vorhanden
+2. Konfiguration in \`~/.gemini/settings.json\` bereits erstellt
+3. Verwenden Sie: \`/mcp\` um verfügbare Tools anzuzeigen
+` : ''}
 
-  generateOrchestrationConfig(config) {
-    return `# Appiq Solution Agent Orchestration
-# Built with ❤️ based on Bmad-Method
+### ${this.config.selectedIDEs.includes('github-copilot') ? '✅ GitHub Copilot in VS Code' : '❌ GitHub Copilot (nicht ausgewählt)'}
+${this.config.selectedIDEs.includes('github-copilot') ? `
+**Setup-Schritte:**
+1. VS Code Settings öffnen
+2. Hinzufügen: \`"dart.mcpServer": true\`
+3. Optional: \`"chat.mcp.discovery.enabled": true\`
+` : ''}
 
-project:
-  name: ${this.config.projectName}
-  type: ${this.config.projectType}
-  plan_approved: ${this.config.planApproved}
+## 📋 Voraussetzungen
 
-agents:
-${config.agents.map(agent => `  - ${agent}`).join('\n')}
+⚠️ **Wichtig:** Dart SDK 3.9+ / Flutter 3.35+ beta erforderlich!
 
-workflows:
-${config.workflows.map(workflow => `  - ${workflow}`).join('\n')}
+\`\`\`bash
+# Flutter auf beta channel wechseln
+flutter channel beta
+flutter upgrade
+\`\`\`
 
-execution_order:
-  1: "po → PRD & Requirements"
-  2: "architect → System Design"  
-  3: "ux-expert → UI/UX Design"
-  4: "story-master → User Stories"
-  5: "developer → Implementation"
-  6: "qa-expert → Testing"
-  7: "sm → Sprint Management"
+## 🎯 Verwendung
 
-ides:
-${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
+Nach dem Setup können Sie Ihren AI-Assistenten fragen:
+
+- **"Analysiere Fehler in meiner Flutter App"**
+- **"Finde ein Package für Karten-Integration"**
+- **"Führe Tests aus und zeige Ergebnisse"**
+- **"Triggere Hot Reload"**
+- **"Was ist das aktuell ausgewählte Widget?"**
+
+## 🔗 Weitere Infos
+
+📖 **Vollständige Dokumentation:**
+https://medium.com/flutter/supercharge-your-dart-flutter-development-experience-with-the-dart-mcp-server-2edcc8107b49
+
+---
+*Erstellt am: ${new Date().toLocaleDateString('de-DE')}*
+*IDEs: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}*
 `;
   }
 
   async performInstallation() {
     console.log(chalk.yellow("📦 Installation läuft..."));
-    
+
     // Create appiq-solution directory
     if (!fs.existsSync(this.appiqPath)) {
       fs.mkdirSync(this.appiqPath, { recursive: true });
     }
-    
+
     // Install optimized agents
     await this.installOptimizedAgents();
-    
+
     // Install project-specific configs
     await this.installProjectConfig();
-    
+
     // Setup IDE integration
     await this.setupIDEIntegration();
-    
+
     console.log(chalk.green("✅ Installation abgeschlossen!\n"));
   }
 
   async installOptimizedAgents() {
     console.log(chalk.gray("  📄 Optimierte Agents installieren..."));
-    
+
     const agentsDir = path.join(this.appiqPath, "agents");
     if (!fs.existsSync(agentsDir)) {
       fs.mkdirSync(agentsDir, { recursive: true });
     }
-    
+
     // Core optimized agents
     const agents = [
       "smart-launcher",
@@ -371,7 +1953,7 @@ ${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
       "developer",
       "qa-expert",
     ];
-    
+
     for (const agent of agents) {
       await this.createOptimizedAgent(agent);
     }
@@ -425,7 +2007,7 @@ ${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
     };
 
     const config = agentConfigs[agentName];
-    
+
     return `# ${config.name}
 
 ## 🎯 Rolle
@@ -455,7 +2037,9 @@ ${
 3. **Verwenden Sie:** ${config.commands[0]} für Quick-Start
 
 ---
-*Automatisch optimiert für ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}*
+*Automatisch optimiert für ${this.config.selectedIDEs
+      .map((ide) => this.getIDEName(ide))
+      .join(", ")}*
 *Powered by Appiq - Based on Bmad-Method*
 `;
   }
@@ -546,116 +2130,214 @@ ${
 
   async setupOneClickWorkflows() {
     console.log(chalk.yellow("⚡ One-Click Workflows einrichten..."));
-    
+
     // Create quick commands
     const commandsDir = path.join(this.appiqPath, "commands");
     if (!fs.existsSync(commandsDir)) {
       fs.mkdirSync(commandsDir, { recursive: true });
     }
-    
+
     // Project-type specific quick starts
     const quickStartContent = this.generateQuickStartScript();
     fs.writeFileSync(
       path.join(commandsDir, "quick-start.md"),
       quickStartContent
     );
-    
+
     console.log(chalk.green("✅ One-Click Workflows bereit!\n"));
   }
 
   generateQuickStartScript() {
-    return `# 🚀 Appiq Solution Quick Start
+    return `# 🚀 Appiq Solution - BMAD Workflow Guide
 
-## Für ${
-      this.config.projectType === "greenfield" ? "NEUE" : "BESTEHENDE"
-    } Projekte
+## Projekt: ${this.config.projectName || "Unbenanntes Projekt"}
+**Typ:** ${
+      this.config.projectType === "greenfield"
+        ? "✨ Greenfield (Neues Projekt)"
+        : "🔧 Brownfield (Bestehendes Projekt)"
+    }
 
-### ⚡ One-Command Start:
+## 📋 BMAD Planning Workflow (Phase 1)
 
-\`\`\`bash
-# In Ihrer IDE, kopieren Sie einfach:
-${
-  this.config.projectType === "greenfield"
-    ? "/start new-project"
-    : "/analyze existing-project"
-}
+### Option A: Web UI Planning (Kosteneffizient)
+1. Claude/Gemini/GPT mit team-fullstack Bundle verwenden
+2. **Flow:** Analyst → PM → UX Expert → Architect → PO
+3. **Output:** docs/prd.md, docs/architecture.md
+
+### Option B: IDE Planning (Leistungsstark)
+\`\`\`
+@analyst → Market Research & Project Brief
+@pm → PRD mit FRs, NFRs, Epics & Stories erstellen
+@ux-expert → Frontend Spec (optional)
+@architect → System Architecture design  
+@po → Master Checklist & Document Alignment
+\`\`\`
+
+## ⚠️ KRITISCHER ÜBERGANG: Document Sharding
+
+**ESSENTIAL STEP:**
 \`\`\`
+@po bitte shard die PRD und Architecture Dokumente in fokussierte Dateien
+\`\`\`
+
+**Das erstellt:**
+- docs/architecture/tech-stack.md ← Dev lädt immer
+- docs/architecture/coding-standards.md ← Dev lädt immer  
+- docs/architecture/project-structure.md ← Dev lädt immer
+- docs/requirements/core.md
+- docs/stories/ (individual story files)
+
+## 🚀 BMAD Development Cycle (Phase 2)
+
+### Core Development Loop:
+\`\`\`
+1. @sm → Review previous notes, draft next story from sharded epic
+2. @po → Validate story draft (optional)
+3. User → Approve story
+4. @dev → Sequential tasks, implement + tests, mark ready  
+5. User → Verify (request QA or approve)
+6. @qa → Senior dev review + refactoring (optional)
+7. ⚠️ CRITICAL: Verify tests + linting pass
+8. ⚠️ SUPER CRITICAL: COMMIT CHANGES BEFORE PROCEEDING!
+9. Mark story done → Loop back to @sm
+\`\`\`
+
+## 🎯 One-Click Commands
+
+### Planning:
+- \`/plan\` → Start planning workflow
+- \`/prd\` → Generate PRD
+- \`/arch\` → Design architecture
 
-### 📁 Wo gehört was hin?
+### Critical Transition:
+- \`/shard\` → Document sharding (ESSENTIAL!)
 
+### Development:
+- \`/story\` → Draft next story
+- \`/dev\` → Start development
+- \`/test\` → Run tests
+- \`/qa\` → Request review
+- \`/commit\` → Commit changes
+
+### ${
+      this.config.projectType === "greenfield" ? "Greenfield" : "Brownfield"
+    } Specific:
 ${
   this.config.projectType === "greenfield"
     ? `
-**NEUE PROJEKTE:**
-- ✅ **PRD:** \`docs/prd.md\` (wird automatisch erstellt)
-- ✅ **Architektur:** \`docs/architecture.md\` (wird automatisch erstellt)  
-- ✅ **Stories:** \`docs/stories/\` (wird automatisch erstellt)
-- ✅ **Code:** Ihr gewähltes Projekt-Layout
-
-*Erstellt mit Appiq Solution - Basierend auf Bmad-Method*
+- \`/start\` → Fresh project setup
+- \`/design\` → Create from scratch
+- \`/build\` → Build step by step
 `
     : `
-**BESTEHENDE PROJEKTE:**
-- ✅ **PRD:** Legen Sie bestehende PRD in \`docs/prd.md\`
-- ✅ **Architektur:** Bestehende Architektur in \`docs/architecture.md\`
-- ✅ **Stories:** Neue Features in \`docs/stories/\`
-- ✅ **Code:** Arbeitet mit Ihrer bestehenden Struktur
+- \`/analyze\` → Analyze existing code
+- \`/document\` → Document current state
+- \`/improve\` → Plan improvements
 `
 }
 
-### 🎯 3-Schritt Erfolgsformel:
+## 📊 File Structure
 
-1. **Agent laden** → Agent-Datei in IDE kopieren
-2. **Kommando ausführen** → \`${
-      this.config.projectType === "greenfield" ? "/start" : "/analyze"
-    }\`
-3. **Folgen Sie den automatischen Anweisungen** → System führt Sie durch alles
+\`\`\`
+your-project/
+├── docs/
+│   ├── prd.md              ← Initial PRD
+│   ├── architecture.md     ← Initial Architecture
+│   ├── architecture/       ← Sharded files
+│   │   ├── tech-stack.md
+│   │   ├── coding-standards.md
+│   │   └── project-structure.md
+│   ├── requirements/
+│   │   └── core.md
+│   └── stories/
+│       ├── epic-1-auth/
+│       └── epic-2-features/
+├── appiq-solution/
+│   ├── agents/             ← AI-Agents
+│   ├── templates/          ← Document templates
+│   ├── workflows/          ← Workflow guides
+│   └── .bmad-core/         ← BMAD configuration
+└── .cursor/rules/          ← IDE integration
+\`\`\`
+
+## ⚠️ Critical Success Factors
+
+### Document Sharding (ESSENTIAL):
+- **MUST DO** after planning phase
+- Creates focused, lean files for agents
+- Improves agent performance dramatically
+
+### Commit Points:
+- After QA approval (always!)
+- Before next story (clean state)
+- Regular commits during development
 
-### 🆘 Hilfe:
+### Quality Gates:
+- All tests passing ✅
+- Linting clean ✅  
+- Code reviewed (if QA used) ✅
+- Documentation updated ✅
 
-- **\`/help\`** - Zeigt alle verfügbaren Kommandos
-- **\`/status\`** - Aktueller Projekt-Status
-- **\`/next\`** - Was ist der nächste Schritt?
+## 🆘 Help & Support
+
+- \`/help\` → Show all commands
+- \`/workflow\` → Current workflow step
+- \`/agents\` → Available agents
+- \`/docs\` → Documentation
+
+### Workflow Files:
+- appiq-solution/workflows/planning-workflow.md
+- appiq-solution/workflows/development-cycle.md
+- appiq-solution/workflows/document-sharding.md
 
 ---
-*Optimiert für ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')} - ${new Date().toLocaleDateString("de-DE")}*
-*Powered by Appiq Solution - Built with ❤️  based on Bmad-Method*
+**IDEs:** ${this.config.selectedIDEs
+      .map((ide) => this.getIDEName(ide))
+      .join(", ")}  
+**Created:** ${new Date().toLocaleDateString("de-DE")}  
+**Powered by Appiq Solution - Built with ❤️ based on Bmad-Method**
 `;
   }
 
   async setupIDEIntegration() {
-    if (this.config.selectedIDEs.includes("manual") && this.config.selectedIDEs.length === 1) return;
+    if (
+      this.config.selectedIDEs.includes("manual") &&
+      this.config.selectedIDEs.length === 1
+    )
+      return;
 
     console.log(chalk.gray("  🔧 Mehrere IDE-Integrationen..."));
 
     for (const ide of this.config.selectedIDEs) {
       if (ide === "manual") continue;
-      
-      console.log(chalk.gray(`    📝 ${this.getIDEName(ide)} wird konfiguriert...`));
-      
+
+      console.log(
+        chalk.gray(`    📝 ${this.getIDEName(ide)} wird konfiguriert...`)
+      );
+
       const ideConfig = this.getIDEConfig(ide);
-    const ideDir = path.join(this.projectRoot, ideConfig.dir);
-    
-    if (!fs.existsSync(ideDir)) {
-      fs.mkdirSync(ideDir, { recursive: true });
-    }
-    
-    // Copy agents to IDE-specific format
+      const ideDir = path.join(this.projectRoot, ideConfig.dir);
+
+      if (!fs.existsSync(ideDir)) {
+        fs.mkdirSync(ideDir, { recursive: true });
+      }
+
+      // Copy agents to IDE-specific format
       const agentsPath = path.join(this.appiqPath, "agents");
-    const agents = fs.readdirSync(agentsPath);
-    
-    for (const agent of agents) {
-      const sourcePath = path.join(agentsPath, agent);
+      const agents = fs.readdirSync(agentsPath);
+
+      for (const agent of agents) {
+        const sourcePath = path.join(agentsPath, agent);
         const targetPath = path.join(
           ideDir,
           agent.replace(".md", ideConfig.suffix)
         );
-      fs.copyFileSync(sourcePath, targetPath);
+        fs.copyFileSync(sourcePath, targetPath);
       }
-      
+
       console.log(chalk.green(`    ✅ ${this.getIDEName(ide)} konfiguriert`));
     }
-    
+
     console.log(chalk.green("  ✅ Alle IDE-Integrationen abgeschlossen!"));
   }
 
@@ -696,45 +2378,68 @@ ${
     console.log(chalk.cyan("📋 Nächste Schritte (Super einfach):"));
     console.log(chalk.white("════════════════════════════════════\n"));
 
-    if (this.config.selectedIDEs.length > 0 && !this.config.selectedIDEs.includes("manual")) {
+    if (
+      this.config.selectedIDEs.length > 0 &&
+      !this.config.selectedIDEs.includes("manual")
+    ) {
+      console.log(
+        chalk.yellow(
+          `1. Ihre IDEs öffnen: ${this.config.selectedIDEs
+            .map((ide) => this.getIDEName(ide))
+            .join(", ")}`
+        )
+      );
+      console.log(
+        chalk.gray(`   → Agents sind bereits in allen IDEs installiert!\n`)
+      );
+    }
+
+    console.log(chalk.yellow("2. 📋 BMAD Planning Workflow:"));
+    if (this.config.planApproved) {
       console.log(
-        chalk.yellow(`1. Ihre IDEs öffnen: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+        chalk.green(`   ✅ Planning Complete - Ready for Development!`)
       );
-      console.log(chalk.gray(`   → Agents sind bereits in allen IDEs installiert!\n`));
+      console.log(chalk.cyan(`   → Ihre initial PRD: docs/prd.md`));
+    } else {
+      console.log(chalk.cyan(`   Option A: Web UI (kosteneffizient)`));
+      console.log(chalk.gray(`   → Claude/Gemini/GPT mit Agents verwenden`));
+      console.log(chalk.cyan(`   Option B: Direkt in IDE`));
+      console.log(chalk.gray(`   → @pm für PRD, @architect für Architecture`));
     }
+    console.log("");
 
-    console.log(chalk.yellow("2. Appiq Launcher laden:"));
+    console.log(chalk.yellow("3. ⚠️ KRITISCHER ÜBERGANG: Document Sharding"));
     console.log(
-      chalk.white(
-        `   → Kopieren Sie: ${chalk.bold(
-          "appiq-solution/agents/smart-launcher.md"
+      chalk.red(
+        `   → Sagen Sie Ihrer IDE: ${chalk.bold(
+          '"@po bitte shard die PRD und Architecture Dokumente"'
         )}`
       )
     );
-    console.log(chalk.gray(`   → In Ihre IDE einfügen\n`));
-    
-    console.log(chalk.yellow("3. Sagen Sie Ihrer IDE:"));
     console.log(
-      chalk.white(`   → ${chalk.bold('"Agiere als Appiq Launcher"')}\n`)
+      chalk.gray(`   → Dokumente werden in fokussierte Teile aufgeteilt\n`)
     );
 
-    console.log(chalk.yellow("4. One-Command Start:"));
-    console.log(
-      chalk.white(
-        chalk.bold(
-          `   → ${
-            this.config.projectType === "greenfield" ? "/start" : "/analyze"
-          }`
-        )
-      )
-    );
-    console.log(
-      chalk.gray(`   → Das System führt Sie automatisch durch alles!\n`)
-    );
+    console.log(chalk.yellow("4. 🚀 BMAD Development Cycle:"));
+    console.log(chalk.cyan(`   1. @sm → Story Draft von Sharded Epic`));
+    console.log(chalk.cyan(`   2. @po → Story Validation (optional)`));
+    console.log(chalk.cyan(`   3. User → Story Approval`));
+    console.log(chalk.cyan(`   4. @dev → Implementation + Tests`));
+    console.log(chalk.cyan(`   5. @qa → Code Review (optional)`));
+    console.log(chalk.red(`   6. ⚠️ COMMIT CHANGES BEFORE PROCEEDING!`));
+    console.log(chalk.gray(`   → Loop zurück zu @sm für nächste Story\n`));
+
+    console.log(chalk.yellow("5. 🎯 Quick Commands (in quick-start.md):"));
+    console.log(chalk.cyan(`   /plan → Planning starten`));
+    console.log(chalk.cyan(`   /shard → Document Sharding`));
+    console.log(chalk.cyan(`   /story → Nächste Story`));
+    console.log(chalk.cyan(`   /dev → Development`));
+    console.log(chalk.cyan(`   /qa → Quality Review`));
+    console.log(chalk.gray(`   → Alle Details in appiq-solution/workflows/\n`));
 
     console.log(chalk.cyan("🎯 Das war's! Kein komplizierter Setup mehr."));
     console.log(chalk.green("🚀 Viel Erfolg mit Appiq!\n"));
-    
+
     // Quick reference
     console.log(chalk.dim("━".repeat(50)));
     console.log(chalk.dim("📁 Quick Reference:"));
@@ -744,7 +2449,11 @@ ${
     );
     console.log(chalk.dim(`   • Projekt-Typ: ${this.config.projectType}`));
     console.log(
-      chalk.dim(`   • IDEs: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+      chalk.dim(
+        `   • IDEs: ${this.config.selectedIDEs
+          .map((ide) => this.getIDEName(ide))
+          .join(", ")}`
+      )
     );
   }
 
@@ -753,8 +2462,8 @@ ${
     const sourceDirs = ["src", "lib", "app", "components", "pages"];
     return sourceDirs.some(
       (dir) =>
-      fs.existsSync(path.join(this.projectRoot, dir)) && 
-      fs.readdirSync(path.join(this.projectRoot, dir)).length > 0
+        fs.existsSync(path.join(this.projectRoot, dir)) &&
+        fs.readdirSync(path.join(this.projectRoot, dir)).length > 0
     );
   }
 
@@ -780,7 +2489,7 @@ version: "1.0.0"
 project:
   type: ${this.config.projectType}
   created: ${new Date().toISOString()}
-  name: ${this.config.projectName || 'Unbenanntes Projekt'}
+  name: ${this.config.projectName || "Unbenanntes Projekt"}
   plan_approved: ${this.config.planApproved}
 
 # Wo die wichtigen Dateien liegen
@@ -807,21 +2516,25 @@ workflows:
 
 # IDE Integration (Mehrere IDEs)
 ides:
-${this.config.selectedIDEs.map(ide => `  - name: ${this.getIDEName(ide)}
+${this.config.selectedIDEs
+  .map(
+    (ide) => `  - name: ${this.getIDEName(ide)}
     config_path: ${this.getIDEConfig(ide).dir}
-    file_format: ${this.getIDEConfig(ide).suffix}`).join('\n')}
+    file_format: ${this.getIDEConfig(ide).suffix}`
+  )
+  .join("\n")}
 `;
   }
 }
 
-// Run installer if called directly  
+// Run installer if called directly
 if (require.main === module) {
   // Check if 'install' command is provided
   const args = process.argv.slice(2);
 
   if (args.length === 0 || args[0] === "install") {
     const installer = new AppiqSolutionInstaller();
-  installer.install().catch(console.error);
+    installer.install().catch(console.error);
   } else {
     console.log(
       chalk.red("❌ Unknown command. Use: npx appiq-solution install")