bmad-method 4.43.0 → 4.43.1

package/expansion-packs/bmad-godot-game-dev/workflows/game-prototype.yaml

@@ -0,0 +1,213 @@
+workflow:
+  id: godot-game-prototype
+  name: Godot Rapid Prototype Development
+  description: Godot-optimized workflow leveraging the engine's rapid prototyping features - @tool scripts, built-in nodes, CSG geometry, immediate mode GUI, and GDScript's duck typing. Emphasizes Godot's hot reload, in-editor testing, and scene-based iteration for validating game concepts in hours, not days.
+  type: prototype
+  project_types:
+    - godot-game-jam
+    - godot-mechanic-test
+    - godot-shader-demo
+    - godot-physics-sandbox
+    - godot-ui-experiment
+    - godot-multiplayer-test
+  prototype_sequence:
+    - step: concept_definition
+      agent: game-designer
+      duration: 15-30 minutes
+      creates: concept-summary.md
+      notes: Define concept leveraging Godot's strengths - built-in physics (Box2D/Bullet), particle systems, shaders, or procedural generation. Identify which Godot nodes will drive the core mechanic.
+    - step: rapid_design
+      agent: game-designer
+      duration: 30-60 minutes
+      creates: prototype-spec.md
+      requires: concept-summary.md
+      optional_steps:
+        - godot_node_selection
+        - scene_structure_sketch
+        - input_action_mapping
+      notes: Map mechanics to specific Godot nodes (Area2D, CharacterBody2D, RigidBody2D). Define scene hierarchy and signal connections. Plan InputMap actions for immediate responsiveness.
+    - step: technical_planning
+      agent: game-developer
+      duration: 15-30 minutes
+      creates: prototype-architecture.md
+      requires: prototype-spec.md
+      notes: Plan Godot-specific implementation - scene structure, autoload needs, @tool scripts for in-editor testing. Use GDScript for all prototype code (duck typing speeds iteration). Identify built-in nodes to leverage.
+    - step: implementation_stories
+      agent: game-sm
+      duration: 30-45 minutes
+      creates: prototype-stories/
+      requires: prototype-spec.md, prototype-architecture.md
+      notes: Create 3-5 Godot-focused stories - "Create player scene with CharacterBody2D", "Implement _physics_process movement", "Connect Area2D signals for interactions". Each story includes specific node types and Godot methods.
+    - step: iterative_development
+      agent: game-developer
+      duration: varies
+      implements: prototype-stories/
+      notes: Use Godot's hot reload and @tool scripts for real-time iteration. Test in editor with F6 (scene) and F5 (project). Profile with Godot's built-in monitors. Use Remote Debugger for mobile testing. Document which built-in nodes work best.
+  workflow_end:
+    action: prototype_evaluation
+    notes: "Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive."
+  game_jam_sequence:
+    - step: jam_concept
+      agent: game-designer
+      duration: 10-15 minutes
+      creates: jam-concept.md
+      notes: Match jam theme to Godot's built-in capabilities. Identify hero nodes (e.g., CPUParticles2D for effects, AudioStreamPlayer2D for dynamic audio). Define InputMap actions.
+    - step: jam_implementation
+      agent: game-developer
+      duration: varies (jam timeline)
+      creates: working-prototype
+      requires: jam-concept.md
+      notes: Build directly in Godot editor. Use built-in nodes, CSG for 3D prototypes, immediate GUI for quick UI. Leverage Godot's animation player for juice. Export to HTML5 for easy sharing. Keep scenes under 100 nodes for performance.
+  jam_workflow_end:
+    action: jam_submission
+    notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise.
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Prototype Project] --> B{Development Context?}
+        B -->|Standard Prototype| C[game-designer: concept-summary.md]
+        B -->|Game Jam| D[game-designer: jam-concept.md]
+
+        C --> E[game-designer: prototype-spec.md]
+        E --> F[game-developer: prototype-architecture.md]
+        F --> G[game-sm: create prototype stories]
+        G --> H[game-developer: iterative implementation]
+        H --> I[Prototype Evaluation]
+
+        D --> J[game-developer: direct implementation]
+        J --> K[Game Jam Submission]
+
+        E -.-> E1[Optional: quick brainstorming]
+        E -.-> E2[Optional: reference research]
+
+        style I fill:#90EE90
+        style K fill:#90EE90
+        style C fill:#FFE4B5
+        style E fill:#FFE4B5
+        style F fill:#FFE4B5
+        style G fill:#FFE4B5
+        style H fill:#FFE4B5
+        style D fill:#FFB6C1
+        style J fill:#FFB6C1
+    ```
+  godot_specific_features:
+    rapid_prototyping_tools:
+      - Tool scripts for in-editor testing without running
+      - CSG nodes for quick 3D geometry without modeling
+      - Immediate mode drawing for debug visualizations
+      - Built-in placeholder assets (icon.svg, default theme)
+      - Hot reload for GDScript changes
+    prototype_acceleration:
+      - F6 to test current scene instantly
+      - F5 to run full project
+      - Remote debugging on devices
+      - Live scene editing while running
+      - Inspector value tweaking in real-time
+    godot_node_combinations:
+      quick_player: CharacterBody2D + CollisionShape2D + Sprite2D
+      pickup_system: Area2D + signal connections
+      physics_toy: RigidBody2D + joints + constraints
+      particle_effects: CPUParticles2D with built-in parameters
+      ui_prototype: Control + containers + theme variations
+    export_for_testing:
+      - HTML5 export for easy web sharing
+      - One-click APK export for Android testing
+      - Debug export with remote debugger enabled
+      - PCK files for quick distribution
+  decision_guidance:
+    use_prototype_sequence_when:
+      - Testing Godot-specific features (shaders, particles, physics)
+      - Validating scene composition strategies
+      - Experimenting with Godot's node system combinations
+      - Building with Godot's animation tools (AnimationPlayer, AnimationTree)
+      - Testing Godot export targets (HTML5, Mobile, Desktop)
+      - Learning Godot's signal patterns and node communication
+    use_game_jam_sequence_when:
+      - Godot Game Jam participation
+      - Leveraging Godot's rapid development features
+      - Using CSG for quick 3D prototypes
+      - Building with Godot's immediate mode GUI
+      - Testing Godot's networking capabilities quickly
+  godot_prototype_best_practices:
+    godot_rapid_development:
+      - Use @tool scripts to test mechanics in editor without running
+      - Leverage Godot's hot reload for immediate feedback
+      - Build scenes incrementally with F6 (test current scene)
+      - Use placeholder Godot icons and CSG shapes
+    godot_node_leverage:
+      - Start with Godot's template projects when applicable
+      - Use Area2D for all detection/trigger needs
+      - Implement with CharacterBody2D's built-in movement methods
+      - Apply RigidBody2D for physics toys
+      - Use Control nodes with containers for auto-layout UI
+    godot_iteration_tools:
+      - Run scenes directly with F6 during development
+      - Use Godot's remote debugger for device testing
+      - Monitor performance with built-in profiler (not external tools)
+      - Adjust project settings in real-time
+      - Use editor's node property tweaking for balancing
+    godot_prototyping_patterns:
+      - Compose scenes, don't code everything
+      - Signal connections over hard references
+      - Export variables for in-editor tweaking
+      - AnimationPlayer for all timed events
+      - Resource files (.tres) for data-driven design
+  godot_prototype_evaluation:
+    godot_mechanic_validation:
+      - Does the mechanic work well with Godot's physics engine?
+      - Are Godot's built-in nodes sufficient or do we need custom?
+      - Can the mechanic scale with Godot's scene instancing?
+      - Does it perform well on Godot's HTML5 export?
+    godot_technical_assessment:
+      - Draw calls under 1000 (check Godot profiler)
+      - Physics bodies under 200 for mobile targets
+      - Scene tree depth reasonable (<10 levels)
+      - Proper use of Godot's threading if needed
+      - GDScript performance adequate or need C#/GDExtension?
+    godot_expansion_viability:
+      - Can current scene structure support more content?
+      - Are signals and groups set up for scaling?
+      - Is the resource system being used effectively?
+      - Would Godot's multiplayer API support this mechanic?
+      - Are we leveraging Godot's strengths (not fighting it)?
+  post_prototype_options:
+    iterate_and_improve:
+      action: continue_prototyping
+      when: Core mechanic shows promise but needs refinement
+      next_steps: Create new prototype iteration focusing on identified improvements
+    expand_to_full_game:
+      action: transition_to_full_development
+      when: Prototype validates strong game concept
+      next_steps: Use game-dev-greenfield workflow to create full game design and architecture
+    pivot_concept:
+      action: new_prototype_direction
+      when: Current mechanic doesn't work but insights suggest new direction
+      next_steps: Apply learnings to new prototype concept
+    archive_and_learn:
+      action: document_learnings
+      when: Prototype doesn't work but provides valuable insights
+      next_steps: Document lessons learned and move to next prototype concept
+  godot_time_boxing:
+    concept_phase: 30 min - Pick Godot nodes that drive your mechanic
+    design_phase: 1 hour - Sketch scene tree and signal flow
+    planning_phase: 30 min - Set up Godot project with right settings
+    implementation_phase: 2-hour sprints - F6 test after each sprint
+    polish_phase: 1 hour - Godot's animation tools for juice
+  godot_success_metrics:
+    godot_velocity:
+      - First scene running in Godot within 2 hours
+      - Core nodes connected and signaling within 4 hours
+      - Playable build exported (HTML5) within 8 hours
+      - All built-in Godot features identified for mechanic
+    godot_learning:
+      - Which Godot nodes best serve the mechanic
+      - Performance profile from Godot's monitors
+      - Export size and load time benchmarks
+      - Godot-specific optimizations discovered
+      - Editor workflow improvements identified
+  handoff_prompts:
+    concept_to_design: Concept defined with target Godot nodes identified. Create design spec mapping mechanics to Godot's systems.
+    design_to_technical: Design ready with scene structure planned. Create Godot project setup and technical approach.
+    technical_to_stories: Godot architecture defined. Create stories with specific node types and signal connections.
+    stories_to_implementation: Stories specify Godot implementation. Begin building in editor with F6 testing.
+    prototype_to_evaluation: Prototype running in Godot. Check profiler metrics and evaluate for expansion.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "4.43.0",
+  "version": "4.43.1",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

package/release_notes.md

@@ -1,10 +1,12 @@
-## 🚀 What's New in v4.43.0
+## 🚀 What's New in v4.43.1
 
 ### ✨ New Features
 - feat: implement fork-friendly CI/CD with opt-in mechanism (#476)
 - feat(installer): add Codex CLI + Codex Web modes, generate AGENTS.md, inject npm scripts, and docs (#529)
 - feat: add PR validation workflow and contribution checks
 - feat: Add Auggie CLI (Augment Code) Integration (#520)
+- feat: enhance file exclusion capabilities with .bmad-flattenignore support (#531)
+- feat: add iflow cli support to bmad installer.  (#510)
 
 ### 🐛 Bug Fixes
 - fix: update installer version display to show 4.39.0
@@ -14,6 +16,11 @@
 - fix: remove incorrect else branch causing flatten command regression (#452)
 - fix: correct dependency path format in bmad-master agent (#495)
 - fix: Codex options missing from the IDE selection menu (#535)
+- Fixed: "glob" is not defined (#504)
+- fix: Template file extension in validation next story steps (#523)
+- fix: update .gitignore to correct cursor file entry (#485)
+- fix: update workflow file extensions from .md to .yaml in bmad-master.md (#562)
+- fix: Changed title to coding standards section of brownfield architecture template (#564)
 
 ### 📦 Other Changes
 - patch: move script to tools folder
@@ -22,6 +29,11 @@
 - test: trigger PR validation (#533)
 - docs: remove misplaced Codex section from README
 - Expansion pack doc correction
+- added gemini cli custom commands! (#549)
+- Update ide-setup.js - add missing glob require (#514)
+- Godot Game Dev expansion pack for BMAD (#532)
+- documentation updates
+- remove errant command from readme
 
 ### 🔧 Maintenance
 - chore: bump to 4.39.1 to fix installer version display
@@ -36,4 +48,4 @@
 npx bmad-method install
 ```
 
-**Full Changelog**: https://github.com/bmadcode/BMAD-METHOD/compare/v4.39.0...v4.43.0
+**Full Changelog**: https://github.com/bmadcode/BMAD-METHOD/compare/v4.39.0...v4.43.1

package/tools/flattener/ignoreRules.js

@@ -154,9 +154,11 @@ async function parseGitignore(gitignorePath) {
 async function loadIgnore(rootDir, extraPatterns = []) {
   const ig = ignore();
   const gitignorePath = path.join(rootDir, '.gitignore');
+  const flattenIgnorePath = path.join(rootDir, '.bmad-flattenignore');
   const patterns = [
     ...(await readIgnoreFile(gitignorePath)),
     ...DEFAULT_PATTERNS,
+    ...(await readIgnoreFile(flattenIgnorePath)),
     ...extraPatterns,
   ];
   // De-duplicate

package/tools/installer/bin/bmad.js

@@ -49,7 +49,7 @@ program
   .option('-d, --directory <path>', 'Installation directory')
   .option(
     '-i, --ide <ide...>',
-    'Configure for specific IDE(s) - can specify multiple (cursor, claude-code, windsurf, trae, roo, kilo, cline, gemini, qwen-code, github-copilot, codex, codex-web, auggie-cli, other)',
+    'Configure for specific IDE(s) - can specify multiple (cursor, claude-code, windsurf, trae, roo, kilo, cline, gemini, qwen-code, github-copilot, codex, codex-web, auggie-cli, iflow-cli, other)',
   )
   .option(
     '-e, --expansion-packs <packs...>',
@@ -397,6 +397,7 @@ async function promptInstallation() {
         choices: [
           { name: 'Cursor', value: 'cursor' },
           { name: 'Claude Code', value: 'claude-code' },
+          { name: 'iFlow CLI', value: 'iflow-cli' },
           { name: 'Windsurf', value: 'windsurf' },
           { name: 'Trae', value: 'trae' }, // { name: 'Trae', value: 'trae'}
           { name: 'Roo Code', value: 'roo' },

package/tools/installer/config/install.config.yaml

@@ -28,6 +28,15 @@ ide-configurations:
       # To use BMad agents in Claude Code:
       # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
       # 2. Claude will switch to that agent's persona
+  iflow-cli:
+    name: iFlow CLI
+    rule-dir: .iflow/commands/BMad/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in iFlow CLI:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. iFlow will switch to that agent's persona
   crush:
     name: Crush
     rule-dir: .crush/commands/BMad/
@@ -78,15 +87,15 @@ ide-configurations:
       # 4. Rules are stored in .clinerules/ directory in your project
   gemini:
     name: Gemini CLI
-    rule-dir: .gemini/bmad-method/
-    format: single-file
-    command-suffix: .md
+    rule-dir: .gemini/commands/BMad/
+    format: multi-file
+    command-suffix: .toml
     instructions: |
       # To use BMad agents with the Gemini CLI:
-      # 1. The installer creates a .gemini/bmad-method/ directory in your project.
-      # 2. It concatenates all agent files into a single GEMINI.md file.
-      # 3. Simply mention the agent in your prompt (e.g., "As *dev, ...").
-      # 4. The Gemini CLI will automatically have the context for that agent.
+      # 1. The installer creates a `BMad` folder in `.gemini/commands`.
+      # 2. This adds custom commands for each agent and task.
+      # 3. Type /BMad:agents:<agent-name> (e.g., "/BMad:agents:dev", "/BMad:agents:pm") or /BMad:tasks:<task-name> (e.g., "/BMad:tasks:create-doc").
+      # 4. The agent will adopt that persona for the conversation or preform the task.
   github-copilot:
     name: Github Copilot
     rule-dir: .github/chatmodes/

package/tools/installer/lib/ide-setup.js

@@ -47,6 +47,9 @@ class IdeSetup extends BaseIdeSetup {
       case 'claude-code': {
         return this.setupClaudeCode(installDir, selectedAgent);
       }
+      case 'iflow-cli': {
+        return this.setupIFlowCli(installDir, selectedAgent);
+      }
       case 'crush': {
         return this.setupCrush(installDir, selectedAgent);
       }
@@ -453,6 +456,134 @@ class IdeSetup extends BaseIdeSetup {
     console.log(chalk.dim(`  - Tasks in: ${tasksDir}`));
   }
 
+  async setupIFlowCli(installDir, selectedAgent) {
+    // Setup bmad-core commands
+    const coreSlashPrefix = await this.getCoreSlashPrefix(installDir);
+    const coreAgents = selectedAgent ? [selectedAgent] : await this.getCoreAgentIds(installDir);
+    const coreTasks = await this.getCoreTaskIds(installDir);
+    await this.setupIFlowCliForPackage(
+      installDir,
+      'core',
+      coreSlashPrefix,
+      coreAgents,
+      coreTasks,
+      '.bmad-core',
+    );
+
+    // Setup expansion pack commands
+    const expansionPacks = await this.getInstalledExpansionPacks(installDir);
+    for (const packInfo of expansionPacks) {
+      const packSlashPrefix = await this.getExpansionPackSlashPrefix(packInfo.path);
+      const packAgents = await this.getExpansionPackAgents(packInfo.path);
+      const packTasks = await this.getExpansionPackTasks(packInfo.path);
+
+      if (packAgents.length > 0 || packTasks.length > 0) {
+        // Use the actual directory name where the expansion pack is installed
+        const rootPath = path.relative(installDir, packInfo.path);
+        await this.setupIFlowCliForPackage(
+          installDir,
+          packInfo.name,
+          packSlashPrefix,
+          packAgents,
+          packTasks,
+          rootPath,
+        );
+      }
+    }
+
+    return true;
+  }
+
+  async setupIFlowCliForPackage(installDir, packageName, slashPrefix, agentIds, taskIds, rootPath) {
+    const commandsBaseDir = path.join(installDir, '.iflow', 'commands', slashPrefix);
+    const agentsDir = path.join(commandsBaseDir, 'agents');
+    const tasksDir = path.join(commandsBaseDir, 'tasks');
+
+    // Ensure directories exist
+    await fileManager.ensureDirectory(agentsDir);
+    await fileManager.ensureDirectory(tasksDir);
+
+    // Setup agents
+    for (const agentId of agentIds) {
+      // Find the agent file - for expansion packs, prefer the expansion pack version
+      let agentPath;
+      if (packageName === 'core') {
+        // For core, use the normal search
+        agentPath = await this.findAgentPath(agentId, installDir);
+      } else {
+        // For expansion packs, first try to find the agent in the expansion pack directory
+        const expansionPackPath = path.join(installDir, rootPath, 'agents', `${agentId}.md`);
+        if (await fileManager.pathExists(expansionPackPath)) {
+          agentPath = expansionPackPath;
+        } else {
+          // Fall back to core if not found in expansion pack
+          agentPath = await this.findAgentPath(agentId, installDir);
+        }
+      }
+
+      const commandPath = path.join(agentsDir, `${agentId}.md`);
+
+      if (agentPath) {
+        // Create command file with agent content
+        let agentContent = await fileManager.readFile(agentPath);
+
+        // Replace {root} placeholder with the appropriate root path for this context
+        agentContent = agentContent.replaceAll('{root}', rootPath);
+
+        // Add command header
+        let commandContent = `# /${agentId} Command\n\n`;
+        commandContent += `When this command is used, adopt the following agent persona:\n\n`;
+        commandContent += agentContent;
+
+        await fileManager.writeFile(commandPath, commandContent);
+        console.log(chalk.green(`✓ Created agent command: /${agentId}`));
+      }
+    }
+
+    // Setup tasks
+    for (const taskId of taskIds) {
+      // Find the task file - for expansion packs, prefer the expansion pack version
+      let taskPath;
+      if (packageName === 'core') {
+        // For core, use the normal search
+        taskPath = await this.findTaskPath(taskId, installDir);
+      } else {
+        // For expansion packs, first try to find the task in the expansion pack directory
+        const expansionPackPath = path.join(installDir, rootPath, 'tasks', `${taskId}.md`);
+        if (await fileManager.pathExists(expansionPackPath)) {
+          taskPath = expansionPackPath;
+        } else {
+          // Fall back to core if not found in expansion pack
+          taskPath = await this.findTaskPath(taskId, installDir);
+        }
+      }
+
+      const commandPath = path.join(tasksDir, `${taskId}.md`);
+
+      if (taskPath) {
+        // Create command file with task content
+        let taskContent = await fileManager.readFile(taskPath);
+
+        // Replace {root} placeholder with the appropriate root path for this context
+        taskContent = taskContent.replaceAll('{root}', rootPath);
+
+        // Add command header
+        let commandContent = `# /${taskId} Task\n\n`;
+        commandContent += `When this command is used, execute the following task:\n\n`;
+        commandContent += taskContent;
+
+        await fileManager.writeFile(commandPath, commandContent);
+        console.log(chalk.green(`✓ Created task command: /${taskId}`));
+      }
+    }
+
+    console.log(
+      chalk.green(`\n✓ Created iFlow CLI commands for ${packageName} in ${commandsBaseDir}`),
+    );
+    console.log(chalk.dim(`  - Agents in: ${agentsDir}`));
+    console.log(chalk.dim(`  - Tasks in: ${tasksDir}`));
+  }
+
   async setupCrushForPackage(installDir, packageName, slashPrefix, agentIds, taskIds, rootPath) {
     const commandsBaseDir = path.join(installDir, '.crush', 'commands', slashPrefix);
     const agentsDir = path.join(commandsBaseDir, 'agents');
@@ -690,6 +821,7 @@ class IdeSetup extends BaseIdeSetup {
 
   async getCoreTaskIds(installDir) {
     const allTaskIds = [];
+    const glob = require('glob');
 
     // Check core tasks in .bmad-core or root only
     let tasksDir = path.join(installDir, '.bmad-core', 'tasks');
@@ -698,7 +830,6 @@ class IdeSetup extends BaseIdeSetup {
     }
 
     if (await fileManager.pathExists(tasksDir)) {
-      const glob = require('glob');
       const taskFiles = glob.sync('*.md', { cwd: tasksDir });
       allTaskIds.push(...taskFiles.map((file) => path.basename(file, '.md')));
     }
@@ -706,6 +837,7 @@ class IdeSetup extends BaseIdeSetup {
     // Check common tasks
     const commonTasksDir = path.join(installDir, 'common', 'tasks');
     if (await fileManager.pathExists(commonTasksDir)) {
+      const glob = require('glob');
       const commonTaskFiles = glob.sync('*.md', { cwd: commonTasksDir });
       allTaskIds.push(...commonTaskFiles.map((file) => path.basename(file, '.md')));
     }
@@ -1208,97 +1340,77 @@ class IdeSetup extends BaseIdeSetup {
     return true;
   }
 
-  async setupGeminiCli(installDir) {
-    const geminiDir = path.join(installDir, '.gemini');
-    const bmadMethodDir = path.join(geminiDir, 'bmad-method');
-    await fileManager.ensureDirectory(bmadMethodDir);
-
-    // Update logic for existing settings.json
-    const settingsPath = path.join(geminiDir, 'settings.json');
-    if (await fileManager.pathExists(settingsPath)) {
-      try {
-        const settingsContent = await fileManager.readFile(settingsPath);
-        const settings = JSON.parse(settingsContent);
-        let updated = false;
+  async setupGeminiCli(installDir, selectedAgent) {
+    const ideConfig = await configLoader.getIdeConfiguration('gemini');
+    const bmadCommandsDir = path.join(installDir, ideConfig['rule-dir']);
 
-        // Handle contextFileName property
-        if (settings.contextFileName && Array.isArray(settings.contextFileName)) {
-          const originalLength = settings.contextFileName.length;
-          settings.contextFileName = settings.contextFileName.filter(
-            (fileName) => !fileName.startsWith('agents/'),
-          );
-          if (settings.contextFileName.length !== originalLength) {
-            updated = true;
-          }
-        }
+    const agentCommandsDir = path.join(bmadCommandsDir, 'agents');
+    const taskCommandsDir = path.join(bmadCommandsDir, 'tasks');
+    await fileManager.ensureDirectory(agentCommandsDir);
+    await fileManager.ensureDirectory(taskCommandsDir);
 
-        if (updated) {
-          await fileManager.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-          console.log(
-            chalk.green('✓ Updated .gemini/settings.json - removed agent file references'),
-          );
-        }
-      } catch (error) {
-        console.warn(chalk.yellow('Could not update .gemini/settings.json'), error);
+    // Process Agents
+    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);
+    for (const agentId of agents) {
+      const agentPath = await this.findAgentPath(agentId, installDir);
+      if (!agentPath) {
+        console.log(chalk.yellow(`✗ Agent file not found for ${agentId}, skipping.`));
+        continue;
       }
-    }
 
-    // Remove old agents directory
-    const agentsDir = path.join(geminiDir, 'agents');
-    if (await fileManager.pathExists(agentsDir)) {
-      await fileManager.removeDirectory(agentsDir);
-      console.log(chalk.green('✓ Removed old .gemini/agents directory'));
-    }
+      const agentTitle = await this.getAgentTitle(agentId, installDir);
+      const commandPath = path.join(agentCommandsDir, `${agentId}.toml`);
 
-    // Get all available agents
-    const agents = await this.getAllAgentIds(installDir);
-    let concatenatedContent = '';
+      // Get relative path from installDir to agent file for @{file} reference
+      const relativeAgentPath = path.relative(installDir, agentPath).replaceAll('\\', '/');
 
-    for (const agentId of agents) {
-      // Find the source agent file
-      const agentPath = await this.findAgentPath(agentId, installDir);
+      const tomlContent = `description = "Activates the ${agentTitle} agent from the BMad Method."
+prompt = """
+CRITICAL: You are now the BMad '${agentTitle}' agent. Adopt its persona, follow its instructions, and use its capabilities. The full agent definition is below.
 
-      if (agentPath) {
-        const agentContent = await fileManager.readFile(agentPath);
+@{${relativeAgentPath}}
+"""`;
 
-        // Create properly formatted agent rule content (similar to trae)
-        let agentRuleContent = `# ${agentId.toUpperCase()} Agent Rule\n\n`;
-        agentRuleContent += `This rule is triggered when the user types \`*${agentId}\` and activates the ${await this.getAgentTitle(
-          agentId,
-          installDir,
-        )} agent persona.\n\n`;
-        agentRuleContent += '## Agent Activation\n\n';
-        agentRuleContent +=
-          'CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n';
-        agentRuleContent += '```yaml\n';
-        // Extract just the YAML content from the agent file
-        const yamlContent = extractYamlFromAgent(agentContent);
-        if (yamlContent) {
-          agentRuleContent += yamlContent;
-        } else {
-          // If no YAML found, include the whole content minus the header
-          agentRuleContent += agentContent.replace(/^#.*$/m, '').trim();
-        }
-        agentRuleContent += '\n```\n\n';
-        agentRuleContent += '## File Reference\n\n';
-        const relativePath = path.relative(installDir, agentPath).replaceAll('\\', '/');
-        agentRuleContent += `The complete agent definition is available in [${relativePath}](${relativePath}).\n\n`;
-        agentRuleContent += '## Usage\n\n';
-        agentRuleContent += `When the user types \`*${agentId}\`, activate this ${await this.getAgentTitle(
-          agentId,
-          installDir,
-        )} persona and follow all instructions defined in the YAML configuration above.\n`;
+      await fileManager.writeFile(commandPath, tomlContent);
+      console.log(chalk.green(`✓ Created agent command: /bmad:agents:${agentId}`));
+    }
 
-        // Add to concatenated content with separator
-        concatenatedContent += agentRuleContent + '\n\n---\n\n';
-        console.log(chalk.green(`✓ Added context for @${agentId}`));
+    // Process Tasks
+    const tasks = await this.getAllTaskIds(installDir);
+    for (const taskId of tasks) {
+      const taskPath = await this.findTaskPath(taskId, installDir);
+      if (!taskPath) {
+        console.log(chalk.yellow(`✗ Task file not found for ${taskId}, skipping.`));
+        continue;
       }
+
+      const taskTitle = taskId
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+      const commandPath = path.join(taskCommandsDir, `${taskId}.toml`);
+
+      // Get relative path from installDir to task file for @{file} reference
+      const relativeTaskPath = path.relative(installDir, taskPath).replaceAll('\\', '/');
+
+      const tomlContent = `description = "Executes the BMad Task: ${taskTitle}"
+prompt = """
+CRITICAL: You are to execute the BMad Task defined below.
+
+@{${relativeTaskPath}}
+"""`;
+
+      await fileManager.writeFile(commandPath, tomlContent);
+      console.log(chalk.green(`✓ Created task command: /bmad:tasks:${taskId}`));
     }
 
-    // Write the concatenated content to GEMINI.md
-    const geminiMdPath = path.join(bmadMethodDir, 'GEMINI.md');
-    await fileManager.writeFile(geminiMdPath, concatenatedContent);
-    console.log(chalk.green(`\n✓ Created GEMINI.md in ${bmadMethodDir}`));
+    console.log(
+      chalk.green(`
+✓ Created Gemini CLI extension in ${bmadCommandsDir}`),
+    );
+    console.log(
+      chalk.dim('You can now use commands like /bmad:agents:dev or /bmad:tasks:create-doc.'),
+    );
 
     return true;
   }