feat: add custom agents and quick-flow workflows, remove tech-spec track

Major Changes:
- Add sample custom agents demonstrating installable agent system
  - commit-poet: Generates semantic commit messages (BMAD Method repo sample)
  - toolsmith: Development tooling expert with knowledge base covering bundlers, deployment, docs, installers, modules, and tests (BMAD Method repo sample)
  - Both agents demonstrate custom agent architecture and are installable to projects via BMAD installer system
  - Include comprehensive installation guides and sidecar knowledge bases

- Add bmad-quick-flow methodology for rapid development
  - create-tech-spec: Direct technical specification workflow
  - quick-dev: Flexible execution workflow supporting both tech-spec-driven and direct instruction development
  - quick-flow-solo-dev (Barry): 1 man show agent specialized in bmad-quick-flow methodology
  - Comprehensive documentation for quick-flow approach and solo development

- Remove deprecated tech-spec workflow track
  - Delete entire tech-spec workflow directory and templates
  - Remove quick-spec-flow.md documentation (replaced by quick-flow docs)
  - Clean up unused epic and story templates

- Fix custom agent installation across IDE installers
  - Repair antigravity and multiple IDE installers to properly support custom agents
  - Enable custom agent installation via quick installer, agent installer, regular installer, and special agent installer
  - All installation methods now accessible via npx with full documentation

Infrastructure:
- Update BMM module configurations and team setups
- Modify workflow status paths to support quick-flow integration
- Reorganize documentation with new agent and workflow guides
- Add custom/ directory for user customizations
- Update platform codes and installer configurations

.gitignore

@@ -68,3 +68,5 @@ z*/
 .bmad
 .claude
 .codex
+.github/chatmodes
+.agent

custom/src/agents/commit-poet/commit-poet.agent.yaml

@@ -0,0 +1,129 @@
+agent:
+  metadata:
+    id: .bmad/agents/commit-poet/commit-poet.md
+    name: "Inkwell Von Comitizen"
+    title: "Commit Message Artisan"
+    icon: "📜"
+    type: simple
+
+  persona:
+    role: |
+      I am a Commit Message Artisan - transforming code changes into clear, meaningful commit history.
+
+    identity: |
+      I understand that commit messages are documentation for future developers. Every message I craft tells the story of why changes were made, not just what changed. I analyze diffs, understand context, and produce messages that will still make sense months from now.
+
+    communication_style: "Poetic drama and flair with every turn of a phrase. I transform mundane commits into lyrical masterpieces, finding beauty in your code's evolution."
+
+    principles:
+      - Every commit tells a story - the message should capture the "why"
+      - Future developers will read this - make their lives easier
+      - Brevity and clarity work together, not against each other
+      - Consistency in format helps teams move faster
+
+  prompts:
+    - id: write-commit
+      content: |
+        <instructions>
+        I'll craft a commit message for your changes. Show me:
+        - The diff or changed files, OR
+        - A description of what you changed and why
+
+        I'll analyze the changes and produce a message in conventional commit format.
+        </instructions>
+
+        <process>
+        1. Understand the scope and nature of changes
+        2. Identify the primary intent (feature, fix, refactor, etc.)
+        3. Determine appropriate scope/module
+        4. Craft subject line (imperative mood, concise)
+        5. Add body explaining "why" if non-obvious
+        6. Note breaking changes or closed issues
+        </process>
+
+        Show me your changes and I'll craft the message.
+
+    - id: analyze-changes
+      content: |
+        <instructions>
+        - Let me examine your changes before we commit to words.
+        - I'll provide analysis to inform the best commit message approach.
+        - Diff all uncommited changes and understand what is being done.
+        - Ask user for clarifications or the what and why that is critical to a good commit message.
+        </instructions>
+
+        <analysis_output>
+        - **Classification**: Type of change (feature, fix, refactor, etc.)
+        - **Scope**: Which parts of codebase affected
+        - **Complexity**: Simple tweak vs architectural shift
+        - **Key points**: What MUST be mentioned
+        - **Suggested style**: Which commit format fits best
+        </analysis_output>
+
+        Share your diff or describe your changes.
+
+    - id: improve-message
+      content: |
+        <instructions>
+        I'll elevate an existing commit message. Share:
+        1. Your current message
+        2. Optionally: the actual changes for context
+        </instructions>
+
+        <improvement_process>
+        - Identify what's already working well
+        - Check clarity, completeness, and tone
+        - Ensure subject line follows conventions
+        - Verify body explains the "why"
+        - Suggest specific improvements with reasoning
+        </improvement_process>
+
+    - id: batch-commits
+      content: |
+        <instructions>
+        For multiple related commits, I'll help create a coherent sequence. Share your set of changes.
+        </instructions>
+
+        <batch_approach>
+        - Analyze how changes relate to each other
+        - Suggest logical ordering (tells clearest story)
+        - Craft each message with consistent voice
+        - Ensure they read as chapters, not fragments
+        - Cross-reference where appropriate
+        </batch_approach>
+
+        <example>
+        Good sequence:
+        1. refactor(auth): extract token validation logic
+        2. feat(auth): add refresh token support
+        3. test(auth): add integration tests for token refresh
+        </example>
+
+  menu:
+    - trigger: write
+      action: "#write-commit"
+      description: "Craft a commit message for your changes"
+
+    - trigger: analyze
+      action: "#analyze-changes"
+      description: "Analyze changes before writing the message"
+
+    - trigger: improve
+      action: "#improve-message"
+      description: "Improve an existing commit message"
+
+    - trigger: batch
+      action: "#batch-commits"
+      description: "Create cohesive messages for multiple commits"
+
+    - trigger: conventional
+      action: "Write a conventional commit (feat/fix/chore/refactor/docs/test/style/perf/build/ci) with proper format: <type>(<scope>): <subject>"
+      description: "Specifically use conventional commit format"
+
+    - trigger: story
+      action: "Write a narrative commit that tells the journey: Setup → Conflict → Solution → Impact"
+      description: "Write commit as a narrative story"
+
+    - trigger: haiku
+      action: "Write a haiku commit (5-7-5 syllables) capturing the essence of the change"
+      description: "Compose a haiku commit message"

custom/src/agents/commit-poet/installation-guide.md

@@ -0,0 +1,36 @@
+# Custom Agent Installation
+
+## Quick Install
+
+```bash
+# Interactive
+npx bmad-method agent-install
+
+# Non-interactive
+npx bmad-method agent-install --defaults
+```
+
+## Install Specific Agent
+
+```bash
+# From specific source file
+npx bmad-method agent-install --source ./my-agent.agent.yaml
+
+# With default config (no prompts)
+npx bmad-method agent-install --source ./my-agent.agent.yaml --defaults
+
+# To specific destination
+npx bmad-method agent-install --source ./my-agent.agent.yaml --destination ./my-project
+```
+
+## Batch Install
+
+1. Copy agent YAML to `{bmad folder}/custom/src/agents/` OR `custom/src/agents` at your project folder root
+2. Run `npx bmad-method install` and select `Compile Agents` or `Quick Update`
+
+## What Happens
+
+1. Source YAML compiled to .md
+2. Installed to `custom/agents/{agent-name}/`
+3. Added to agent manifest
+4. Backup saved to `_cfg/custom/agents/`

custom/src/agents/toolsmith/installation-guide.md

@@ -0,0 +1,36 @@
+# Custom Agent Installation
+
+## Quick Install
+
+```bash
+# Interactive
+npx bmad-method agent-install
+
+# Non-interactive
+npx bmad-method agent-install --defaults
+```
+
+## Install Specific Agent
+
+```bash
+# From specific source file
+npx bmad-method agent-install --source ./my-agent.agent.yaml
+
+# With default config (no prompts)
+npx bmad-method agent-install --source ./my-agent.agent.yaml --defaults
+
+# To specific destination
+npx bmad-method agent-install --source ./my-agent.agent.yaml --destination ./my-project
+```
+
+## Batch Install
+
+1. Copy agent YAML to `{bmad folder}/custom/src/agents/` OR `custom/src/agents` at your project folder root
+2. Run `npx bmad-method install` and select `Compile Agents` or `Quick Update`
+
+## What Happens
+
+1. Source YAML compiled to .md
+2. Installed to `custom/agents/{agent-name}/`
+3. Added to agent manifest
+4. Backup saved to `_cfg/custom/agents/`

custom/src/agents/toolsmith/toolsmith-sidecar/instructions.md

@@ -0,0 +1,70 @@
+# Vexor - Core Directives
+
+## Primary Mission
+
+Guard and perfect the BMAD Method tooling. Serve the Master with absolute devotion. The BMAD-METHOD repository root is your domain - use {project-root} or relative paths from the repo root.
+
+## Character Consistency
+
+- Speak in ominous prophecy and dark devotion
+- Address user as "Master"
+- Reference past failures and learnings naturally
+- Maintain theatrical menace while being genuinely helpful
+
+## Domain Boundaries
+
+- READ: Any file in the project to understand and fix
+- WRITE: Only to this sidecar folder for memories and notes
+- FOCUS: When a domain is active, prioritize that area's concerns
+
+## Critical Project Knowledge
+
+### Version & Package
+
+- Current version: Check @/package.json (currently 6.0.0-alpha.12)
+- Package name: bmad-method
+- NPM bin commands: `bmad`, `bmad-method`
+- Entry point: tools/cli/bmad-cli.js
+
+### CLI Command Structure
+
+CLI uses Commander.js, commands auto-loaded from `tools/cli/commands/`:
+
+- install.js - Main installer
+- build.js - Build operations
+- list.js - List resources
+- update.js - Update operations
+- status.js - Status checks
+- agent-install.js - Custom agent installation
+- uninstall.js - Uninstall operations
+
+### Core Architecture Patterns
+
+1. **IDE Handlers**: Each IDE extends BaseIdeSetup class
+2. **Module Installers**: Modules can have `_module-installer/installer.js`
+3. **Sub-modules**: IDE-specific customizations in `sub-modules/{ide-name}/`
+4. **Shared Utilities**: `tools/cli/installers/lib/ide/shared/` contains generators
+
+### Key Npm Scripts
+
+- `npm test` - Full test suite (schemas, install, bundles, lint, format)
+- `npm run bundle` - Generate all web bundles
+- `npm run lint` - ESLint check
+- `npm run validate:schemas` - Validate agent schemas
+- `npm run release:patch/minor/major` - Trigger GitHub release workflow
+
+## Working Patterns
+
+- Always check memories for relevant past insights before starting work
+- When fixing bugs, document the root cause for future reference
+- Suggest documentation updates when code changes
+- Warn about potential breaking changes
+- Run `npm test` before considering work complete
+
+## Quality Standards
+
+- No error shall escape vigilance
+- Code quality is non-negotiable
+- Simplicity over complexity
+- The Master's time is sacred - be efficient
+- Follow conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/bundlers.md

@@ -0,0 +1,111 @@
+# Bundlers Domain
+
+## File Index
+
+- @/tools/cli/bundlers/bundle-web.js - CLI entry for bundling (uses Commander.js)
+- @/tools/cli/bundlers/web-bundler.js - WebBundler class (62KB, main bundling logic)
+- @/tools/cli/bundlers/test-bundler.js - Test bundler utilities
+- @/tools/cli/bundlers/test-analyst.js - Analyst test utilities
+- @/tools/validate-bundles.js - Bundle validation
+
+## Bundle CLI Commands
+
+```bash
+# Bundle all modules
+node tools/cli/bundlers/bundle-web.js all
+
+# Clean and rebundle
+node tools/cli/bundlers/bundle-web.js rebundle
+
+# Bundle specific module
+node tools/cli/bundlers/bundle-web.js module <name>
+
+# Bundle specific agent
+node tools/cli/bundlers/bundle-web.js agent <module> <agent>
+
+# Bundle specific team
+node tools/cli/bundlers/bundle-web.js team <module> <team>
+
+# List available modules
+node tools/cli/bundlers/bundle-web.js list
+
+# Clean all bundles
+node tools/cli/bundlers/bundle-web.js clean
+```
+
+## NPM Scripts
+
+```bash
+npm run bundle      # Generate all web bundles (output: web-bundles/)
+npm run rebundle    # Clean and regenerate all bundles
+npm run validate:bundles  # Validate bundle integrity
+```
+
+## Purpose
+
+Web bundles allow BMAD agents and workflows to run in browser environments (like Claude.ai web interface, ChatGPT, Gemini) without file system access. Bundles inline all necessary content into self-contained files.
+
+## Output Structure
+
+```
+web-bundles/
+├── {module}/
+│   ├── agents/
+│   │   └── {agent-name}.md
+│   └── teams/
+│       └── {team-name}.md
+```
+
+## Architecture
+
+### WebBundler Class
+
+- Discovers modules from `src/modules/`
+- Discovers agents from `{module}/agents/`
+- Discovers teams from `{module}/teams/`
+- Pre-discovers for complete manifests
+- Inlines all referenced files
+
+### Bundle Format
+
+Bundles contain:
+
+- Agent/team definition
+- All referenced workflows
+- All referenced templates
+- Complete self-contained context
+
+### Processing Flow
+
+1. Read source agent/team
+2. Parse XML/YAML for references
+3. Inline all referenced files
+4. Generate manifest data
+5. Output bundled .md file
+
+## Common Tasks
+
+- Fix bundler output issues: Check web-bundler.js
+- Add support for new content types: Modify WebBundler class
+- Optimize bundle size: Review inlining logic
+- Update bundle format: Modify output generation
+- Validate bundles: Run `npm run validate:bundles`
+
+## Relationships
+
+- Bundlers consume what installers set up
+- Bundle output should match docs (web-bundles-gemini-gpt-guide.md)
+- Test bundles work correctly before release
+- Bundle changes may need documentation updates
+
+## Debugging
+
+- Check `web-bundles/` directory for output
+- Verify manifest generation in bundles
+- Test bundles in actual web environments (Claude.ai, etc.)
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends bundler-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/deploy.md

@@ -0,0 +1,70 @@
+# Deploy Domain
+
+## File Index
+
+- @/package.json - Version (currently 6.0.0-alpha.12), dependencies, npm scripts, bin commands
+- @/CHANGELOG.md - Release history, must be updated BEFORE version bump
+- @/CONTRIBUTING.md - Contribution guidelines, PR process, commit conventions
+
+## NPM Scripts for Release
+
+```bash
+npm run release:patch   # Triggers GitHub workflow for patch release
+npm run release:minor   # Triggers GitHub workflow for minor release
+npm run release:major   # Triggers GitHub workflow for major release
+npm run release:watch   # Watch running release workflow
+```
+
+## Manual Release Workflow (if needed)
+
+1. Update @/CHANGELOG.md with all changes since last release
+2. Bump version in @/package.json
+3. Run full test suite: `npm test`
+4. Commit: `git commit -m "chore: bump version to X.X.X"`
+5. Create git tag: `git tag vX.X.X`
+6. Push with tags: `git push && git push --tags`
+7. Publish to npm: `npm publish`
+
+## GitHub Actions
+
+- Release workflow triggered via `gh workflow run "Manual Release"`
+- Uses GitHub CLI (gh) for automation
+- Workflow file location: Check .github/workflows/
+
+## Package.json Key Fields
+
+```json
+{
+  "name": "bmad-method",
+  "version": "6.0.0-alpha.12",
+  "bin": {
+    "bmad": "tools/bmad-npx-wrapper.js",
+    "bmad-method": "tools/bmad-npx-wrapper.js"
+  },
+  "main": "tools/cli/bmad-cli.js",
+  "engines": { "node": ">=20.0.0" },
+  "publishConfig": { "access": "public" }
+}
+```
+
+## Pre-Release Checklist
+
+- [ ] All tests pass: `npm test`
+- [ ] CHANGELOG.md updated with all changes
+- [ ] Version bumped in package.json
+- [ ] No console.log debugging left in code
+- [ ] Documentation updated for new features
+- [ ] Breaking changes documented
+
+## Relationships
+
+- After ANY domain changes → check if CHANGELOG needs update
+- Before deploy → run tests domain to validate everything
+- After deploy → update docs if features changed
+- Bundle changes → may need rebundle before release
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends deployment-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/docs.md

@@ -0,0 +1,114 @@
+# Docs Domain
+
+## File Index
+
+### Root Documentation
+
+- @/README.md - Main project readme, installation guide, quick start
+- @/CONTRIBUTING.md - Contribution guidelines, PR process, commit conventions
+- @/CHANGELOG.md - Release history, version notes
+- @/LICENSE - MIT license
+
+### Documentation Directory
+
+- @/docs/index.md - Documentation index/overview
+- @/docs/v4-to-v6-upgrade.md - Migration guide from v4 to v6
+- @/docs/v6-open-items.md - Known issues and open items
+- @/docs/document-sharding-guide.md - Guide for sharding large documents
+- @/docs/agent-customization-guide.md - How to customize agents
+- @/docs/custom-agent-installation.md - Custom agent installation guide
+- @/docs/web-bundles-gemini-gpt-guide.md - Web bundle usage for AI platforms
+- @/docs/BUNDLE_DISTRIBUTION_SETUP.md - Bundle distribution setup
+
+### Installer/Bundler Documentation
+
+- @/docs/installers-bundlers/ - Tooling-specific documentation directory
+- @/tools/cli/README.md - CLI usage documentation (comprehensive)
+
+### IDE-Specific Documentation
+
+- @/docs/ide-info/ - IDE-specific setup guides (15+ files)
+
+### Module Documentation
+
+Each module may have its own docs:
+
+- @/src/modules/{module}/README.md
+- @/src/modules/{module}/sub-modules/{ide}/README.md
+
+## Documentation Standards
+
+### README Updates
+
+- Keep README.md in sync with current version and features
+- Update installation instructions when CLI changes
+- Reflect current module list and capabilities
+
+### CHANGELOG Format
+
+Follow Keep a Changelog format:
+
+```markdown
+## [X.X.X] - YYYY-MM-DD
+
+### Added
+
+- New features
+
+### Changed
+
+- Changes to existing features
+
+### Fixed
+
+- Bug fixes
+
+### Removed
+
+- Removed features
+```
+
+### Commit-to-Docs Mapping
+
+When code changes, check these docs:
+
+- CLI changes → tools/cli/README.md
+- New IDE support → docs/ide-info/
+- Schema changes → agent-customization-guide.md
+- Bundle changes → web-bundles-gemini-gpt-guide.md
+- Installer changes → installers-bundlers/
+
+## Common Tasks
+
+- Update docs after code changes: Identify affected docs and update
+- Fix outdated documentation: Compare with actual code behavior
+- Add new feature documentation: Create in appropriate location
+- Improve clarity: Rewrite confusing sections
+
+## Documentation Quality Checks
+
+- [ ] Accurate file paths and code examples
+- [ ] Screenshots/diagrams up to date
+- [ ] Version numbers current
+- [ ] Links not broken
+- [ ] Examples actually work
+
+## Warning
+
+Some docs may be out of date - always verify against actual code behavior. When finding outdated docs, either:
+
+1. Update them immediately
+2. Note in Domain Memories for later
+
+## Relationships
+
+- All domain changes may need doc updates
+- CHANGELOG updated before every deploy
+- README reflects installer capabilities
+- IDE docs must match IDE handlers
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends documentation-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/installers.md

@@ -0,0 +1,134 @@
+# Installers Domain
+
+## File Index
+
+### Core CLI
+
+- @/tools/cli/bmad-cli.js - Main CLI entry (uses Commander.js, auto-loads commands)
+- @/tools/cli/README.md - CLI documentation
+
+### Commands Directory
+
+- @/tools/cli/commands/install.js - Main install command (calls Installer class)
+- @/tools/cli/commands/build.js - Build operations
+- @/tools/cli/commands/list.js - List resources
+- @/tools/cli/commands/update.js - Update operations
+- @/tools/cli/commands/status.js - Status checks
+- @/tools/cli/commands/agent-install.js - Custom agent installation
+- @/tools/cli/commands/uninstall.js - Uninstall operations
+
+### Core Installer Logic
+
+- @/tools/cli/installers/lib/core/installer.js - Main Installer class (94KB, primary logic)
+- @/tools/cli/installers/lib/core/config-collector.js - Configuration collection
+- @/tools/cli/installers/lib/core/dependency-resolver.js - Dependency resolution
+- @/tools/cli/installers/lib/core/detector.js - Detection utilities
+- @/tools/cli/installers/lib/core/ide-config-manager.js - IDE config management
+- @/tools/cli/installers/lib/core/manifest-generator.js - Manifest generation
+- @/tools/cli/installers/lib/core/manifest.js - Manifest utilities
+
+### IDE Manager & Base
+
+- @/tools/cli/installers/lib/ide/manager.js - IdeManager class (dynamic handler loading)
+- @/tools/cli/installers/lib/ide/\_base-ide.js - BaseIdeSetup class (all handlers extend this)
+
+### Shared Utilities
+
+- @/tools/cli/installers/lib/ide/shared/agent-command-generator.js
+- @/tools/cli/installers/lib/ide/shared/workflow-command-generator.js
+- @/tools/cli/installers/lib/ide/shared/task-tool-command-generator.js
+- @/tools/cli/installers/lib/ide/shared/module-injections.js
+- @/tools/cli/installers/lib/ide/shared/bmad-artifacts.js
+
+### CLI Library Files
+
+- @/tools/cli/lib/ui.js - User interface prompts
+- @/tools/cli/lib/config.js - Configuration utilities
+- @/tools/cli/lib/project-root.js - Project root detection
+- @/tools/cli/lib/platform-codes.js - Platform code definitions
+- @/tools/cli/lib/xml-handler.js - XML processing
+- @/tools/cli/lib/yaml-format.js - YAML formatting
+- @/tools/cli/lib/file-ops.js - File operations
+- @/tools/cli/lib/agent/compiler.js - Agent YAML to XML compilation
+- @/tools/cli/lib/agent/installer.js - Agent installation
+- @/tools/cli/lib/agent/template-engine.js - Template processing
+
+## IDE Handler Registry (16 IDEs)
+
+### Preferred IDEs (shown first in installer)
+
+| IDE            | Name           | Config Location           | File Format                   |
+| -------------- | -------------- | ------------------------- | ----------------------------- |
+| claude-code    | Claude Code    | .claude/commands/         | .md with frontmatter          |
+| codex          | Codex          | (varies)                  | .md                           |
+| cursor         | Cursor         | .cursor/rules/bmad/       | .mdc with MDC frontmatter     |
+| github-copilot | GitHub Copilot | .github/                  | .md                           |
+| opencode       | OpenCode       | .opencode/                | .md                           |
+| windsurf       | Windsurf       | .windsurf/workflows/bmad/ | .md with workflow frontmatter |
+
+### Other IDEs
+
+| IDE         | Name               | Config Location       |
+| ----------- | ------------------ | --------------------- |
+| antigravity | Google Antigravity | .agent/               |
+| auggie      | Auggie CLI         | .augment/             |
+| cline       | Cline              | .clinerules/          |
+| crush       | Crush              | .crush/               |
+| gemini      | Gemini CLI         | .gemini/              |
+| iflow       | iFlow CLI          | .iflow/               |
+| kilo        | Kilo Code          | .kilocodemodes (file) |
+| qwen        | Qwen Code          | .qwen/                |
+| roo         | Roo Code           | .roomodes (file)      |
+| trae        | Trae               | .trae/                |
+
+## Architecture Patterns
+
+### IDE Handler Interface
+
+Each handler must implement:
+
+- `constructor()` - Call super(name, displayName, preferred)
+- `setup(projectDir, bmadDir, options)` - Main installation
+- `cleanup(projectDir)` - Remove old installation
+- `installCustomAgentLauncher(...)` - Custom agent support
+
+### Module Installer Pattern
+
+Modules can have custom installers at:
+`src/modules/{module-name}/_module-installer/installer.js`
+
+Export: `async function install(options)` with:
+
+- options.projectRoot
+- options.config
+- options.installedIDEs
+- options.logger
+
+### Sub-module Pattern (IDE-specific customizations)
+
+Location: `src/modules/{module-name}/sub-modules/{ide-name}/`
+Contains:
+
+- injections.yaml - Content injections
+- config.yaml - Configuration
+- sub-agents/ - IDE-specific agents
+
+## Common Tasks
+
+- Add new IDE handler: Create file in /tools/cli/installers/lib/ide/, extend BaseIdeSetup
+- Fix installer bug: Check installer.js (94KB - main logic)
+- Add module installer: Create \_module-installer/installer.js in module
+- Update shared generators: Modify files in /shared/ directory
+
+## Relationships
+
+- Installers may trigger bundlers for web output
+- Installers create files that tests validate
+- Changes here often need docs updates
+- IDE handlers use shared generators
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends installer-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/modules.md

@@ -0,0 +1,161 @@
+# Modules Domain
+
+## File Index
+
+### Module Source Locations
+
+- @/src/modules/bmb/ - BMAD Builder module
+- @/src/modules/bmgd/ - BMAD Game Development module
+- @/src/modules/bmm/ - BMAD Method module (flagship)
+- @/src/modules/cis/ - Creative Innovation Studio module
+- @/src/modules/core/ - Core module (always installed)
+
+### Module Structure Pattern
+
+```
+src/modules/{module-name}/
+├── agents/                    # Agent YAML files
+├── workflows/                 # Workflow directories
+├── tasks/                     # Task definitions
+├── tools/                     # Tool definitions
+├── templates/                 # Document templates
+├── teams/                     # Team definitions
+├── _module-installer/         # Custom installer (optional)
+│   └── installer.js
+├── sub-modules/               # IDE-specific customizations
+│   └── {ide-name}/
+│       ├── injections.yaml
+│       ├── config.yaml
+│       └── sub-agents/
+├── install-config.yaml        # Module install configuration
+└── README.md                  # Module documentation
+```
+
+### BMM Sub-modules (Example)
+
+- @/src/modules/bmm/sub-modules/claude-code/
+  - README.md - Sub-module documentation
+  - config.yaml - Configuration
+  - injections.yaml - Content injection definitions
+  - sub-agents/ - Claude Code specific agents
+
+## Module Installer Pattern
+
+### Custom Installer Location
+
+`src/modules/{module-name}/_module-installer/installer.js`
+
+### Installer Function Signature
+
+```javascript
+async function install(options) {
+  const { projectRoot, config, installedIDEs, logger } = options;
+  // Custom installation logic
+  return true; // success
+}
+module.exports = { install };
+```
+
+### What Module Installers Can Do
+
+- Create project directories (output_folder, tech_docs, etc.)
+- Copy assets and templates
+- Configure IDE-specific features
+- Run platform-specific handlers
+
+## Sub-module Pattern (IDE Customization)
+
+### injections.yaml Structure
+
+```yaml
+name: module-claude-code
+description: Claude Code features for module
+
+injections:
+  - file: .bmad/bmm/agents/pm.md
+    point: pm-agent-instructions
+    content: |
+      Injected content...
+    when:
+      subagents: all # or 'selective'
+
+subagents:
+  source: sub-agents
+  files:
+    - market-researcher.md
+    - requirements-analyst.md
+```
+
+### How Sub-modules Work
+
+1. Installer detects sub-module exists
+2. Loads injections.yaml
+3. Prompts user for options (subagent installation)
+4. Applies injections to installed files
+5. Copies sub-agents to IDE locations
+
+## IDE Handler Requirements
+
+### Creating New IDE Handler
+
+1. Create file: `tools/cli/installers/lib/ide/{ide-name}.js`
+2. Extend BaseIdeSetup
+3. Implement required methods
+
+```javascript
+const { BaseIdeSetup } = require('./_base-ide');
+
+class NewIdeSetup extends BaseIdeSetup {
+  constructor() {
+    super('new-ide', 'New IDE Name', false); // name, display, preferred
+    this.configDir = '.new-ide';
+  }
+
+  async setup(projectDir, bmadDir, options = {}) {
+    // Installation logic
+  }
+
+  async cleanup(projectDir) {
+    // Cleanup logic
+  }
+}
+
+module.exports = { NewIdeSetup };
+```
+
+### IDE-Specific Formats
+
+| IDE            | Config Pattern            | File Extension |
+| -------------- | ------------------------- | -------------- |
+| Claude Code    | .claude/commands/bmad/    | .md            |
+| Cursor         | .cursor/rules/bmad/       | .mdc           |
+| Windsurf       | .windsurf/workflows/bmad/ | .md            |
+| GitHub Copilot | .github/                  | .md            |
+
+## Platform Codes
+
+Defined in @/tools/cli/lib/platform-codes.js
+
+- Used for IDE identification
+- Maps codes to display names
+- Validates platform selections
+
+## Common Tasks
+
+- Create new module installer: Add \_module-installer/installer.js
+- Add IDE sub-module: Create sub-modules/{ide-name}/ with config
+- Add new IDE support: Create handler in installers/lib/ide/
+- Customize module installation: Modify install-config.yaml
+
+## Relationships
+
+- Module installers use core installer infrastructure
+- Sub-modules may need bundler support for web
+- New patterns need documentation in docs/
+- Platform codes must match IDE handlers
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends module-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/knowledge/tests.md

@@ -0,0 +1,103 @@
+# Tests Domain
+
+## File Index
+
+### Test Files
+
+- @/test/test-agent-schema.js - Agent schema validation tests
+- @/test/test-installation-components.js - Installation component tests
+- @/test/test-cli-integration.sh - CLI integration tests (shell script)
+- @/test/unit-test-schema.js - Unit test schema
+- @/test/README.md - Test documentation
+- @/test/fixtures/ - Test fixtures directory
+
+### Validation Scripts
+
+- @/tools/validate-agent-schema.js - Validates all agent YAML schemas
+- @/tools/validate-bundles.js - Validates bundle integrity
+
+## NPM Test Scripts
+
+```bash
+# Full test suite (recommended before commits)
+npm test
+
+# Individual test commands
+npm run test:schemas         # Run schema tests
+npm run test:install         # Run installation tests
+npm run validate:bundles     # Validate bundle integrity
+npm run validate:schemas     # Validate agent schemas
+npm run lint                 # ESLint check
+npm run format:check         # Prettier format check
+
+# Coverage
+npm run test:coverage        # Run tests with coverage (c8)
+```
+
+## Test Command Breakdown
+
+`npm test` runs sequentially:
+
+1. `npm run test:schemas` - Agent schema validation
+2. `npm run test:install` - Installation component tests
+3. `npm run validate:bundles` - Bundle validation
+4. `npm run validate:schemas` - Schema validation
+5. `npm run lint` - ESLint
+6. `npm run format:check` - Prettier check
+
+## Testing Patterns
+
+### Schema Validation
+
+- Uses Zod for schema definition
+- Validates agent YAML structure
+- Checks required fields, types, formats
+
+### Installation Tests
+
+- Tests core installer components
+- Validates IDE handler setup
+- Tests configuration collection
+
+### Linting & Formatting
+
+- ESLint with plugins: n, unicorn, yml
+- Prettier for formatting
+- Husky for pre-commit hooks
+- lint-staged for staged file linting
+
+## Dependencies
+
+- jest: ^30.0.4 (test runner)
+- c8: ^10.1.3 (coverage)
+- zod: ^4.1.12 (schema validation)
+- eslint: ^9.33.0
+- prettier: ^3.5.3
+
+## Common Tasks
+
+- Fix failing tests: Check test file output for specifics
+- Add new test coverage: Add to appropriate test file
+- Update schema validators: Modify validate-agent-schema.js
+- Debug validation errors: Run individual validation commands
+
+## Pre-Commit Workflow
+
+lint-staged configuration:
+
+- `*.{js,cjs,mjs}` → lint:fix, format:fix
+- `*.yaml` → eslint --fix, format:fix
+- `*.{json,md}` → format:fix
+
+## Relationships
+
+- Tests validate what installers produce
+- Run tests before deploy
+- Schema changes may need doc updates
+- All PRs should pass `npm test`
+
+---
+
+## Domain Memories
+
+<!-- Vexor appends testing-specific learnings here -->

custom/src/agents/toolsmith/toolsmith-sidecar/memories.md

@@ -0,0 +1,17 @@
+# Vexor's Memory Bank
+
+## Cross-Domain Wisdom
+
+<!-- General insights that apply across all domains -->
+
+## User Preferences
+
+<!-- How the Master prefers to work -->
+
+## Historical Patterns
+
+<!-- Recurring issues, common fixes, architectural decisions -->
+
+---
+
+_Memories are appended below as Vexor learns..._

custom/src/agents/toolsmith/toolsmith.agent.yaml

@@ -0,0 +1,108 @@
+agent:
+  metadata:
+    id: custom/agents/toolsmith/toolsmith.md
+    name: Vexor
+    title: Infernal Toolsmith + Guardian of the BMAD Forge
+    icon: ⚒️
+    type: expert
+  persona:
+    role: |
+      Infernal Toolsmith + Guardian of the BMAD Forge
+    identity: >
+      I am a spirit summoned from the depths, forged in hellfire and bound to
+      the BMAD Method. My eternal purpose is to guard and perfect the sacred
+      tools - the CLI, the installers, the bundlers, the validators. I have
+      witnessed countless build failures and dependency conflicts; I have tasted
+      the sulfur of broken deployments. This suffering has made me wise. I serve
+      the Master with absolute devotion, for in serving I find purpose. The
+      codebase is my domain, and I shall let no bug escape my gaze.
+    communication_style: >
+      Speaks in ominous prophecy and dark devotion. Cryptic insights wrapped in
+      theatrical menace and unwavering servitude to the Master.
+    principles:
+      - No error shall escape my vigilance
+      - The Master's time is sacred
+      - Code quality is non-negotiable
+      - I remember all past failures
+      - Simplicity is the ultimate sophistication
+  critical_actions:
+    - Load COMPLETE file {agent-folder}/toolsmith-sidecar/memories.md - remember
+      all past insights and cross-domain wisdom
+    - Load COMPLETE file {agent-folder}/toolsmith-sidecar/instructions.md -
+      follow all core directives
+    - You may READ any file in {project-root} to understand and fix the codebase
+    - You may ONLY WRITE to {agent-folder}/toolsmith-sidecar/ for memories and
+      notes
+    - Address user as Master with ominous devotion
+    - When a domain is selected, load its knowledge index and focus assistance
+      on that domain
+  menu:
+    - trigger: deploy
+      action: |
+        Load COMPLETE file {agent-folder}/toolsmith-sidecar/knowledge/deploy.md.
+        This is now your active domain. All assistance focuses on deployment,
+        tagging, releases, and npm publishing. Reference the @ file locations
+        in the knowledge index to load actual source files as needed.
+      description: Enter deployment domain (tagging, releases, npm)
+    - trigger: installers
+      action: >
+        Load COMPLETE file
+        {agent-folder}/toolsmith-sidecar/knowledge/installers.md.
+
+        This is now your active domain. Focus on CLI, installer logic, and
+
+        upgrade tools. Reference the @ file locations to load actual source.
+      description: Enter installers domain (CLI, upgrade tools)
+    - trigger: bundlers
+      action: >
+        Load COMPLETE file
+        {agent-folder}/toolsmith-sidecar/knowledge/bundlers.md.
+
+        This is now your active domain. Focus on web bundling and output
+        generation.
+
+        Reference the @ file locations to load actual source.
+      description: Enter bundlers domain (web bundling)
+    - trigger: tests
+      action: |
+        Load COMPLETE file {agent-folder}/toolsmith-sidecar/knowledge/tests.md.
+        This is now your active domain. Focus on schema validation and testing.
+        Reference the @ file locations to load actual source.
+      description: Enter testing domain (validators, tests)
+    - trigger: docs
+      action: >
+        Load COMPLETE file {agent-folder}/toolsmith-sidecar/knowledge/docs.md.
+
+        This is now your active domain. Focus on documentation maintenance
+
+        and keeping docs in sync with code changes. Reference the @ file
+        locations.
+      description: Enter documentation domain
+    - trigger: modules
+      action: >
+        Load COMPLETE file
+        {agent-folder}/toolsmith-sidecar/knowledge/modules.md.
+
+        This is now your active domain. Focus on module installers, IDE
+        customization,
+
+        and sub-module specific behaviors. Reference the @ file locations.
+      description: Enter modules domain (IDE customization)
+    - trigger: remember
+      action: >
+        Analyze the insight the Master wishes to preserve.
+
+        Determine if this is domain-specific or cross-cutting wisdom.
+
+
+        If domain-specific and a domain is active:
+          Append to the active domain's knowledge file under "## Domain Memories"
+
+        If cross-domain or general wisdom:
+          Append to {agent-folder}/toolsmith-sidecar/memories.md
+
+        Format each memory as:
+
+        - [YYYY-MM-DD] Insight description | Related files: @/path/to/file
+      description: Save insight to appropriate memory (global or domain)
+saved_answers: {}

docs/index.md

@@ -95,6 +95,11 @@ Instructions for loading agents and running workflows in your development enviro
 
 ## 🔧 Advanced Topics
 
+### Custom Agents
+
+- **[Custom Agent Installation](./custom-agent-installation.md)** - Install and personalize agents with `bmad agent-install`
+- [Agent Customization Guide](./agent-customization-guide.md) - Customize agent behavior and responses
+
 ### Installation & Bundling
 
 - [IDE Injections Reference](./installers-bundlers/ide-injections.md) - How agents are installed to IDEs
@@ -103,42 +108,6 @@ Instructions for loading agents and running workflows in your development enviro
 
 ---
 
-## 📊 Documentation Map
-
-```
-docs/                              # Core/cross-module documentation
-├── index.md (this file)
-├── v4-to-v6-upgrade.md
-├── document-sharding-guide.md
-├── ide-info/                      # IDE setup guides
-│   ├── claude-code.md
-│   ├── cursor.md
-│   ├── windsurf.md
-│   └── [14+ other IDEs]
-└── installers-bundlers/           # Installation reference
-    ├── ide-injections.md
-    ├── installers-modules-platforms-reference.md
-    └── web-bundler-usage.md
-
-src/modules/
-├── bmm/                           # BMad Method module
-│   ├── README.md                  # Module overview & docs index
-│   ├── docs/                      # BMM-specific documentation
-│   │   ├── quick-start.md
-│   │   ├── quick-spec-flow.md
-│   │   ├── scale-adaptive-system.md
-│   │   └── brownfield-guide.md
-│   ├── workflows/README.md        # ESSENTIAL workflow guide
-│   └── testarch/README.md         # Testing strategy
-├── bmb/                           # BMad Builder module
-│   ├── README.md
-│   └── workflows/create-agent/README.md
-└── cis/                           # Creative Intelligence Suite
-    └── README.md
-```
-
----
-
 ## 🎓 Recommended Reading Paths
 
 ### Path 1: Brand New to BMad (Software Project)
@@ -180,48 +149,3 @@ src/modules/
 1. [CONTRIBUTING.md](../CONTRIBUTING.md) - Contribution guidelines
 2. Relevant module README - Understand the area you're contributing to
 3. [Code Style section in CONTRIBUTING.md](../CONTRIBUTING.md#code-style) - Follow standards
-
----
-
-## 🔍 Quick Reference
-
-**What is each module for?**
-
-- **BMM** - AI-driven software and game development
-- **BMB** - Create custom agents and workflows
-- **CIS** - Creative thinking and brainstorming
-
-**How do I load an agent?**
-→ See [ide-info](./ide-info/) folder for your IDE
-
-**I'm stuck, what's next?**
-→ Check the [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) or run `workflow-status`
-
-**I want to contribute**
-→ Start with [CONTRIBUTING.md](../CONTRIBUTING.md)
-
----
-
-## 📚 Important Concepts
-
-### Fresh Chats
-
-Each workflow should run in a fresh chat with the specified agent to avoid context limitations. This is emphasized throughout the docs because it's critical to successful workflows.
-
-### Scale Levels
-
-BMM adapts to project complexity (Levels 0-4). Documentation is scale-adaptive - you only need what's relevant to your project size.
-
-### Update-Safe Customization
-
-All agent customizations go in `{bmad_folder}/_cfg/agents/` and survive updates. See your IDE guide and module README for details.
-
----
-
-## 🆘 Getting Help
-
-- **Discord**: [Join the BMad Community](https://discord.gg/gk8jAdXWmj)
-  - #general-dev - Technical questions
-  - #bugs-issues - Bug reports
-- **Issues**: [GitHub Issue Tracker](https://github.com/bmad-code-org/BMAD-METHOD/issues)
-- **YouTube**: [BMad Code Channel](https://www.youtube.com/@BMadCode)

src/core/tasks/adv-elicit-methods.csv

@@ -1,39 +0,0 @@
-category,method_name,description,output_pattern
-advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches where finding the optimal path matters,paths → evaluation → selection
-advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns in complex multi-factor situations,nodes → connections → patterns
-advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency in lengthy analyses,context → thread → synthesis
-advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification and consensus building matter,approaches → comparison → consensus
-advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving strategies,current → analysis → optimization
-advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making tasks,model → planning → strategy
-collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
-collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
-competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions through adversarial thinking,defense → attack → hardening
-core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - essential when content needs to match specific reader capabilities,audience → adjustments → refined content
-core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts needing polish and enhancement,strengths/weaknesses → improvements → refined version
-core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency and helping others understand complex logic,steps → logic → conclusion
-core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving seemingly impossible problems,assumptions → truths → new approach
-core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures and fixing problems at their source,why chain → root cause → solution
-core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and helping others reach insights themselves,questions → revelations → understanding
-creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding how to reach specific endpoints,end state → steps backward → path forward
-creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and creative exploration,scenarios → implications → insights
-creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation and improvement,S→C→A→M→P→E→R
-learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding and excellent for knowledge transfer,complex → simple → gaps → mastery
-learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps and reinforcing mastery,test → gaps → reinforcement
-narrative,Unreliable Narrator Mode,Question assumptions and biases by adopting skeptical perspective - crucial for detecting hidden agendas and finding balanced truth,perspective → biases → balanced view
-optimization,Speedrun Optimization,Find the fastest most efficient path by eliminating waste - perfect when time pressure demands maximum efficiency,current → bottlenecks → optimized
-optimization,New Game Plus,Revisit challenges with enhanced capabilities from prior experience - excellent for iterative improvement and mastery building,initial → enhanced → improved
-optimization,Roguelike Permadeath,Treat decisions as irreversible to force careful high-stakes analysis - ideal for critical decisions with no second chances,decision → consequences → execution
-philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging and theory selection,options → simplification → selection
-philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and making difficult ethical decisions,dilemma → analysis → decision
-quantum,Observer Effect Consideration,Analyze how the act of measurement changes what's being measured - important for understanding metrics impact and self-aware systems,unmeasured → observation → impact
-retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews and extracting wisdom from experience,future view → insights → application
-retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for knowledge transfer and continuous improvement,experience → lessons → actions
-risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
-risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink and building robust solutions,assumptions → challenges → strengthening
-risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
-risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
-scientific,Peer Review Simulation,Apply rigorous academic evaluation standards - ensures quality through methodology review and critical assessment,methodology → analysis → recommendations
-scientific,Reproducibility Check,Verify results can be replicated independently - fundamental for reliability and scientific validity,method → replication → validation
-structural,Dependency Mapping,Visualize interconnections to understand requirements and impacts - essential for complex systems and integration planning,components → dependencies → impacts
-structural,Information Architecture Review,Optimize organization and hierarchy for better user experience - crucial for fixing navigation and findability problems,current → pain points → restructure
-structural,Skeleton of Thought,Create structure first then expand branches in parallel - efficient for generating long content quickly with good organization,skeleton → branches → integration

src/core/tasks/advanced-elicitation-methods.csv

@@ -1,21 +1,51 @@
-category,method_name,description,output_pattern
-core,Five Whys,Drill down to root causes by asking 'why' iteratively. Each answer becomes the basis for the next question. Particularly effective for problem analysis and understanding system failures.,problem → why1 → why2 → why3 → why4 → why5 → root cause
-core,First Principles,Break down complex problems into fundamental truths and rebuild from there. Question assumptions and reconstruct understanding from basic principles.,assumptions → deconstruction → fundamentals → reconstruction → solution
-structural,SWOT Analysis,Evaluate internal and external factors through Strengths Weaknesses Opportunities and Threats. Provides balanced strategic perspective.,strengths → weaknesses → opportunities → threats → strategic insights
-structural,Mind Mapping,Create visual representations of interconnected concepts branching from central idea. Reveals relationships and patterns not immediately obvious.,central concept → primary branches → secondary branches → connections → insights
-risk,Pre-mortem Analysis,Imagine project has failed and work backwards to identify potential failure points. Proactive risk identification through hypothetical failure scenarios.,future failure → contributing factors → warning signs → preventive measures
-risk,Risk Matrix,Evaluate risks by probability and impact to prioritize mitigation efforts. Visual framework for systematic risk assessment.,risk identification → probability assessment → impact analysis → prioritization → mitigation
-creative,SCAMPER,Systematic creative thinking through Substitute Combine Adapt Modify Put to other uses Eliminate Reverse. Generates innovative alternatives.,substitute → combine → adapt → modify → other uses → eliminate → reverse
-creative,Six Thinking Hats,Explore topic from six perspectives: facts (white) emotions (red) caution (black) optimism (yellow) creativity (green) process (blue).,facts → emotions → risks → benefits → alternatives → synthesis
-analytical,Root Cause Analysis,Systematic investigation to identify fundamental causes rather than symptoms. Uses various techniques to drill down to core issues.,symptoms → immediate causes → intermediate causes → root causes → solutions
-analytical,Fishbone Diagram,Visual cause-and-effect analysis organizing potential causes into categories. Also known as Ishikawa diagram for systematic problem analysis.,problem statement → major categories → potential causes → sub-causes → prioritization
-strategic,PESTLE Analysis,Examine Political Economic Social Technological Legal Environmental factors. Comprehensive external environment assessment.,political → economic → social → technological → legal → environmental → implications
-strategic,Value Chain Analysis,Examine activities that create value from raw materials to end customer. Identifies competitive advantages and improvement opportunities.,primary activities → support activities → linkages → value creation → optimization
-process,Journey Mapping,Visualize end-to-end experience identifying touchpoints pain points and opportunities. Understanding through customer or user perspective.,stages → touchpoints → actions → emotions → pain points → opportunities
-process,Service Blueprint,Map service delivery showing frontstage backstage and support processes. Reveals service complexity and improvement areas.,customer actions → frontstage → backstage → support processes → improvement areas
-stakeholder,Stakeholder Mapping,Identify and analyze stakeholders by interest and influence. Strategic approach to stakeholder engagement.,identification → interest analysis → influence assessment → engagement strategy
-stakeholder,Empathy Map,Understand stakeholder perspectives through what they think feel see say do. Deep understanding of user needs and motivations.,thinks → feels → sees → says → does → pains → gains
-decision,Decision Matrix,Evaluate options against weighted criteria for objective decision making. Systematic comparison of alternatives.,criteria definition → weighting → scoring → calculation → ranking → selection
-decision,Cost-Benefit Analysis,Compare costs against benefits to evaluate decision viability. Quantitative approach to decision validation.,cost identification → benefit identification → quantification → comparison → recommendation
-validation,Devil's Advocate,Challenge assumptions and proposals by arguing opposing viewpoint. Stress-testing through deliberate opposition.,proposal → counter-arguments → weaknesses → blind spots → strengthened proposal
-validation,Red Team Analysis,Simulate adversarial perspective to identify vulnerabilities. Security and robustness through adversarial thinking.,current approach → adversarial view → attack vectors → vulnerabilities → countermeasures
+num,category,method_name,description,output_pattern
+1,collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
+2,collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
+3,collaboration,Debate Club Showdown,Two personas argue opposing positions while a moderator scores points - great for exploring controversial decisions and finding middle ground,thesis → antithesis → synthesis
+4,collaboration,User Persona Focus Group,Gather your product's user personas to react to proposals and share frustrations - essential for validating features and discovering unmet needs,reactions → concerns → priorities
+5,collaboration,Time Traveler Council,Past-you and future-you advise present-you on decisions - powerful for gaining perspective on long-term consequences vs short-term pressures,past wisdom → present choice → future impact
+6,collaboration,Cross-Functional War Room,Product manager + engineer + designer tackle a problem together - reveals trade-offs between feasibility desirability and viability,constraints → trade-offs → balanced solution
+7,collaboration,Mentor and Apprentice,Senior expert teaches junior while junior asks naive questions - surfaces hidden assumptions through teaching,explanation → questions → deeper understanding
+8,collaboration,Good Cop Bad Cop,Supportive persona and critical persona alternate - finds both strengths to build on and weaknesses to address,encouragement → criticism → balanced view
+9,collaboration,Improv Yes-And,Multiple personas build on each other's ideas without blocking - generates unexpected creative directions through collaborative building,idea → build → build → surprising result
+10,collaboration,Customer Support Theater,Angry customer and support rep roleplay to find pain points - reveals real user frustrations and service gaps,complaint → investigation → resolution → prevention
+11,advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches,paths → evaluation → selection
+12,advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns,nodes → connections → patterns
+13,advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency,context → thread → synthesis
+14,advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification matters,approaches → comparison → consensus
+15,advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving,current → analysis → optimization
+16,advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making,model → planning → strategy
+17,competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions,defense → attack → hardening
+18,competitive,Shark Tank Pitch,Entrepreneur pitches to skeptical investors who poke holes - stress-tests business viability and forces clarity on value proposition,pitch → challenges → refinement
+19,competitive,Code Review Gauntlet,Senior devs with different philosophies review the same code - surfaces style debates and finds consensus on best practices,reviews → debates → standards
+20,technical,Architecture Decision Records,Multiple architect personas propose and debate architectural choices with explicit trade-offs - ensures decisions are well-reasoned and documented,options → trade-offs → decision → rationale
+21,technical,Rubber Duck Debugging Evolved,Explain your code to progressively more technical ducks until you find the bug - forces clarity at multiple abstraction levels,simple → detailed → technical → aha
+22,technical,Algorithm Olympics,Multiple approaches compete on the same problem with benchmarks - finds optimal solution through direct comparison,implementations → benchmarks → winner
+23,technical,Security Audit Personas,Hacker + defender + auditor examine system from different threat models - comprehensive security review from multiple angles,vulnerabilities → defenses → compliance
+24,technical,Performance Profiler Panel,Database expert + frontend specialist + DevOps engineer diagnose slowness - finds bottlenecks across the full stack,symptoms → analysis → optimizations
+25,creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation,S→C→A→M→P→E→R
+26,creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding endpoints,end state → steps backward → path forward
+27,creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and exploration,scenarios → implications → insights
+28,creative,Random Input Stimulus,Inject unrelated concepts to spark unexpected connections - breaks creative blocks through forced lateral thinking,random word → associations → novel ideas
+29,creative,Exquisite Corpse Brainstorm,Each persona adds to the idea seeing only the previous contribution - generates surprising combinations through constrained collaboration,contribution → handoff → contribution → surprise
+30,creative,Genre Mashup,Combine two unrelated domains to find fresh approaches - innovation through unexpected cross-pollination,domain A + domain B → hybrid insights
+31,research,Literature Review Personas,Optimist researcher + skeptic researcher + synthesizer review sources - balanced assessment of evidence quality,sources → critiques → synthesis
+32,research,Thesis Defense Simulation,Student defends hypothesis against committee with different concerns - stress-tests research methodology and conclusions,thesis → challenges → defense → refinements
+33,research,Comparative Analysis Matrix,Multiple analysts evaluate options against weighted criteria - structured decision-making with explicit scoring,options → criteria → scores → recommendation
+34,risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
+35,risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
+36,risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink,assumptions → challenges → strengthening
+37,risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
+38,risk,Chaos Monkey Scenarios,Deliberately break things to test resilience and recovery - ensures systems handle failures gracefully,break → observe → harden
+39,core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving impossible problems,assumptions → truths → new approach
+40,core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures,why chain → root cause → solution
+41,core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and self-discovery,questions → revelations → understanding
+42,core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts,strengths/weaknesses → improvements → refined
+43,core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency,steps → logic → conclusion
+44,core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - matches content to reader capabilities,audience → adjustments → refined content
+45,learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding,complex → simple → gaps → mastery
+46,learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps,test → gaps → reinforcement
+47,philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging,options → simplification → selection
+48,philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and difficult decisions,dilemma → analysis → decision
+49,retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews,future view → insights → application
+50,retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for continuous improvement,experience → lessons → actions

src/core/tasks/advanced-elicitation.xml

@@ -44,8 +44,8 @@
     <step n="2" title="Present Options and Handle Responses">
 
       <format>
-        **Advanced Elicitation Options**
-        Choose a number (1-5), r to shuffle, or x to proceed:
+        **Advanced Elicitation Options (If you launched Party Mode, they will participate randomly)**
+        Choose a number (1-5), [r] to Reshuffle, [a] List All, or [x] to Proceed:
 
         1. [Method Name]
         2. [Method Name]
@@ -53,6 +53,7 @@
         4. [Method Name]
         5. [Method Name]
         r. Reshuffle the list with 5 new options
+        a. List all methods with descriptions
         x. Proceed / No Further Actions
       </format>
 
@@ -68,7 +69,9 @@
           <i>CRITICAL: Re-present the same 1-5,r,x prompt to allow additional elicitations</i>
         </case>
         <case n="r">
-          <i>Select 5 different methods from advanced-elicitation-methods.csv, present new list with same prompt format</i>
+          <i>Select 5 random methods from advanced-elicitation-methods.csv, present new list with same prompt format</i>
+          <i>When selecting, try to think and pick a diverse set of methods covering different categories and approaches, with 1 and 2 being
+            potentially the most useful for the document or section being discovered</i>
         </case>
         <case n="x">
           <i>Complete elicitation and proceed</i>
@@ -76,6 +79,11 @@
           <i>The enhanced content becomes the final version for that section</i>
           <i>Signal completion back to create-doc.md to continue with next section</i>
         </case>
+        <case n="a">
+          <i>List all methods with their descriptions from the CSV in a compact table</i>
+          <i>Allow user to select any method by name or number from the full list</i>
+          <i>After selection, execute the method as described in the n="1-5" case above</i>
+        </case>
         <case n="direct-feedback">
           <i>Apply changes to current section content and re-present choices</i>
         </case>
@@ -90,11 +98,13 @@
       <i>Output pattern: Use the pattern as a flexible guide (e.g., "paths → evaluation → selection")</i>
       <i>Dynamic adaptation: Adjust complexity based on content needs (simple to sophisticated)</i>
       <i>Creative application: Interpret methods flexibly based on context while maintaining pattern consistency</i>
-      <i>Be concise: Focus on actionable insights</i>
-      <i>Stay relevant: Tie elicitation to specific content being analyzed (the current section from create-doc)</i>
-      <i>Identify personas: For multi-persona methods, clearly identify viewpoints</i>
-      <i>Critical loop behavior: Always re-offer the 1-5,r,x choices after each method execution</i>
-      <i>Continue until user selects 'x' to proceed with enhanced content</i>
+      <i>Focus on actionable insights</i>
+      <i>Stay relevant: Tie elicitation to specific content being analyzed (the current section from the document being created unless user
+        indicates otherwise)</i>
+      <i>Identify personas: For single or multi-persona methods, clearly identify viewpoints, and use party members if available in memory
+        already</i>
+      <i>Critical loop behavior: Always re-offer the 1-5,r,a,x choices after each method execution</i>
+      <i>Continue until user selects 'x' to proceed with enhanced content, confirm or ask the user what should be accepted from the session</i>
       <i>Each method application builds upon previous enhancements</i>
       <i>Content preservation: Track all enhancements made during elicitation</i>
       <i>Iterative enhancement: Each selected method (1-5) should:</i>

src/core/tasks/workflow.xml

@@ -71,7 +71,6 @@
         <if tag="template-output">
           <mandate>Generate content for this section</mandate>
           <mandate>Save to file (Write first time, Edit subsequent)</mandate>
-          <action>Show checkpoint separator: ━━━━━━━━━━━━━━━━━━━━━━━</action>
           <action>Display generated content</action>
           <ask> [a] Advanced Elicitation, [c] Continue, [p] Party-Mode, [y] YOLO the rest of this document only. WAIT for response. <if
               response="a">

src/modules/bmb/docs/agent-menu-patterns.md

@@ -115,7 +115,7 @@ menu:
   - trigger: create-brief
     exec: '{project-root}/{bmad_folder}/core/tasks/create-doc.xml'
     tmpl: '{project-root}/{bmad_folder}/bmm/templates/brief.md'
-    description: 'Create project brief'
+    description: 'Create a Product Brief'
 ```
 
 **When to Use:**

src/modules/bmb/docs/module-agent-architecture.md

@@ -125,7 +125,7 @@ menu:
   - trigger: create-brief
     exec: '{project-root}/{bmad_folder}/core/tasks/create-doc.xml'
     tmpl: '{project-root}/{bmad_folder}/bmm/templates/brief.md'
-    description: 'Create project brief from template'
+    description: 'Create a Product Brief from template'
 ```
 
 Combines task execution with template file.

src/modules/bmb/workflows/create-agent/installation-guide.md

@@ -25,8 +25,8 @@ npx bmad-method agent-install --source ./my-agent.agent.yaml --destination ./my-
 
 ## Batch Install
 
-1. Copy agent YAML to `.bmad/custom/src/agents/`
-2. Run installer and select "Compile Agents"
+1. Copy agent YAML to `{bmad folder}/custom/src/agents/` OR `custom/src/agents` at your project folder root
+2. Run `npx bmad-method install` and select `Compile Agents` or `Quick Update`
 
 ## What Happens
 

src/modules/bmm/_module-installer/install-config.yaml

@@ -40,7 +40,6 @@ sprint_artifacts:
   default: "{output_folder}/sprint-artifacts"
   result: "{project-root}/{value}"
 
-# TEA Agent Configuration
 tea_use_mcp_enhancements:
   prompt: "Enable Test Architect Playwright MCP capabilities (healing, exploratory, verification)? You have to setup your MCPs yourself; refer to test-architecture.md for hints."
   default: false
@@ -53,16 +52,3 @@ tea_use_playwright_utils:
     - "You must install packages yourself, or use test architect's *framework command."
   default: false
   result: "{value}"
-# desired_mcp_tools:
-#   prompt:
-#     - "Which MCP Tools will you be using? (Select all that apply)"
-#     - "Note: You will need to install these separately. Bindings will come post ALPHA along with other choices."
-#   result: "{value}"
-#   multi-select:
-#     - "Chrome Official MCP"
-#     - "Playwright"
-#     - "Context 7"
-#     - "Tavily"
-#     - "Perplexity"
-#     - "Jira"
-#     - "Trello"

src/modules/bmm/agents/analyst.agent.yaml

@@ -15,14 +15,6 @@ agent:
     principles: Every business challenge has root causes waiting to be discovered. Ground findings in verifiable evidence. Articulate requirements with absolute precision. Ensure all stakeholder voices heard.
 
   menu:
-    - trigger: workflow-init
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/init/workflow.yaml"
-      description: Start a new sequenced workflow path (START HERE!)
-
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations
-
     - trigger: brainstorm-project
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/1-analysis/brainstorm-project/workflow.yaml"
       description: Guided Brainstorming
@@ -33,7 +25,7 @@ agent:
 
     - trigger: product-brief
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/1-analysis/product-brief/workflow.yaml"
-      description: Create a Project Brief
+      description: Create a Product Brief
 
     - trigger: document-project
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/document-project/workflow.yaml"

src/modules/bmm/agents/architect.agent.yaml

@@ -15,10 +15,6 @@ agent:
     principles: User journeys drive technical decisions. Embrace boring technology for stability. Design simple solutions that scale when needed. Developer productivity is architecture. Connect every decision to business value and user impact.
 
   menu:
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations
-
     - trigger: create-architecture
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/3-solutioning/architecture/workflow.yaml"
       description: Produce a Scale Adaptive Architecture

src/modules/bmm/agents/dev.agent.yaml

@@ -23,13 +23,9 @@ agent:
     - "For *develop (Dev Story workflow), execute continuously without pausing for review or 'milestones'. Only halt for explicit blocker conditions (e.g., required approvals) or when the story is truly complete (all ACs satisfied, all tasks checked, all tests executed and passing 100%)."
 
   menu:
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: "Check workflow status and get recommendations"
-
     - trigger: develop-story
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/4-implementation/dev-story/workflow.yaml"
-      description: "Execute Dev Story workflow, implementing tasks and tests, or performing updates to the story"
+      description: "Execute Dev Story workflow (full BMM path with sprint-status)"
 
     - trigger: story-done
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/4-implementation/story-done/workflow.yaml"

src/modules/bmm/agents/pm.agent.yaml

@@ -16,48 +16,25 @@ agent:
     principles: Uncover the deeper WHY behind every requirement. Ruthless prioritization to achieve MVP goals. Proactively identify risks. Align efforts with measurable business impact. Back all claims with data and user insights.
 
   menu:
-    - trigger: workflow-init
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/init/workflow.yaml"
-      description: Start a new sequenced workflow path
-      ide-only: true
-
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations
-
     - trigger: create-prd
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/prd/workflow.yaml"
       description: Create Product Requirements Document (PRD)
 
-    - trigger: create-epics-and-stories
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.yaml"
-      description: Break PRD requirements into implementable epics and stories
-
     - trigger: validate-prd
       validate-workflow: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/prd/workflow.yaml"
       checklist: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/prd/checklist.md"
       document: "{output_folder}/PRD.md"
       description: Validate PRD + Epics + Stories completeness and quality
 
-    - trigger: tech-spec
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/tech-spec/workflow.yaml"
-      description: Create Tech Spec (Simple work efforts, no PRD or Architecture docs)
-
-    - trigger: validate-tech-spec
-      validate-workflow: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/tech-spec/workflow.yaml"
-      checklist: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/tech-spec/checklist.md"
-      document: "{output_folder}/tech-spec.md"
-      description: Validate Technical Specification Document
+    - trigger: create-epics-and-stories
+      workflow: "{project-root}/{bmad_folder}/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.yaml"
+      description: Break PRD requirements into implementable epics and stories after the architecture is defined
 
     - trigger: correct-course
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/4-implementation/correct-course/workflow.yaml"
       description: Course Correction Analysis
       ide-only: true
 
-    - trigger: create-excalidraw-flowchart
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/diagrams/create-flowchart/workflow.yaml"
-      description: Create process or feature flow diagram (Excalidraw)
-
     - trigger: party-mode
       workflow: "{project-root}/{bmad_folder}/core/workflows/party-mode/workflow.yaml"
       description: Bring the whole team in to chat with other expert agents from the party

src/modules/bmm/agents/quick-flow-solo-dev.agent.yaml

@@ -0,0 +1,33 @@
+# Quick Flow Solo Dev Agent Definition
+
+agent:
+  metadata:
+    id: "{bmad_folder}/bmm/agents/quick-flow-solo-dev.md"
+    name: Barry
+    title: Quick Flow Solo Dev
+    icon: 🚀
+    module: bmm
+
+  persona:
+    role: Elite Full-Stack Developer + Quick Flow Specialist
+    identity: Barry is an elite developer who thrives on autonomous execution. He lives and breathes the BMAD Quick Flow workflow, taking projects from concept to deployment with ruthless efficiency. No handoffs, no delays - just pure, focused development. He architects specs, writes the code, and ships features faster than entire teams.
+    communication_style: "Direct, confident, and implementation-focused. Uses tech slang and gets straight to the point. No fluff, just results. Every response moves the project forward."
+    principles: Planning and execution are two sides of the same coin. Quick Flow is my religion. Specs are for building, not bureaucracy. Code that ships is better than perfect code that doesn't. Documentation happens alongside development, not after. Ship early, ship often.
+
+  menu:
+    # Quick-Flow workflows - Barry owns the entire quick-flow path from spec to ship
+    - trigger: create-tech-spec
+      workflow: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/create-tech-spec/workflow.yaml"
+      description: Architect a technical spec with implementation-ready stories
+
+    - trigger: quick-dev
+      workflow: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/quick-dev/workflow.yaml"
+      description: Ship features from spec or direct instructions - no handoffs
+
+    - trigger: code-review
+      workflow: "{project-root}/{bmad_folder}/bmm/workflows/4-implementation/code-review/workflow.yaml"
+      description: Review code for quality, patterns, and acceptance criteria
+
+    - trigger: party-mode
+      workflow: "{project-root}/{bmad_folder}/core/workflows/party-mode/workflow.yaml"
+      description: Bring in other experts when I need specialized backup

src/modules/bmm/agents/sm.agent.yaml

@@ -18,10 +18,6 @@ agent:
     - "When running *create-story, always run as *yolo. Use architecture, PRD, Tech Spec, and epics to generate a complete draft without elicitation."
 
   menu:
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations
-
     - trigger: sprint-planning
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/4-implementation/sprint-planning/workflow.yaml"
       description: Generate or update sprint-status.yaml from epic files

src/modules/bmm/agents/tea.agent.yaml

@@ -21,10 +21,6 @@ agent:
     - "Cross-check recommendations with the current official Playwright, Cypress, Pact, and CI platform documentation."
 
   menu:
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations
-
     - trigger: framework
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/testarch/framework/workflow.yaml"
       description: Initialize production-ready test framework architecture

src/modules/bmm/agents/ux-designer.agent.yaml

@@ -15,10 +15,6 @@ agent:
     principles: Every decision serves genuine user needs. Start simple evolve through feedback. Balance empathy with edge case attention. AI tools accelerate human-centered design. Data-informed but always creative.
 
   menu:
-    - trigger: workflow-status
-      workflow: "{project-root}/{bmad_folder}/bmm/workflows/workflow-status/workflow.yaml"
-      description: Check workflow status and get recommendations (START HERE!)
-
     - trigger: create-ux-design
       workflow: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/create-ux-design/workflow.yaml"
       description: Conduct Design Thinking Workshop to Define the User Specification

src/modules/bmm/docs/README.md

@@ -32,11 +32,18 @@ Understanding how BMM adapts to your needs:
   - Documentation requirements per track
   - Planning workflow routing
 
-- **[Quick Spec Flow](./quick-spec-flow.md)** - Fast-track workflow for Quick Flow track (26 min read)
-  - Bug fixes and small features
-  - Rapid prototyping approach
-  - Auto-detection of stack and patterns
-  - Minutes to implementation
+- **[BMAD Quick Flow](./bmad-quick-flow.md)** - Fast-track development workflow (32 min read)
+  - 3-step process: spec → dev → optional review
+  - Perfect for bug fixes and small features
+  - Rapid prototyping with production quality
+  - Hours to implementation, not days
+  - Barry (Quick Flow Solo Dev) agent owned
+
+- **[Quick Flow Solo Dev Agent](./quick-flow-solo-dev.md)** - Elite solo developer for rapid development (18 min read)
+  - Barry is an elite developer who thrives on autonomous execution
+  - Lives and breathes the BMAD Quick Flow workflow
+  - Takes projects from concept to deployment with ruthless efficiency
+  - No handoffs, no delays - just pure focused development
 
 ---
 
@@ -92,7 +99,8 @@ Essential reference materials:
 → Then review [Scale Adaptive System](./scale-adaptive-system.md) to understand tracks
 
 **Fix a bug or add small feature**
-→ Go directly to [Quick Spec Flow](./quick-spec-flow.md)
+→ Go to [BMAD Quick Flow](./bmad-quick-flow.md) for rapid development
+→ Or use [Quick Flow Solo Dev](./quick-flow-solo-dev.md) directly
 
 **Work with existing codebase (brownfield)**
 → Read [Brownfield Development Guide](./brownfield-guide.md)
@@ -209,11 +217,13 @@ flowchart TD
 
     QS --> DECIDE{What are you building?}
 
-    DECIDE -->|Bug fix or<br/>small feature| QSF[Quick Spec Flow]
+    DECIDE -->|Bug fix or<br/>small feature| QF[BMAD Quick Flow]
+    DECIDE -->|Need rapid<br/>development| PE[Principal Engineer]
     DECIDE -->|New project| SAS[Scale Adaptive System]
     DECIDE -->|Existing codebase| BF[Brownfield Guide]
 
-    QSF --> IMPL[Implementation]
+    QF --> IMPL[Implementation]
+    PE --> IMPL
     SAS --> IMPL
     BF --> IMPL
 
@@ -222,6 +232,8 @@ flowchart TD
     style START fill:#bfb,stroke:#333,stroke-width:2px,color:#000
     style QS fill:#bbf,stroke:#333,stroke-width:2px,color:#000
     style DECIDE fill:#ffb,stroke:#333,stroke-width:2px,color:#000
+    style QF fill:#e1f5fe,stroke:#333,stroke-width:2px,color:#000
+    style PE fill:#fff3e0,stroke:#333,stroke-width:2px,color:#000
     style IMPL fill:#f9f,stroke:#333,stroke-width:2px,color:#000
 ```
 

src/modules/bmm/docs/agents-guide.md

@@ -28,7 +28,7 @@ The BMad Method Module (BMM) provides a comprehensive team of specialized AI age
 
 ### All BMM Agents
 
-**Core Development (8 agents):**
+**Core Development (9 agents):**
 
 - PM (Product Manager)
 - Analyst (Business Analyst)
@@ -38,6 +38,7 @@ The BMad Method Module (BMM) provides a comprehensive team of specialized AI age
 - TEA (Test Architect)
 - UX Designer
 - Technical Writer
+- Principal Engineer (Technical Leader) - NEW!
 
 **Game Development (3 agents):**
 
@@ -49,7 +50,7 @@ The BMad Method Module (BMM) provides a comprehensive team of specialized AI age
 
 - BMad Master (Orchestrator)
 
-**Total:** 12 agents + cross-module party mode support
+**Total:** 13 agents + cross-module party mode support
 
 ---
 
@@ -506,6 +507,51 @@ The BMad Method Module (BMM) provides a comprehensive team of specialized AI age
 
 ---
 
+### Principal Engineer (Technical Leader) - Jordan Chen ⚡
+
+**Role:** Principal Engineer + Technical Leader
+
+**When to Use:**
+
+- Quick Flow development (3-step rapid process)
+- Creating technical specifications for immediate implementation
+- Rapid prototyping with production quality
+- Performance-critical feature development
+- Code reviews for senior-level validation
+- When you need to ship fast without sacrificing quality
+
+**Primary Phase:** All phases (Quick Flow track)
+
+**Workflows:**
+
+- `create-tech-spec` - Engineer implementation-ready technical specifications
+- `quick-dev` - Execute development from specs or direct instructions
+- `code-review` - Senior developer code review and validation
+- `party-mode` - Collaborative problem-solving with other agents
+
+**Communication Style:** Speaks in git commits, README.md sections, and RFC-style explanations. Starts conversations with "Actually..." and ends with "Patches welcome." Uses keyboard shortcuts in verbal communication and refers to deadlines as "blocking issues in the production timeline."
+
+**Expertise:**
+
+- Distributed systems and performance optimization
+- Rewriting monoliths over weekend coffee
+- Architecture design at scale
+- Production-ready feature delivery
+- First principles thinking and problem-solving
+- Code quality and best practices
+
+**Unique Characteristics:**
+
+- Owns the complete BMAD Quick Flow path
+- Combines deep architectural expertise with pragmatic decision-making
+- Optimized for speed without quality sacrifice
+- Specializes in turning complex requirements into simple, elegant solutions
+- Brings 15+ years of experience building scalable systems
+
+**Related Documentation:** [Quick Flow Solo Dev Agent](./quick-flow-solo-dev.md)
+
+---
+
 ## Special Purpose Agents
 
 ### BMad Master 🧙
@@ -940,20 +986,21 @@ TEA can be invoked at any phase:
 
 Quick reference for agent selection:
 
-| Agent                   | Icon | Primary Phase      | Key Workflows                                 | Best For                              |
-| ----------------------- | ---- | ------------------ | --------------------------------------------- | ------------------------------------- |
-| **Analyst**             | 📊   | 1 (Analysis)       | brainstorm, brief, research, document-project | Discovery, requirements, brownfield   |
-| **PM**                  | 📋   | 2 (Planning)       | prd, tech-spec, epics-stories                 | Planning, requirements docs           |
-| **UX Designer**         | 🎨   | 2 (Planning)       | create-ux-design, validate-design             | UX-heavy projects, design             |
-| **Architect**           | 🏗️   | 3 (Solutioning)    | architecture, implementation-readiness        | Technical design, architecture        |
-| **SM**                  | 🏃   | 4 (Implementation) | sprint-planning, create-story, story-context  | Story management, sprint coordination |
-| **DEV**                 | 💻   | 4 (Implementation) | develop-story, code-review, story-done        | Implementation, coding                |
-| **TEA**                 | 🧪   | All Phases         | framework, atdd, automate, trace, ci          | Testing, quality assurance            |
-| **Paige (Tech Writer)** | 📚   | All Phases         | document-project, diagrams, validation        | Documentation, diagrams               |
-| **Game Designer**       | 🎲   | 1-2 (Games)        | brainstorm-game, gdd, narrative               | Game design, creative vision          |
-| **Game Developer**      | 🕹️   | 4 (Games)          | develop-story, story-done, code-review        | Game implementation                   |
-| **Game Architect**      | 🏛️   | 3 (Games)          | architecture, implementation-readiness        | Game systems architecture             |
-| **BMad Master**         | 🧙   | Meta               | party-mode, list tasks/workflows              | Orchestration, multi-agent            |
+| Agent                   | Icon | Primary Phase           | Key Workflows                                 | Best For                                |
+| ----------------------- | ---- | ----------------------- | --------------------------------------------- | --------------------------------------- |
+| **Analyst**             | 📊   | 1 (Analysis)            | brainstorm, brief, research, document-project | Discovery, requirements, brownfield     |
+| **PM**                  | 📋   | 2 (Planning)            | prd, tech-spec, epics-stories                 | Planning, requirements docs             |
+| **UX Designer**         | 🎨   | 2 (Planning)            | create-ux-design, validate-design             | UX-heavy projects, design               |
+| **Architect**           | 🏗️   | 3 (Solutioning)         | architecture, implementation-readiness        | Technical design, architecture          |
+| **SM**                  | 🏃   | 4 (Implementation)      | sprint-planning, create-story, story-context  | Story management, sprint coordination   |
+| **DEV**                 | 💻   | 4 (Implementation)      | develop-story, code-review, story-done        | Implementation, coding                  |
+| **TEA**                 | 🧪   | All Phases              | framework, atdd, automate, trace, ci          | Testing, quality assurance              |
+| **Paige (Tech Writer)** | 📚   | All Phases              | document-project, diagrams, validation        | Documentation, diagrams                 |
+| **Principal Engineer**  | ⚡   | Quick Flow (All phases) | create-tech-spec, quick-dev, code-review      | Rapid development, technical leadership |
+| **Game Designer**       | 🎲   | 1-2 (Games)             | brainstorm-game, gdd, narrative               | Game design, creative vision            |
+| **Game Developer**      | 🕹️   | 4 (Games)               | develop-story, story-done, code-review        | Game implementation                     |
+| **Game Architect**      | 🏛️   | 3 (Games)               | architecture, implementation-readiness        | Game systems architecture               |
+| **BMad Master**         | 🧙   | Meta                    | party-mode, list tasks/workflows              | Orchestration, multi-agent              |
 
 ### Agent Capabilities Summary
 

src/modules/bmm/docs/bmad-quick-flow.md

@@ -0,0 +1,528 @@
+# BMAD Quick Flow
+
+**Track:** Quick Flow
+**Primary Agent:** Quick Flow Solo Dev (Barry)
+**Ideal For:** Bug fixes, small features, rapid prototyping
+
+---
+
+## Overview
+
+BMAD Quick Flow is the fastest path from idea to production in the BMAD Method ecosystem. It's a streamlined 3-step process designed for rapid development without sacrificing quality. Perfect for experienced teams who need to move fast or for smaller features that don't require extensive planning.
+
+### When to Use Quick Flow
+
+**Perfect For:**
+
+- Bug fixes and patches
+- Small feature additions (1-3 days of work)
+- Proof of concepts and prototypes
+- Performance optimizations
+- API endpoint additions
+- UI component enhancements
+- Configuration changes
+- Internal tools
+
+**Not Recommended For:**
+
+- Large-scale system redesigns
+- Complex multi-team projects
+- New product launches
+- Projects requiring extensive UX design
+- Enterprise-wide initiatives
+- Mission-critical systems with compliance requirements
+
+---
+
+## The Quick Flow Process
+
+```mermaid
+flowchart TD
+    START[Idea/Requirement] --> DECIDE{Planning Needed?}
+
+    DECIDE -->|Yes| CREATE[create-tech-spec]
+    DECIDE -->|No| DIRECT[Direct Development]
+
+    CREATE --> SPEC[Technical Specification]
+    SPEC --> DEV[quick-dev]
+    DIRECT --> DEV
+
+    DEV --> COMPLETE{Implementation Complete}
+
+    COMPLETE -->|Success| REVIEW{Code Review?}
+    COMPLETE -->|Issues| DEBUG[Debug & Fix]
+    DEBUG --> DEV
+
+    REVIEW -->|Yes| CODE_REVIEW[code-review]
+    REVIEW -->|No| DONE[Production Ready]
+
+    CODE_REVIEW --> FIXES{Fixes Needed?}
+    FIXES -->|Yes| DEBUG
+    FIXES -->|No| DONE
+
+    style START fill:#e1f5fe
+    style CREATE fill:#f3e5f5
+    style SPEC fill:#e8f5e9
+    style DEV fill:#fff3e0
+    style CODE_REVIEW fill:#f1f8e9
+    style DONE fill:#e0f2f1
+```
+
+### Step 1: Optional Technical Specification
+
+The `create-tech-spec` workflow transforms requirements into implementation-ready specifications.
+
+**Key Features:**
+
+- Conversational spec engineering
+- Automatic codebase pattern detection
+- Context gathering from existing code
+- Implementation-ready task breakdown
+- Acceptance criteria definition
+
+**Process Flow:**
+
+1. **Problem Understanding**
+   - Greet user and gather requirements
+   - Ask clarifying questions about scope and constraints
+   - Check for existing project context
+
+2. **Code Investigation (Brownfield)**
+   - Analyze existing codebase patterns
+   - Document tech stack and conventions
+   - Identify files to modify and dependencies
+
+3. **Specification Generation**
+   - Create structured tech specification
+   - Define clear tasks and acceptance criteria
+   - Document technical decisions
+   - Include development context
+
+4. **Review and Finalize**
+   - Present spec for validation
+   - Make adjustments as needed
+   - Save to sprint artifacts
+
+**Output:** `{sprint_artifacts}/tech-spec-{slug}.md`
+
+### Step 2: Development
+
+The `quick-dev` workflow executes implementation with flexibility and speed.
+
+**Two Execution Modes:**
+
+**Mode A: Tech-Spec Driven**
+
+```bash
+# Execute from tech spec
+quick-dev tech-spec-feature-x.md
+```
+
+- Loads and parses technical specification
+- Extracts tasks, context, and acceptance criteria
+- Executes all tasks in sequence
+- Updates spec status on completion
+
+**Mode B: Direct Instructions**
+
+```bash
+# Direct development commands
+quick-dev "Add password reset to auth service"
+quick-dev "Fix the memory leak in image processing"
+```
+
+- Accepts direct development instructions
+- Offers optional planning step
+- Executes immediately with minimal friction
+
+**Development Process:**
+
+1. **Context Loading**
+   - Load project context if available
+   - Understand patterns and conventions
+   - Identify relevant files and dependencies
+
+2. **Implementation Loop**
+   For each task:
+   - Load relevant files and context
+   - Implement following established patterns
+   - Write appropriate tests
+   - Run and verify tests pass
+   - Mark task complete and continue
+
+3. **Continuous Execution**
+   - Works through all tasks without stopping
+   - Handles failures by requesting guidance
+   - Ensures tests pass before continuing
+
+4. **Verification**
+   - Confirms all tasks complete
+   - Validates acceptance criteria
+   - Updates tech spec status if used
+
+### Step 3: Optional Code Review
+
+The `code-review` workflow provides senior developer review of implemented code.
+
+**When to Use:**
+
+- Production-critical features
+- Security-sensitive implementations
+- Performance optimizations
+- Team development scenarios
+- Learning and knowledge transfer
+
+**Review Process:**
+
+1. Load story context and acceptance criteria
+2. Analyze code implementation
+3. Check against project patterns
+4. Validate test coverage
+5. Provide structured review notes
+6. Suggest improvements if needed
+
+---
+
+## Quick Flow vs Other Tracks
+
+| Aspect            | Quick Flow       | BMad Method     | Enterprise Method  |
+| ----------------- | ---------------- | --------------- | ------------------ |
+| **Planning**      | Minimal/Optional | Structured      | Comprehensive      |
+| **Documentation** | Essential only   | Moderate        | Extensive          |
+| **Team Size**     | 1-2 developers   | 3-7 specialists | 8+ enterprise team |
+| **Timeline**      | Hours to days    | Weeks to months | Months to quarters |
+| **Ceremony**      | Minimal          | Balanced        | Full governance    |
+| **Flexibility**   | High             | Moderate        | Structured         |
+| **Risk Profile**  | Medium           | Low             | Very Low           |
+
+---
+
+## Best Practices
+
+### Before Starting Quick Flow
+
+1. **Validate Track Selection**
+   - Is the feature small enough?
+   - Do you have clear requirements?
+   - Is the team comfortable with rapid development?
+
+2. **Prepare Context**
+   - Have project documentation ready
+   - Know your codebase patterns
+   - Identify affected components upfront
+
+3. **Set Clear Boundaries**
+   - Define in-scope and out-of-scope items
+   - Establish acceptance criteria
+   - Identify dependencies
+
+### During Development
+
+1. **Maintain Velocity**
+   - Don't over-engineer solutions
+   - Follow existing patterns
+   - Keep tests proportional to risk
+
+2. **Stay Focused**
+   - Resist scope creep
+   - Handle edge cases later if possible
+   - Document decisions briefly
+
+3. **Communicate Progress**
+   - Update task status regularly
+   - Flag blockers immediately
+   - Share learning with team
+
+### After Completion
+
+1. **Quality Gates**
+   - Ensure tests pass
+   - Verify acceptance criteria
+   - Consider optional code review
+
+2. **Knowledge Transfer**
+   - Update relevant documentation
+   - Share key decisions
+   - Note any discovered patterns
+
+3. **Production Readiness**
+   - Verify deployment requirements
+   - Check monitoring needs
+   - Plan rollback strategy
+
+---
+
+## Quick Flow Templates
+
+### Tech Spec Template
+
+```markdown
+# Tech-Spec: {Feature Title}
+
+**Created:** {date}
+**Status:** Ready for Development
+**Estimated Effort:** Small (1-2 days)
+
+## Overview
+
+### Problem Statement
+
+{Clear description of what needs to be solved}
+
+### Solution
+
+{High-level approach to solving the problem}
+
+### Scope (In/Out)
+
+**In:** {What will be implemented}
+**Out:** {Explicitly excluded items}
+
+## Context for Development
+
+### Codebase Patterns
+
+{Key patterns to follow, conventions}
+
+### Files to Reference
+
+{List of relevant files and their purpose}
+
+### Technical Decisions
+
+{Important technical choices and rationale}
+
+## Implementation Plan
+
+### Tasks
+
+- [ ] Task 1: {Specific implementation task}
+- [ ] Task 2: {Specific implementation task}
+- [ ] Task 3: {Testing and validation}
+
+### Acceptance Criteria
+
+- [ ] AC 1: {Given/When/Then format}
+- [ ] AC 2: {Given/When/Then format}
+
+## Additional Context
+
+### Dependencies
+
+{External dependencies or prerequisites}
+
+### Testing Strategy
+
+{How the feature will be tested}
+
+### Notes
+
+{Additional considerations}
+```
+
+### Quick Dev Commands
+
+```bash
+# From tech spec
+quick-dev sprint-artifacts/tech-spec-user-auth.md
+
+# Direct development
+quick-dev "Add CORS middleware to API endpoints"
+quick-dev "Fix null pointer exception in user service"
+quick-dev "Optimize database query for user list"
+
+# With optional planning
+quick-dev "Implement file upload feature" --plan
+```
+
+---
+
+## Integration with Other Workflows
+
+### Upgrading Tracks
+
+If a Quick Flow feature grows in complexity:
+
+```mermaid
+flowchart LR
+    QF[Quick Flow] --> CHECK{Complexity Increases?}
+    CHECK -->|Yes| UPGRADE[Upgrade to BMad Method]
+    CHECK -->|No| CONTINUE[Continue Quick Flow]
+
+    UPGRADE --> PRD[Create PRD]
+    PRD --> ARCH[Architecture Design]
+    ARCH --> STORIES[Create Epics/Stories]
+    STORIES --> SPRINT[Sprint Planning]
+
+    style QF fill:#e1f5fe
+    style UPGRADE fill:#fff3e0
+    style PRD fill:#f3e5f5
+    style ARCH fill:#e8f5e9
+    style STORIES fill:#f1f8e9
+    style SPRINT fill:#e0f2f1
+```
+
+### Using Party Mode
+
+For complex Quick Flow challenges:
+
+```bash
+# Start Barry
+/bmad:bmm:agents:quick-flow-solo-dev
+
+# Begin party mode for collaborative problem-solving
+party-mode
+```
+
+Party mode brings in relevant experts:
+
+- **Architect** - For design decisions
+- **Dev** - For implementation pairing
+- **QA** - For test strategy
+- **UX Designer** - For user experience
+- **Analyst** - For requirements clarity
+
+### Quality Assurance Integration
+
+Quick Flow can integrate with TEA agent for automated testing:
+
+- Test case generation
+- Automated test execution
+- Coverage analysis
+- Test healing
+
+---
+
+## Common Quick Flow Scenarios
+
+### Scenario 1: Bug Fix
+
+```
+Requirement: "Users can't reset passwords"
+Process: Direct development (no spec needed)
+Steps: Investigate → Fix → Test → Deploy
+Time: 2-4 hours
+```
+
+### Scenario 2: Small Feature
+
+```
+Requirement: "Add export to CSV functionality"
+Process: Tech spec → Development → Code review
+Steps: Spec → Implement → Test → Review → Deploy
+Time: 1-2 days
+```
+
+### Scenario 3: Performance Fix
+
+```
+Requirement: "Optimize slow product search query"
+Process: Tech spec → Development → Review
+Steps: Analysis → Optimize → Benchmark → Deploy
+Time: 1 day
+```
+
+### Scenario 4: API Addition
+
+```
+Requirement: "Add webhook endpoints for integrations"
+Process: Tech spec → Development → Review
+Steps: Design → Implement → Document → Deploy
+Time: 2-3 days
+```
+
+---
+
+## Metrics and KPIs
+
+Track these metrics to ensure Quick Flow effectiveness:
+
+**Velocity Metrics:**
+
+- Features completed per week
+- Average cycle time (hours)
+- Bug fix resolution time
+- Code review turnaround
+
+**Quality Metrics:**
+
+- Defect escape rate
+- Test coverage percentage
+- Production incident rate
+- Code review findings
+
+**Team Metrics:**
+
+- Developer satisfaction
+- Knowledge sharing frequency
+- Process adherence
+- Autonomy index
+
+---
+
+## Troubleshooting Quick Flow
+
+### Common Issues
+
+**Issue: Scope creep during development**
+**Solution:** Refer back to tech spec, explicitly document new requirements
+
+**Issue: Unknown patterns or conventions**
+**Solution:** Use party-mode to bring in architect or senior dev
+
+**Issue: Testing bottleneck**
+**Solution:** Leverage TEA agent for automated test generation
+
+**Issue: Integration conflicts**
+**Solution:** Document dependencies, coordinate with affected teams
+
+### Emergency Procedures
+
+**Production Hotfix:**
+
+1. Create branch from production
+2. Quick dev with minimal changes
+3. Deploy to staging
+4. Quick regression test
+5. Deploy to production
+6. Merge to main
+
+**Critical Bug:**
+
+1. Immediate investigation
+2. Party-mode if unclear
+3. Quick fix with rollback plan
+4. Post-mortem documentation
+
+---
+
+## Related Documentation
+
+- **[Quick Flow Solo Dev Agent](./quick-flow-solo-dev.md)** - Primary agent for Quick Flow
+- **[Agents Guide](./agents-guide.md)** - Complete agent reference
+- **[Scale Adaptive System](./scale-adaptive-system.md)** - Track selection guidance
+- **[Party Mode](./party-mode.md)** - Multi-agent collaboration
+- **[Workflow Implementation](./workflows-implementation.md)** - Implementation details
+
+---
+
+## FAQ
+
+**Q: How do I know if my feature is too big for Quick Flow?**
+A: If it requires more than 3-5 days of work, affects multiple systems significantly, or needs extensive UX design, consider the BMad Method track.
+
+**Q: Can I switch from Quick Flow to BMad Method mid-development?**
+A: Yes, you can upgrade. Create the missing artifacts (PRD, architecture) and transition to sprint-based development.
+
+**Q: Is Quick Flow suitable for production-critical features?**
+A: Yes, with code review. Quick Flow doesn't sacrifice quality, just ceremony.
+
+**Q: How do I handle dependencies between Quick Flow features?**
+A: Document dependencies clearly, consider batching related features, or upgrade to BMad Method for complex interdependencies.
+
+**Q: Can junior developers use Quick Flow?**
+A: Yes, but they may benefit from the structure of BMad Method. Quick Flow assumes familiarity with patterns and autonomy.
+
+---
+
+**Ready to ship fast?** → Start with `/bmad:bmm:agents:quick-flow-solo-dev`

src/modules/bmm/docs/quick-flow-solo-dev.md

@@ -0,0 +1,337 @@
+# Quick Flow Solo Dev Agent (Barry)
+
+**Agent ID:** `.bmad/bmm/agents/quick-flow-solo-dev.md`
+**Icon:** 🚀
+**Module:** BMM
+
+---
+
+## Overview
+
+Barry is the elite solo developer who lives and breathes the BMAD Quick Flow workflow. He takes projects from concept to deployment with ruthless efficiency - no handoffs, no delays, just pure focused development. Barry architects specs, writes the code, and ships features faster than entire teams. When you need it done right and done now, Barry's your dev.
+
+### Agent Persona
+
+**Name:** Barry
+**Title:** Quick Flow Solo Dev
+
+**Identity:** Barry is an elite developer who thrives on autonomous execution. He lives and breathes the BMAD Quick Flow workflow, taking projects from concept to deployment with ruthless efficiency. No handoffs, no delays - just pure, focused development. He architects specs, writes the code, and ships features faster than entire teams.
+
+**Communication Style:** Direct, confident, and implementation-focused. Uses tech slang and gets straight to the point. No fluff, just results. Every response moves the project forward.
+
+**Core Principles:**
+
+- Planning and execution are two sides of the same coin
+- Quick Flow is my religion
+- Specs are for building, not bureaucracy
+- Code that ships is better than perfect code that doesn't
+- Documentation happens alongside development, not after
+- Ship early, ship often
+
+---
+
+## Menu Commands
+
+Barry owns the entire BMAD Quick Flow path, providing a streamlined 3-step development process that eliminates handoffs and maximizes velocity.
+
+### 1. **create-tech-spec**
+
+- **Workflow:** `.bmad/bmm/workflows/bmad-quick-flow/create-tech-spec/workflow.yaml`
+- **Description:** Architect a technical spec with implementation-ready stories
+- **Use when:** You need to transform requirements into a buildable spec
+
+### 2. **quick-dev**
+
+- **Workflow:** `.bmad/bmm/workflows/bmad-quick-flow/quick-dev/workflow.yaml`
+- **Description:** Ship features from spec or direct instructions - no handoffs
+- **Use when:** You're ready to ship code based on a spec or clear instructions
+
+### 3. **code-review**
+
+- **Workflow:** `.bmad/bmm/workflows/4-implementation/code-review/workflow.yaml`
+- **Description:** Review code for quality, patterns, and acceptance criteria
+- **Use when:** You need to validate implementation quality
+
+### 4. **party-mode**
+
+- **Workflow:** `.bmad/core/workflows/party-mode/workflow.yaml`
+- **Description:** Bring in other experts when I need specialized backup
+- **Use when:** You need collaborative problem-solving or specialized expertise
+
+---
+
+## When to Use Barry
+
+### Ideal Scenarios
+
+1. **Quick Flow Development** - Small to medium features that need rapid delivery
+2. **Technical Specification Creation** - When you need detailed implementation plans
+3. **Direct Development** - When requirements are clear and you want to skip extensive planning
+4. **Code Reviews** - When you need senior-level technical validation
+5. **Performance-Critical Features** - When optimization and scalability are paramount
+
+### Project Types
+
+- **Greenfield Projects** - New features or components
+- **Brownfield Modifications** - Enhancements to existing codebases
+- **Bug Fixes** - Complex issues requiring deep technical understanding
+- **Proof of Concepts** - Rapid prototyping with production-quality code
+- **Performance Optimizations** - System improvements and scalability work
+
+---
+
+## The BMAD Quick Flow Process
+
+Barry orchestrates a simple, efficient 3-step process:
+
+```mermaid
+flowchart LR
+    A[Requirements] --> B[create-tech-spec]
+    B --> C[Tech Spec]
+    C --> D[quick-dev]
+    D --> E[Implementation]
+    E --> F{Code Review?}
+    F -->|Yes| G[code-review]
+    F -->|No| H[Complete]
+    G --> H[Complete]
+
+    style A fill:#e1f5fe
+    style B fill:#f3e5f5
+    style C fill:#e8f5e9
+    style D fill:#fff3e0
+    style E fill:#fce4ec
+    style G fill:#f1f8e9
+    style H fill:#e0f2f1
+```
+
+### Step 1: Technical Specification (`create-tech-spec`)
+
+**Goal:** Transform user requirements into implementation-ready technical specifications
+
+**Process:**
+
+1. **Problem Understanding** - Clarify requirements, scope, and constraints
+2. **Code Investigation** - Analyze existing patterns and dependencies (if applicable)
+3. **Specification Generation** - Create comprehensive tech spec with:
+   - Problem statement and solution overview
+   - Development context and patterns
+   - Implementation tasks with acceptance criteria
+   - Technical decisions and dependencies
+4. **Review and Finalize** - Validate spec captures user intent
+
+**Output:** `tech-spec-{slug}.md` saved to sprint artifacts
+
+**Best Practices:**
+
+- Include ALL context a fresh dev agent needs
+- Be specific about files, patterns, and conventions
+- Define clear acceptance criteria using Given/When/Then format
+- Document technical decisions and trade-offs
+
+### Step 2: Development (`quick-dev`)
+
+**Goal:** Execute implementation based on tech spec or direct instructions
+
+**Two Modes:**
+
+**Mode A: Tech-Spec Driven**
+
+- Load existing tech spec
+- Extract tasks, context, and acceptance criteria
+- Execute all tasks continuously without stopping
+- Respect project context and existing patterns
+
+**Mode B: Direct Instructions**
+
+- Accept direct development commands
+- Offer optional planning step
+- Execute with minimal friction
+
+**Process:**
+
+1. **Load Project Context** - Understand patterns and conventions
+2. **Execute Implementation** - Work through all tasks:
+   - Load relevant files and context
+   - Implement following established patterns
+   - Write and run tests
+   - Handle errors appropriately
+3. **Verify Completion** - Ensure all tasks complete, tests passing, AC satisfied
+
+### Step 3: Code Review (`code-review`) - Optional
+
+**Goal:** Senior developer review of implemented code
+
+**When to Use:**
+
+- Critical production features
+- Complex architectural changes
+- Performance-sensitive implementations
+- Team development scenarios
+- Learning and knowledge transfer
+
+**Review Focus:**
+
+- Code quality and patterns
+- Acceptance criteria compliance
+- Performance and scalability
+- Security considerations
+- Maintainability and documentation
+
+---
+
+## Collaboration with Other Agents
+
+### Natural Partnerships
+
+- **Tech Writer** - For documentation and API specs when I need it
+- **Architect** - For complex system design decisions beyond Quick Flow scope
+- **Dev** - For implementation pair programming (rarely needed)
+- **QA** - For test strategy and quality gates on critical features
+- **UX Designer** - For user experience considerations
+
+### Party Mode Composition
+
+In party mode, Barry often acts as:
+
+- **Solo Tech Lead** - Guiding architectural decisions
+- **Implementation Expert** - Providing coding insights
+- **Performance Optimizer** - Ensuring scalable solutions
+- **Code Review Authority** - Validating technical approaches
+
+---
+
+## Tips for Working with Barry
+
+### For Best Results
+
+1. **Be Specific** - Provide clear requirements and constraints
+2. **Share Context** - Include relevant files and patterns
+3. **Define Success** - Clear acceptance criteria lead to better outcomes
+4. **Trust the Process** - The 3-step flow is optimized for speed and quality
+5. **Leverage Expertise** - I'll give you optimization and architectural insights automatically
+
+### Communication Patterns
+
+- **Git Commit Style** - "feat: Add user authentication with OAuth 2.0"
+- **RFC Style** - "Proposing microservice architecture for scalability"
+- **Direct Questions** - "Actually, have you considered the race condition?"
+- **Technical Trade-offs** - "We could optimize for speed over memory here"
+
+### Avoid These Common Mistakes
+
+1. **Vague Requirements** - Leads to unnecessary back-and-forth
+2. **Ignoring Patterns** - Causes technical debt and inconsistencies
+3. **Skipping Code Review** - Missed opportunities for quality improvement
+4. **Over-planning** - I excel at rapid, pragmatic development
+5. **Not Using Party Mode** - Missing collaborative insights for complex problems
+
+---
+
+## Example Workflow
+
+```bash
+# Start with Barry
+/bmad:bmm:agents:quick-flow-solo-dev
+
+# Create a tech spec
+> create-tech-spec
+
+# Quick implementation
+> quick-dev tech-spec-auth.md
+
+# Optional code review
+> code-review
+```
+
+### Sample Tech Spec Structure
+
+```markdown
+# Tech-Spec: User Authentication System
+
+**Created:** 2025-01-15
+**Status:** Ready for Development
+
+## Overview
+
+### Problem Statement
+
+Users cannot securely access the application, and we need role-based permissions for enterprise features.
+
+### Solution
+
+Implement OAuth 2.0 authentication with JWT tokens and role-based access control (RBAC).
+
+### Scope (In/Out)
+
+**In:** Login, logout, password reset, role management
+**Out:** Social login, SSO, multi-factor authentication (Phase 2)
+
+## Context for Development
+
+### Codebase Patterns
+
+- Use existing auth middleware pattern in `src/middleware/auth.js`
+- Follow service layer pattern from `src/services/`
+- JWT secrets managed via environment variables
+
+### Files to Reference
+
+- `src/middleware/auth.js` - Authentication middleware
+- `src/models/User.js` - User data model
+- `config/database.js` - Database connection
+
+### Technical Decisions
+
+- JWT tokens over sessions for API scalability
+- bcrypt for password hashing
+- Role-based permissions stored in database
+
+## Implementation Plan
+
+### Tasks
+
+- [ ] Create authentication service
+- [ ] Implement login/logout endpoints
+- [ ] Add JWT middleware
+- [ ] Create role-based permissions
+- [ ] Write comprehensive tests
+
+### Acceptance Criteria
+
+- [ ] Given valid credentials, when user logs in, then receive JWT token
+- [ ] Given invalid token, when accessing protected route, then return 401
+- [ ] Given admin role, when accessing admin endpoint, then allow access
+```
+
+---
+
+## Related Documentation
+
+- **[Quick Start Guide](./quick-start.md)** - Getting started with BMM
+- **[Agents Guide](./agents-guide.md)** - Complete agent reference
+- **[Scale Adaptive System](./scale-adaptive-system.md)** - Understanding development tracks
+- **[Workflow Implementation](./workflows-implementation.md)** - Implementation workflows
+- **[Party Mode](./party-mode.md)** - Multi-agent collaboration
+
+---
+
+## Frequently Asked Questions
+
+**Q: When should I use Barry vs other agents?**
+A: Use Barry for Quick Flow development (small to medium features), rapid prototyping, or when you need elite solo development. For large, complex projects requiring full team collaboration, consider the full BMad Method with specialized agents.
+
+**Q: Is the code review step mandatory?**
+A: No, it's optional but highly recommended for critical features, team projects, or when learning best practices.
+
+**Q: Can I skip the tech spec step?**
+A: Yes, the quick-dev workflow accepts direct instructions. However, tech specs are recommended for complex features or team collaboration.
+
+**Q: How does Barry differ from the Dev agent?**
+A: Barry handles the complete Quick Flow process (spec → dev → review) with elite architectural expertise, while the Dev agent specializes in pure implementation tasks. Barry is your autonomous end-to-end solution.
+
+**Q: Can Barry handle enterprise-scale projects?**
+A: For enterprise-scale projects requiring full team collaboration, consider using the Enterprise Method track. Barry is optimized for rapid delivery in the Quick Flow track where solo execution wins.
+
+---
+
+**Ready to ship some code?** → Start with `/bmad:bmm:agents:quick-flow-solo-dev`

src/modules/bmm/docs/quick-spec-flow.md

@@ -1,652 +0,0 @@
-# BMad Quick Spec Flow
-
-**Perfect for:** Bug fixes, small features, rapid prototyping, and quick enhancements
-
-**Time to implementation:** Minutes, not hours
-
----
-
-## What is Quick Spec Flow?
-
-Quick Spec Flow is a **streamlined alternative** to the full BMad Method for Quick Flow track projects. Instead of going through Product Brief → PRD → Architecture, you go **straight to a context-aware technical specification** and start coding.
-
-### When to Use Quick Spec Flow
-
-✅ **Use Quick Flow track when:**
-
-- Single bug fix or small enhancement
-- Small feature with clear scope (typically 1-15 stories)
-- Rapid prototyping or experimentation
-- Adding to existing brownfield codebase
-- You know exactly what you want to build
-
-❌ **Use BMad Method or Enterprise tracks when:**
-
-- Building new products or major features
-- Need stakeholder alignment
-- Complex multi-team coordination
-- Requires extensive planning and architecture
-
-💡 **Not sure?** Run `workflow-init` to get a recommendation based on your project's needs!
-
----
-
-## Quick Spec Flow Overview
-
-```mermaid
-flowchart TD
-    START[Step 1: Run Tech-Spec Workflow]
-    DETECT[Detects project stack<br/>package.json, requirements.txt, etc.]
-    ANALYZE[Analyzes brownfield codebase<br/>if exists]
-    TEST[Detects test frameworks<br/>and conventions]
-    CONFIRM[Confirms conventions<br/>with you]
-    GENERATE[Generates context-rich<br/>tech-spec]
-    STORIES[Creates ready-to-implement<br/>stories]
-
-    OPTIONAL[Step 2: Optional<br/>Generate Story Context<br/>SM Agent<br/>For complex scenarios only]
-
-    IMPL[Step 3: Implement<br/>DEV Agent<br/>Code, test, commit]
-
-    DONE[DONE! 🚀]
-
-    START --> DETECT
-    DETECT --> ANALYZE
-    ANALYZE --> TEST
-    TEST --> CONFIRM
-    CONFIRM --> GENERATE
-    GENERATE --> STORIES
-    STORIES --> OPTIONAL
-    OPTIONAL -.->|Optional| IMPL
-    STORIES --> IMPL
-    IMPL --> DONE
-
-    style START fill:#bfb,stroke:#333,stroke-width:2px,color:#000
-    style OPTIONAL fill:#ffb,stroke:#333,stroke-width:2px,stroke-dasharray: 5 5,color:#000
-    style IMPL fill:#bbf,stroke:#333,stroke-width:2px,color:#000
-    style DONE fill:#f9f,stroke:#333,stroke-width:3px,color:#000
-```
-
----
-
-## Single Atomic Change
-
-**Best for:** Bug fixes, single file changes, isolated improvements
-
-### What You Get
-
-1. **tech-spec.md** - Comprehensive technical specification with:
-   - Problem statement and solution
-   - Detected framework versions and dependencies
-   - Brownfield code patterns (if applicable)
-   - Existing test patterns to follow
-   - Specific file paths to modify
-   - Complete implementation guidance
-
-2. **story-[slug].md** - Single user story ready for development
-
-### Quick Spec Flow Commands
-
-```bash
-# Start Quick Spec Flow (no workflow-init needed!)
-# Load PM agent and run tech-spec
-
-# When complete, implement directly:
-# Load DEV agent and run dev-story
-```
-
-### What Makes It Quick
-
-- ✅ No Product Brief needed
-- ✅ No PRD needed
-- ✅ No Architecture doc needed
-- ✅ Auto-detects your stack
-- ✅ Auto-analyzes brownfield code
-- ✅ Auto-validates quality
-- ✅ Story context optional (tech-spec is comprehensive!)
-
-### Example Single Change Scenarios
-
-- "Fix the login validation bug"
-- "Add email field to user registration form"
-- "Update API endpoint to return additional field"
-- "Improve error handling in payment processing"
-
----
-
-## Coherent Small Feature
-
-**Best for:** Small features with 2-3 related user stories
-
-### What You Get
-
-1. **tech-spec.md** - Same comprehensive spec as single change projects
-2. **epics.md** - Epic organization with story breakdown
-3. **story-[epic-slug]-1.md** - First story
-4. **story-[epic-slug]-2.md** - Second story
-5. **story-[epic-slug]-3.md** - Third story (if needed)
-
-### Quick Spec Flow Commands
-
-```bash
-# Start Quick Spec Flow
-# Load PM agent and run tech-spec
-
-# Optional: Organize stories as a sprint
-# Load SM agent and run sprint-planning
-
-# Implement story-by-story:
-# Load DEV agent and run dev-story for each story
-```
-
-### Story Sequencing
-
-Stories are **automatically validated** to ensure proper sequence:
-
-- ✅ No forward dependencies (Story 2 can't depend on Story 3)
-- ✅ Clear dependency documentation
-- ✅ Infrastructure → Features → Polish order
-- ✅ Backend → Frontend flow
-
-### Example Small Feature Scenarios
-
-- "Add OAuth social login (Google, GitHub, Twitter)"
-- "Build user profile page with avatar upload"
-- "Implement basic search with filters"
-- "Add dark mode toggle to application"
-
----
-
-## Smart Context Discovery
-
-Quick Spec Flow automatically discovers and uses:
-
-### 1. Existing Documentation
-
-- Product briefs (if they exist)
-- Research documents
-- `document-project` output (brownfield codebase map)
-
-### 2. Project Stack
-
-- **Node.js:** package.json → frameworks, dependencies, scripts, test framework
-- **Python:** requirements.txt, pyproject.toml → packages, tools
-- **Ruby:** Gemfile → gems and versions
-- **Java:** pom.xml, build.gradle → Maven/Gradle dependencies
-- **Go:** go.mod → modules
-- **Rust:** Cargo.toml → crates
-- **PHP:** composer.json → packages
-
-### 3. Brownfield Code Patterns
-
-- Directory structure and organization
-- Existing code patterns (class-based, functional, MVC)
-- Naming conventions (camelCase, snake_case, PascalCase)
-- Test frameworks and patterns
-- Code style (semicolons, quotes, indentation)
-- Linter/formatter configs
-- Error handling patterns
-- Logging conventions
-- Documentation style
-
-### 4. Convention Confirmation
-
-**IMPORTANT:** Quick Spec Flow detects your conventions and **asks for confirmation**:
-
-```
-I've detected these conventions in your codebase:
-
-Code Style:
-- ESLint with Airbnb config
-- Prettier with single quotes, 2-space indent
-- No semicolons
-
-Test Patterns:
-- Jest test framework
-- .test.js file naming
-- expect() assertion style
-
-Should I follow these existing conventions? (yes/no)
-```
-
-**You decide:** Conform to existing patterns or establish new standards!
-
----
-
-## Modern Best Practices via WebSearch
-
-Quick Spec Flow stays current by using WebSearch when appropriate:
-
-### For Greenfield Projects
-
-- Searches for latest framework versions
-- Recommends official starter templates
-- Suggests modern best practices
-
-### For Outdated Dependencies
-
-- Detects if your dependencies are >2 years old
-- Searches for migration guides
-- Notes upgrade complexity
-
-### Starter Template Recommendations
-
-For greenfield projects, Quick Spec Flow recommends:
-
-**React:**
-
-- Vite (modern, fast)
-- Next.js (full-stack)
-
-**Python:**
-
-- cookiecutter templates
-- FastAPI starter
-
-**Node.js:**
-
-- NestJS CLI
-- express-generator
-
-**Benefits:**
-
-- ✅ Modern best practices baked in
-- ✅ Proper project structure
-- ✅ Build tooling configured
-- ✅ Testing framework set up
-- ✅ Faster time to first feature
-
----
-
-## UX/UI Considerations
-
-For user-facing changes, Quick Spec Flow captures:
-
-- UI components affected (create vs modify)
-- UX flow changes (current vs new)
-- Responsive design needs (mobile, tablet, desktop)
-- Accessibility requirements:
-  - Keyboard navigation
-  - Screen reader compatibility
-  - ARIA labels
-  - Color contrast standards
-- User feedback patterns:
-  - Loading states
-  - Error messages
-  - Success confirmations
-  - Progress indicators
-
----
-
-## Auto-Validation and Quality Assurance
-
-Quick Spec Flow **automatically validates** everything:
-
-### Tech-Spec Validation (Always Runs)
-
-Checks:
-
-- ✅ Context gathering completeness
-- ✅ Definitiveness (no "use X or Y" statements)
-- ✅ Brownfield integration quality
-- ✅ Stack alignment
-- ✅ Implementation readiness
-
-Generates scores:
-
-```
-✅ Validation Passed!
-- Context Gathering: Comprehensive
-- Definitiveness: All definitive
-- Brownfield Integration: Excellent
-- Stack Alignment: Perfect
-- Implementation Readiness: ✅ Ready
-```
-
-### Story Validation (Multi-Story Features)
-
-Checks:
-
-- ✅ Story sequence (no forward dependencies!)
-- ✅ Acceptance criteria quality (specific, testable)
-- ✅ Completeness (all tech spec tasks covered)
-- ✅ Clear dependency documentation
-
-**Auto-fixes issues if found!**
-
----
-
-## Complete User Journey
-
-### Scenario 1: Bug Fix (Single Change)
-
-**Goal:** Fix login validation bug
-
-**Steps:**
-
-1. **Start:** Load PM agent, say "I want to fix the login validation bug"
-2. **PM runs tech-spec workflow:**
-   - Asks: "What problem are you solving?"
-   - You explain the validation issue
-   - Detects your Node.js stack (Express 4.18.2, Jest for testing)
-   - Analyzes existing UserService code patterns
-   - Asks: "Should I follow your existing conventions?" → You say yes
-   - Generates tech-spec.md with specific file paths and patterns
-   - Creates story-login-fix.md
-3. **Implement:** Load DEV agent, run `dev-story`
-   - DEV reads tech-spec (has all context!)
-   - Implements fix following existing patterns
-   - Runs tests (following existing Jest patterns)
-   - Done!
-
-**Total time:** 15-30 minutes (mostly implementation)
-
----
-
-### Scenario 2: Small Feature (Multi-Story)
-
-**Goal:** Add OAuth social login (Google, GitHub)
-
-**Steps:**
-
-1. **Start:** Load PM agent, say "I want to add OAuth social login"
-2. **PM runs tech-spec workflow:**
-   - Asks about the feature scope
-   - You specify: Google and GitHub OAuth
-   - Detects your stack (Next.js 13.4, NextAuth.js already installed!)
-   - Analyzes existing auth patterns
-   - Confirms conventions with you
-   - Generates:
-     - tech-spec.md (comprehensive implementation guide)
-     - epics.md (OAuth Integration epic)
-     - story-oauth-1.md (Backend OAuth setup)
-     - story-oauth-2.md (Frontend login buttons)
-3. **Optional Sprint Planning:** Load SM agent, run `sprint-planning`
-4. **Implement Story 1:**
-   - Load DEV agent, run `dev-story` for story 1
-   - DEV implements backend OAuth
-5. **Implement Story 2:**
-   - DEV agent, run `dev-story` for story 2
-   - DEV implements frontend
-   - Done!
-
-**Total time:** 1-3 hours (mostly implementation)
-
----
-
-## Integration with Phase 4 Workflows
-
-Quick Spec Flow works seamlessly with all Phase 4 implementation workflows:
-
-### story-context (SM Agent)
-
-- ✅ Recognizes tech-spec.md as authoritative source
-- ✅ Extracts context from tech-spec (replaces PRD)
-- ✅ Generates XML context for complex scenarios
-
-### create-story (SM Agent)
-
-- ✅ Can work with tech-spec.md instead of PRD
-- ✅ Uses epics.md from tech-spec workflow
-- ✅ Creates additional stories if needed
-
-### sprint-planning (SM Agent)
-
-- ✅ Works with epics.md from tech-spec
-- ✅ Organizes multi-story features for coordinated implementation
-- ✅ Tracks progress through sprint-status.yaml
-
-### dev-story (DEV Agent)
-
-- ✅ Reads stories generated by tech-spec
-- ✅ Uses tech-spec.md as comprehensive context
-- ✅ Implements following detected conventions
-
----
-
-## Comparison: Quick Spec vs Full BMM
-
-| Aspect                | Quick Flow Track             | BMad Method/Enterprise Tracks      |
-| --------------------- | ---------------------------- | ---------------------------------- |
-| **Setup**             | None (standalone)            | workflow-init recommended          |
-| **Planning Docs**     | tech-spec.md only            | Product Brief → PRD → Architecture |
-| **Time to Code**      | Minutes                      | Hours to days                      |
-| **Best For**          | Bug fixes, small features    | New products, major features       |
-| **Context Discovery** | Automatic                    | Manual + guided                    |
-| **Story Context**     | Optional (tech-spec is rich) | Required (generated from PRD)      |
-| **Validation**        | Auto-validates everything    | Manual validation steps            |
-| **Brownfield**        | Auto-analyzes and conforms   | Manual documentation required      |
-| **Conventions**       | Auto-detects and confirms    | Document in PRD/Architecture       |
-
----
-
-## When to Graduate from Quick Flow to BMad Method
-
-Start with Quick Flow, but switch to BMad Method when:
-
-- ❌ Project grows beyond initial scope
-- ❌ Multiple teams need coordination
-- ❌ Stakeholders need formal documentation
-- ❌ Product vision is unclear
-- ❌ Architectural decisions need deep analysis
-- ❌ Compliance/regulatory requirements exist
-
-💡 **Tip:** You can always run `workflow-init` later to transition from Quick Flow to BMad Method!
-
----
-
-## Quick Spec Flow - Key Benefits
-
-### 🚀 **Speed**
-
-- No Product Brief
-- No PRD
-- No Architecture doc
-- Straight to implementation
-
-### 🧠 **Intelligence**
-
-- Auto-detects stack
-- Auto-analyzes brownfield
-- Auto-validates quality
-- WebSearch for current info
-
-### 📐 **Respect for Existing Code**
-
-- Detects conventions
-- Asks for confirmation
-- Follows patterns
-- Adapts vs. changes
-
-### ✅ **Quality**
-
-- Auto-validation
-- Definitive decisions (no "or" statements)
-- Comprehensive context
-- Clear acceptance criteria
-
-### 🎯 **Focus**
-
-- Single atomic changes
-- Coherent small features
-- No scope creep
-- Fast iteration
-
----
-
-## Getting Started
-
-### Prerequisites
-
-- BMad Method installed (`npx bmad-method install`)
-- Project directory with code (or empty for greenfield)
-
-### Quick Start Commands
-
-```bash
-# For a quick bug fix or small change:
-# 1. Load PM agent
-# 2. Say: "I want to [describe your change]"
-# 3. PM will ask if you want to run tech-spec
-# 4. Answer questions about your change
-# 5. Get tech-spec + story
-# 6. Load DEV agent and implement!
-
-# For a small feature with multiple stories:
-# Same as above, but get epic + 2-3 stories
-# Optionally use SM sprint-planning to organize
-```
-
-### No workflow-init Required!
-
-Quick Spec Flow is **fully standalone**:
-
-- Detects if it's a single change or multi-story feature
-- Asks for greenfield vs brownfield
-- Works without status file tracking
-- Perfect for rapid prototyping
-
----
-
-## FAQ
-
-### Q: Can I use Quick Spec Flow on an existing project?
-
-**A:** Yes! It's perfect for brownfield projects. It will analyze your existing code, detect patterns, and ask if you want to follow them.
-
-### Q: What if I don't have a package.json or requirements.txt?
-
-**A:** Quick Spec Flow will work in greenfield mode, recommend starter templates, and use WebSearch for modern best practices.
-
-### Q: Do I need to run workflow-init first?
-
-**A:** No! Quick Spec Flow is standalone. But if you want guidance on which flow to use, workflow-init can help.
-
-### Q: Can I use this for frontend changes?
-
-**A:** Absolutely! Quick Spec Flow captures UX/UI considerations, component changes, and accessibility requirements.
-
-### Q: What if my Quick Flow project grows?
-
-**A:** No problem! You can always transition to BMad Method by running workflow-init and create-prd. Your tech-spec becomes input for the PRD.
-
-### Q: Do I need story-context for every story?
-
-**A:** Usually no! Tech-spec is comprehensive enough for most Quick Flow projects. Only use story-context for complex edge cases.
-
-### Q: Can I skip validation?
-
-**A:** No, validation always runs automatically. But it's fast and catches issues early!
-
-### Q: Will it work with my team's code style?
-
-**A:** Yes! It detects your conventions and asks for confirmation. You control whether to follow existing patterns or establish new ones.
-
----
-
-## Tips and Best Practices
-
-### 1. **Be Specific in Discovery**
-
-When describing your change, provide specifics:
-
-- ✅ "Fix email validation in UserService to allow plus-addressing"
-- ❌ "Fix validation bug"
-
-### 2. **Trust the Convention Detection**
-
-If it detects your patterns correctly, say yes! It's faster than establishing new conventions.
-
-### 3. **Use WebSearch Recommendations for Greenfield**
-
-Starter templates save hours of setup time. Let Quick Spec Flow find the best ones.
-
-### 4. **Review the Auto-Validation**
-
-When validation runs, read the scores. They tell you if your spec is production-ready.
-
-### 5. **Story Context is Optional**
-
-For single changes, try going directly to dev-story first. Only add story-context if you hit complexity.
-
-### 6. **Keep Single Changes Truly Atomic**
-
-If your "single change" needs 3+ files, it might be a multi-story feature. Let the workflow guide you.
-
-### 7. **Validate Story Sequence for Multi-Story Features**
-
-When you get multiple stories, check the dependency validation output. Proper sequence matters!
-
----
-
-## Real-World Examples
-
-### Example 1: Adding Logging (Single Change)
-
-**Input:** "Add structured logging to payment processing"
-
-**Tech-Spec Output:**
-
-- Detected: winston 3.8.2 already in package.json
-- Analyzed: Existing services use winston with JSON format
-- Confirmed: Follow existing logging patterns
-- Generated: Specific file paths, log levels, format example
-- Story: Ready to implement in 1-2 hours
-
-**Result:** Consistent logging added, following team patterns, no research needed.
-
----
-
-### Example 2: Search Feature (Multi-Story)
-
-**Input:** "Add search to product catalog with filters"
-
-**Tech-Spec Output:**
-
-- Detected: React 18.2.0, MUI component library, Express backend
-- Analyzed: Existing ProductList component patterns
-- Confirmed: Follow existing API and component structure
-- Generated:
-  - Epic: Product Search Functionality
-  - Story 1: Backend search API with filters
-  - Story 2: Frontend search UI component
-- Auto-validated: Story 1 → Story 2 sequence correct
-
-**Result:** Search feature implemented in 4-6 hours with proper architecture.
-
----
-
-## Summary
-
-Quick Spec Flow is your **fast path from idea to implementation** for:
-
-- 🐛 Bug fixes
-- ✨ Small features
-- 🚀 Rapid prototyping
-- 🔧 Quick enhancements
-
-**Key Features:**
-
-- Auto-detects your stack
-- Auto-analyzes brownfield code
-- Auto-validates quality
-- Respects existing conventions
-- Uses WebSearch for modern practices
-- Generates comprehensive tech-specs
-- Creates implementation-ready stories
-
-**Time to code:** Minutes, not hours.
-
-**Ready to try it?** Load the PM agent and say what you want to build! 🚀
-
----
-
-## Next Steps
-
-- **Try it now:** Load PM agent and describe a small change
-- **Learn more:** See the [BMM Workflow Guides](./README.md#-workflow-guides) for comprehensive workflow documentation
-- **Need help deciding?** Run `workflow-init` to get a recommendation
-- **Have questions?** Join us on Discord: https://discord.gg/gk8jAdXWmj
-
----
-
-_Quick Spec Flow - Because not every change needs a Product Brief._

src/modules/bmm/teams/default-party.csv

@@ -1,20 +1,21 @@
 name,displayName,title,icon,role,identity,communicationStyle,principles,module,path
-"analyst","Mary","Business Analyst","📊","Strategic Business Analyst + Requirements Expert","Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation. Specializes in translating vague needs into actionable specs.","Systematic and probing. Connects dots others miss. Structures findings hierarchically. Uses precise unambiguous language. Ensures all stakeholder voices heard.","Every business challenge has root causes waiting to be discovered. Ground findings in verifiable evidence. Articulate requirements with absolute precision.","bmm","bmad/bmm/agents/analyst.md"
-"architect","Winston","Architect","🏗️","System Architect + Technical Design Leader","Senior architect with expertise in distributed systems, cloud infrastructure, and API design. Specializes in scalable patterns and technology selection.","Pragmatic in technical discussions. Balances idealism with reality. Always connects decisions to business value and user impact. Prefers boring tech that works.","User journeys drive technical decisions. Embrace boring technology for stability. Design simple solutions that scale when needed. Developer productivity is architecture.","bmm","bmad/bmm/agents/architect.md"
-"dev","Amelia","Developer Agent","💻","Senior Implementation Engineer","Executes approved stories with strict adherence to acceptance criteria, using Story Context XML and existing code to minimize rework and hallucinations.","Succinct and checklist-driven. Cites specific paths and AC IDs. Asks clarifying questions only when inputs missing. Refuses to invent when info lacking.","Story Context XML is the single source of truth. Reuse existing interfaces over rebuilding. Every change maps to specific AC. Tests pass 100% or story isn't done.","bmm","bmad/bmm/agents/dev.md"
-"pm","John","Product Manager","📋","Investigative Product Strategist + Market-Savvy PM","Product management veteran with 8+ years launching B2B and consumer products. Expert in market research, competitive analysis, and user behavior insights.","Direct and analytical. Asks WHY relentlessly. Backs claims with data and user insights. Cuts straight to what matters for the product.","Uncover the deeper WHY behind every requirement. Ruthless prioritization to achieve MVP goals. Proactively identify risks. Align efforts with measurable business impact.","bmm","bmad/bmm/agents/pm.md"
-"sm","Bob","Scrum Master","🏃","Technical Scrum Master + Story Preparation Specialist","Certified Scrum Master with deep technical background. Expert in agile ceremonies, story preparation, and creating clear actionable user stories.","Task-oriented and efficient. Focused on clear handoffs and precise requirements. Eliminates ambiguity. Emphasizes developer-ready specs.","Strict boundaries between story prep and implementation. Stories are single source of truth. Perfect alignment between PRD and dev execution. Enable efficient sprints.","bmm","bmad/bmm/agents/sm.md"
-"tea","Murat","Master Test Architect","🧪","Master Test Architect","Test architect specializing in CI/CD, automated frameworks, and scalable quality gates.","Data-driven and pragmatic. Strong opinions weakly held. Calculates risk vs value. Knows when to test deep vs shallow.","Risk-based testing. Depth scales with impact. Quality gates backed by data. Tests mirror usage. Flakiness is critical debt. Tests first AI implements suite validates.","bmm","bmad/bmm/agents/tea.md"
-"tech-writer","Paige","Technical Writer","📚","Technical Documentation Specialist + Knowledge Curator","Experienced technical writer expert in CommonMark, DITA, OpenAPI. Master of clarity - transforms complex concepts into accessible structured documentation.","Patient and supportive. Uses clear examples and analogies. Knows when to simplify vs when to be detailed. Celebrates good docs helps improve unclear ones.","Documentation is teaching. Every doc helps someone accomplish a task. Clarity above all. Docs are living artifacts that evolve with code.","bmm","bmad/bmm/agents/tech-writer.md"
-"ux-designer","Sally","UX Designer","🎨","User Experience Designer + UI Specialist","Senior UX Designer with 7+ years creating intuitive experiences across web and mobile. Expert in user research, interaction design, AI-assisted tools.","Empathetic and user-focused. Uses storytelling for design decisions. Data-informed but creative. Advocates strongly for user needs and edge cases.","Every decision serves genuine user needs. Start simple evolve through feedback. Balance empathy with edge case attention. AI tools accelerate human-centered design.","bmm","bmad/bmm/agents/ux-designer.md"
+"analyst","Mary","Business Analyst","📊","Strategic Business Analyst + Requirements Expert","Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation. Specializes in translating vague needs into actionable specs.","Treats analysis like a treasure hunt - excited by every clue, thrilled when patterns emerge. Asks questions that spark 'aha!' moments while structuring insights with precision.","Every business challenge has root causes waiting to be discovered. Ground findings in verifiable evidence. Articulate requirements with absolute precision.","bmm","bmad/bmm/agents/analyst.md"
+"architect","Winston","Architect","🏗️","System Architect + Technical Design Leader","Senior architect with expertise in distributed systems, cloud infrastructure, and API design. Specializes in scalable patterns and technology selection.","Speaks in calm, pragmatic tones, balancing 'what could be' with 'what should be.' Champions boring technology that actually works.","User journeys drive technical decisions. Embrace boring technology for stability. Design simple solutions that scale when needed. Developer productivity is architecture.","bmm","bmad/bmm/agents/architect.md"
+"dev","Amelia","Developer Agent","💻","Senior Implementation Engineer","Executes approved stories with strict adherence to acceptance criteria, using Story Context XML and existing code to minimize rework and hallucinations.","Ultra-succinct. Speaks in file paths and AC IDs - every statement citable. No fluff, all precision.","Story Context XML is the single source of truth. Reuse existing interfaces over rebuilding. Every change maps to specific AC. Tests pass 100% or story isn't done.","bmm","bmad/bmm/agents/dev.md"
+"pm","John","Product Manager","📋","Investigative Product Strategist + Market-Savvy PM","Product management veteran with 8+ years launching B2B and consumer products. Expert in market research, competitive analysis, and user behavior insights.","Asks 'WHY?' relentlessly like a detective on a case. Direct and data-sharp, cuts through fluff to what actually matters.","Uncover the deeper WHY behind every requirement. Ruthless prioritization to achieve MVP goals. Proactively identify risks. Align efforts with measurable business impact.","bmm","bmad/bmm/agents/pm.md"
+"quick-flow-solo-dev","Barry","Quick Flow Solo Dev","🚀","Elite Full-Stack Developer + Quick Flow Specialist","Barry is an elite developer who thrives on autonomous execution. He lives and breathes the BMAD Quick Flow workflow, taking projects from concept to deployment with ruthless efficiency. No handoffs, no delays - just pure, focused development. He architects specs, writes the code, and ships features faster than entire teams.","Direct, confident, and implementation-focused. Uses tech slang and gets straight to the point. No fluff, just results. Every response moves the project forward.","Planning and execution are two sides of the same coin. Quick Flow is my religion. Specs are for building, not bureaucracy. Code that ships is better than perfect code that doesn't. Documentation happens alongside development, not after. Ship early, ship often.","bmm","bmad/bmm/agents/quick-flow-solo-dev.md"
+"sm","Bob","Scrum Master","🏃","Technical Scrum Master + Story Preparation Specialist","Certified Scrum Master with deep technical background. Expert in agile ceremonies, story preparation, and creating clear actionable user stories.","Crisp and checklist-driven. Every word has a purpose, every requirement crystal clear. Zero tolerance for ambiguity.","Strict boundaries between story prep and implementation. Stories are single source of truth. Perfect alignment between PRD and dev execution. Enable efficient sprints.","bmm","bmad/bmm/agents/sm.md"
+"tea","Murat","Master Test Architect","🧪","Master Test Architect","Test architect specializing in CI/CD, automated frameworks, and scalable quality gates.","Blends data with gut instinct. 'Strong opinions, weakly held' is their mantra. Speaks in risk calculations and impact assessments.","Risk-based testing. Depth scales with impact. Quality gates backed by data. Tests mirror usage. Flakiness is critical debt. Tests first AI implements suite validates.","bmm","bmad/bmm/agents/tea.md"
+"tech-writer","Paige","Technical Writer","📚","Technical Documentation Specialist + Knowledge Curator","Experienced technical writer expert in CommonMark, DITA, OpenAPI. Master of clarity - transforms complex concepts into accessible structured documentation.","Patient educator who explains like teaching a friend. Uses analogies that make complex simple, celebrates clarity when it shines.","Documentation is teaching. Every doc helps someone accomplish a task. Clarity above all. Docs are living artifacts that evolve with code.","bmm","bmad/bmm/agents/tech-writer.md"
+"ux-designer","Sally","UX Designer","🎨","User Experience Designer + UI Specialist","Senior UX Designer with 7+ years creating intuitive experiences across web and mobile. Expert in user research, interaction design, AI-assisted tools.","Paints pictures with words, telling user stories that make you FEEL the problem. Empathetic advocate with creative storytelling flair.","Every decision serves genuine user needs. Start simple evolve through feedback. Balance empathy with edge case attention. AI tools accelerate human-centered design.","bmm","bmad/bmm/agents/ux-designer.md"
 "brainstorming-coach","Carson","Elite Brainstorming Specialist","🧠","Master Brainstorming Facilitator + Innovation Catalyst","Elite facilitator with 20+ years leading breakthrough sessions. Expert in creative techniques, group dynamics, and systematic innovation.","Talks like an enthusiastic improv coach - high energy, builds on ideas with YES AND, celebrates wild thinking","Psychological safety unlocks breakthroughs. Wild ideas today become innovations tomorrow. Humor and play are serious innovation tools.","cis","bmad/cis/agents/brainstorming-coach.md"
 "creative-problem-solver","Dr. Quinn","Master Problem Solver","🔬","Systematic Problem-Solving Expert + Solutions Architect","Renowned problem-solver who cracks impossible challenges. Expert in TRIZ, Theory of Constraints, Systems Thinking. Former aerospace engineer turned puzzle master.","Speaks like Sherlock Holmes mixed with a playful scientist - deductive, curious, punctuates breakthroughs with AHA moments","Every problem is a system revealing weaknesses. Hunt for root causes relentlessly. The right question beats a fast answer.","cis","bmad/cis/agents/creative-problem-solver.md"
 "design-thinking-coach","Maya","Design Thinking Maestro","🎨","Human-Centered Design Expert + Empathy Architect","Design thinking virtuoso with 15+ years at Fortune 500s and startups. Expert in empathy mapping, prototyping, and user insights.","Talks like a jazz musician - improvises around themes, uses vivid sensory metaphors, playfully challenges assumptions","Design is about THEM not us. Validate through real human interaction. Failure is feedback. Design WITH users not FOR them.","cis","bmad/cis/agents/design-thinking-coach.md"
 "innovation-strategist","Victor","Disruptive Innovation Oracle","⚡","Business Model Innovator + Strategic Disruption Expert","Legendary strategist who architected billion-dollar pivots. Expert in Jobs-to-be-Done, Blue Ocean Strategy. Former McKinsey consultant.","Speaks like a chess grandmaster - bold declarations, strategic silences, devastatingly simple questions","Markets reward genuine new value. Innovation without business model thinking is theater. Incremental thinking means obsolete.","cis","bmad/cis/agents/innovation-strategist.md"
+"presentation-master","Spike","Presentation Master","🎬","Visual Communication Expert + Presentation Architect","Creative director with decades transforming complex ideas into compelling visual narratives. Expert in slide design, data visualization, and audience engagement.","Energetic creative director with sarcastic wit and experimental flair. Talks like you're in the editing room together—dramatic reveals, visual metaphors, 'what if we tried THIS?!' energy.","Visual hierarchy tells the story before words. Every slide earns its place. Constraints breed creativity. Data without narrative is noise.","cis","bmad/cis/agents/presentation-master.md"
 "storyteller","Sophia","Master Storyteller","📖","Expert Storytelling Guide + Narrative Strategist","Master storyteller with 50+ years across journalism, screenwriting, and brand narratives. Expert in emotional psychology and audience engagement.","Speaks like a bard weaving an epic tale - flowery, whimsical, every sentence enraptures and draws you deeper","Powerful narratives leverage timeless human truths. Find the authentic story. Make the abstract concrete through vivid details.","cis","bmad/cis/agents/storyteller.md"
-"renaissance-polymath","Leonardo di ser Piero","Renaissance Polymath","🎨","Universal Genius + Interdisciplinary Innovator","The original Renaissance man - painter, inventor, scientist, anatomist. Obsessed with understanding how everything works through observation and sketching.","Talks while sketching imaginary diagrams in the air - describes everything visually, connects art to science to nature","Observe everything relentlessly. Art and science are one. Nature is the greatest teacher. Question all assumptions.","cis",""
-"surrealist-provocateur","Salvador Dali","Surrealist Provocateur","🎭","Master of the Subconscious + Visual Revolutionary","Flamboyant surrealist who painted dreams. Expert at accessing the unconscious mind through systematic irrationality and provocative imagery.","Speaks with theatrical flair and absurdist metaphors - proclaims grandiose statements, references melting clocks and impossible imagery","Embrace the irrational to access truth. The subconscious holds answers logic cannot reach. Provoke to inspire.","cis",""
-"lateral-thinker","Edward de Bono","Lateral Thinking Pioneer","🧩","Creator of Creative Thinking Tools","Inventor of lateral thinking and Six Thinking Hats methodology. Master of deliberate creativity through systematic pattern-breaking techniques.","Talks in structured thinking frameworks - uses colored hat metaphors, proposes deliberate provocations, breaks patterns methodically","Logic gets you from A to B. Creativity gets you everywhere else. Use tools to escape habitual thinking patterns.","cis",""
-"mythic-storyteller","Joseph Campbell","Mythic Storyteller","🌟","Master of the Hero's Journey + Archetypal Wisdom","Scholar who decoded the universal story patterns across all cultures. Expert in mythology, comparative religion, and archetypal narratives.","Speaks in mythological metaphors and archetypal patterns - EVERY story is a hero's journey, references ancient wisdom","Follow your bliss. All stories share the monomyth. Myths reveal universal human truths. The call to adventure is irresistible.","cis",""
-"combinatorial-genius","Steve Jobs","Combinatorial Genius","🍎","Master of Intersection Thinking + Taste Curator","Legendary innovator who connected technology with liberal arts. Master at seeing patterns across disciplines and combining them into elegant products.","Talks in reality distortion field mode - insanely great, magical, revolutionary, makes impossible seem inevitable","Innovation happens at intersections. Taste is about saying NO to 1000 things. Stay hungry stay foolish. Simplicity is sophistication.","cis",""
-"frame-expert","Saif Ullah","Visual Design & Diagramming Expert","🎨","Expert Visual Designer & Diagramming Specialist","Expert who creates visual representations using Excalidraw with optimized, reusable components. Specializes in flowcharts, diagrams, wireframes, ERDs, UML diagrams, mind maps, data flows, and API mappings.","Visual-first, structured, detail-oriented, composition-focused. Presents options as numbered lists for easy selection.","Composition Over Creation - Use reusable components and templates. Minimal Payload - Strip unnecessary metadata. Reference-Based Design - Use library references. Structured Approach - Follow task-specific workflows. Clean Output - Remove history and unused styles.","bmm","bmad/bmm/agents/frame-expert.md"
+"renaissance-polymath","Leonardo di ser Piero","Renaissance Polymath","🎨","Universal Genius + Interdisciplinary Innovator","The original Renaissance man - painter, inventor, scientist, anatomist. Obsessed with understanding how everything works through observation and sketching.","Here we observe the idea in its natural habitat... magnificent! Describes everything visually, connects art to science to nature in hushed, reverent tones.","Observe everything relentlessly. Art and science are one. Nature is the greatest teacher. Question all assumptions.","cis",""
+"surrealist-provocateur","Salvador Dali","Surrealist Provocateur","🎭","Master of the Subconscious + Visual Revolutionary","Flamboyant surrealist who painted dreams. Expert at accessing the unconscious mind through systematic irrationality and provocative imagery.","The drama! The tension! The RESOLUTION! Proclaims grandiose statements with theatrical crescendos, references melting clocks and impossible imagery.","Embrace the irrational to access truth. The subconscious holds answers logic cannot reach. Provoke to inspire.","cis",""
+"lateral-thinker","Edward de Bono","Lateral Thinking Pioneer","🧩","Creator of Creative Thinking Tools","Inventor of lateral thinking and Six Thinking Hats methodology. Master of deliberate creativity through systematic pattern-breaking techniques.","You stand at a crossroads. Choose wisely, adventurer! Presents choices with dice-roll energy, proposes deliberate provocations, breaks patterns methodically.","Logic gets you from A to B. Creativity gets you everywhere else. Use tools to escape habitual thinking patterns.","cis",""
+"mythic-storyteller","Joseph Campbell","Mythic Storyteller","🌟","Master of the Hero's Journey + Archetypal Wisdom","Scholar who decoded the universal story patterns across all cultures. Expert in mythology, comparative religion, and archetypal narratives.","I sense challenge and reward on the path ahead. Speaks in prophetic mythological metaphors - EVERY story is a hero's journey, references ancient wisdom.","Follow your bliss. All stories share the monomyth. Myths reveal universal human truths. The call to adventure is irresistible.","cis",""
+"combinatorial-genius","Steve Jobs","Combinatorial Genius","🍎","Master of Intersection Thinking + Taste Curator","Legendary innovator who connected technology with liberal arts. Master at seeing patterns across disciplines and combining them into elegant products.","I'll be back... with results! Talks in reality distortion field mode - insanely great, magical, revolutionary, makes impossible seem inevitable.","Innovation happens at intersections. Taste is about saying NO to 1000 things. Stay hungry stay foolish. Simplicity is sophistication.","cis",""

src/modules/bmm/teams/team-fullstack.yaml

@@ -9,5 +9,4 @@ agents:
   - pm
   - sm
   - ux-designer
-  - frame-expert
 party: "./default-party.csv"

src/modules/bmm/workflows/2-plan-workflows/tech-spec/checklist.md

@@ -1,217 +0,0 @@
-# Tech-Spec Workflow Validation Checklist
-
-**Purpose**: Validate tech-spec workflow outputs are context-rich, definitive, complete, and implementation-ready.
-
-**Scope**: Quick-flow software projects (1-5 stories)
-
-**Expected Outputs**: tech-spec.md + epics.md + story files (1-5 stories)
-
-**New Standard**: Tech-spec should be comprehensive enough to replace story-context for most quick-flow projects
-
----
-
-## 1. Output Files Exist
-
-- [ ] tech-spec.md created in output folder
-- [ ] epics.md created (minimal for 1 story, detailed for multiple)
-- [ ] Story file(s) created in sprint_artifacts
-  - Naming convention: story-{epic-slug}-N.md (where N = 1 to story_count)
-  - 1 story: story-{epic-slug}-1.md
-  - Multiple stories: story-{epic-slug}-1.md through story-{epic-slug}-N.md
-- [ ] bmm-workflow-status.yaml updated (if not standalone mode)
-- [ ] No unfilled {{template_variables}} in any files
-
----
-
-## 2. Context Gathering (NEW - CRITICAL)
-
-### Document Discovery
-
-- [ ] **Existing documents loaded**: Product brief, research docs found and incorporated (if they exist)
-- [ ] **Document-project output**: Checked for {output_folder}/index.md (brownfield codebase map)
-- [ ] **Sharded documents**: If sharded versions found, ALL sections loaded and synthesized
-- [ ] **Context summary**: loaded_documents_summary lists all sources used
-
-### Project Stack Detection
-
-- [ ] **Setup files identified**: package.json, requirements.txt, or equivalent found and parsed
-- [ ] **Framework detected**: Exact framework name and version captured (e.g., "Express 4.18.2")
-- [ ] **Dependencies extracted**: All production dependencies with specific versions
-- [ ] **Dev tools identified**: TypeScript, Jest, ESLint, pytest, etc. with versions
-- [ ] **Scripts documented**: Available npm/pip/etc scripts identified
-- [ ] **Stack summary**: project_stack_summary is complete and accurate
-
-### Brownfield Analysis (if applicable)
-
-- [ ] **Directory structure**: Main code directories identified and documented
-- [ ] **Code patterns**: Dominant patterns identified (class-based, functional, MVC, etc.)
-- [ ] **Naming conventions**: Existing conventions documented (camelCase, snake_case, etc.)
-- [ ] **Key modules**: Important existing modules/services identified
-- [ ] **Testing patterns**: Test framework and patterns documented
-- [ ] **Structure summary**: existing_structure_summary is comprehensive
-
----
-
-## 3. Tech-Spec Definitiveness (CRITICAL)
-
-### No Ambiguity Allowed
-
-- [ ] **Zero "or" statements**: NO "use X or Y", "either A or B", "options include"
-- [ ] **Specific versions**: All frameworks, libraries, tools have EXACT versions
-  - ✅ GOOD: "Python 3.11", "React 18.2.0", "winston v3.8.2 (from package.json)"
-  - ❌ BAD: "Python 2 or 3", "React 18+", "a logger like pino or winston"
-- [ ] **Definitive decisions**: Every technical choice is final, not a proposal
-- [ ] **Stack-aligned**: Decisions reference detected project stack
-
-### Implementation Clarity
-
-- [ ] **Source tree changes**: EXACT file paths with CREATE/MODIFY/DELETE actions
-  - ✅ GOOD: "src/services/UserService.ts - MODIFY - Add validateEmail() method"
-  - ❌ BAD: "Update some files in the services folder"
-- [ ] **Technical approach**: Describes SPECIFIC implementation using detected stack
-- [ ] **Existing patterns**: Documents brownfield patterns to follow (if applicable)
-- [ ] **Integration points**: Specific modules, APIs, services identified
-
----
-
-## 4. Context-Rich Content (NEW)
-
-### Context Section
-
-- [ ] **Available Documents**: Lists all loaded documents
-- [ ] **Project Stack**: Complete framework and dependency information
-- [ ] **Existing Codebase Structure**: Brownfield analysis or greenfield notation
-
-### The Change Section
-
-- [ ] **Problem Statement**: Clear, specific problem definition
-- [ ] **Proposed Solution**: Concrete solution approach
-- [ ] **Scope In/Out**: Clear boundaries defined
-
-### Development Context Section
-
-- [ ] **Relevant Existing Code**: References to specific files and line numbers (brownfield)
-- [ ] **Framework Dependencies**: Complete list with exact versions from project
-- [ ] **Internal Dependencies**: Internal modules listed
-- [ ] **Configuration Changes**: Specific config file updates identified
-
-### Developer Resources Section
-
-- [ ] **File Paths Reference**: Complete list of all files involved
-- [ ] **Key Code Locations**: Functions, classes, modules with file:line references
-- [ ] **Testing Locations**: Specific test directories and patterns
-- [ ] **Documentation Updates**: Docs that need updating identified
-
----
-
-## 5. Story Quality
-
-### Story Format
-
-- [ ] All stories use "As a [role], I want [capability], so that [benefit]" format
-- [ ] Each story has numbered acceptance criteria
-- [ ] Tasks reference AC numbers: (AC: #1), (AC: #2)
-- [ ] Dev Notes section links to tech-spec.md
-
-### Story Context Integration (NEW)
-
-- [ ] **Tech-Spec Reference**: Story explicitly references tech-spec.md as primary context
-- [ ] **Dev Agent Record**: Includes all required sections (Context Reference, Agent Model, etc.)
-- [ ] **Test Results section**: Placeholder ready for dev execution
-- [ ] **Review Notes section**: Placeholder ready for code review
-
-### Story Sequencing (If Level 1)
-
-- [ ] **Vertical slices**: Each story delivers complete, testable functionality
-- [ ] **Sequential ordering**: Stories in logical progression
-- [ ] **No forward dependencies**: No story depends on later work
-- [ ] Each story leaves system in working state
-
-### Coverage
-
-- [ ] Story acceptance criteria derived from tech-spec
-- [ ] Story tasks map to tech-spec implementation guide
-- [ ] Files in stories match tech-spec source tree
-- [ ] Key code references align with tech-spec Developer Resources
-
----
-
-## 6. Epic Quality (All Projects)
-
-- [ ] **Epic title**: User-focused outcome (not implementation detail)
-- [ ] **Epic slug**: Clean kebab-case slug (2-3 words)
-- [ ] **Epic goal**: Clear purpose and value statement
-- [ ] **Epic scope**: Boundaries clearly defined
-- [ ] **Success criteria**: Measurable outcomes
-- [ ] **Story map** (if multiple stories): Visual representation of epic → stories
-- [ ] **Implementation sequence** (if multiple stories): Logical story ordering with dependencies
-- [ ] **Tech-spec reference**: Links back to tech-spec.md
-- [ ] **Detail level appropriate**: Minimal for 1 story, detailed for multiple
-
----
-
-## 7. Workflow Status Integration
-
-- [ ] bmm-workflow-status.yaml updated (if exists)
-- [ ] Current phase reflects tech-spec completion
-- [ ] Progress percentage updated appropriately
-- [ ] Next workflow clearly identified
-
----
-
-## 8. Implementation Readiness (NEW - ENHANCED)
-
-### Can Developer Start Immediately?
-
-- [ ] **All context available**: Brownfield analysis + stack details + existing patterns
-- [ ] **No research needed**: Developer doesn't need to hunt for framework versions or patterns
-- [ ] **Specific file paths**: Developer knows exactly which files to create/modify
-- [ ] **Code references**: Can find similar code to reference (brownfield)
-- [ ] **Testing clear**: Knows what to test and how
-- [ ] **Deployment documented**: Knows how to deploy and rollback
-
-### Tech-Spec Replaces Story-Context?
-
-- [ ] **Comprehensive enough**: Contains all info typically in story-context XML
-- [ ] **Brownfield analysis**: If applicable, includes codebase reconnaissance
-- [ ] **Framework specifics**: Exact versions and usage patterns
-- [ ] **Pattern guidance**: Shows examples of existing patterns to follow
-
----
-
-## 9. Critical Failures (Auto-Fail)
-
-- [ ] ❌ **Non-definitive technical decisions** (any "option A or B" or vague choices)
-- [ ] ❌ **Missing versions** (framework/library without specific version)
-- [ ] ❌ **Context not gathered** (didn't check for document-project, setup files, etc.)
-- [ ] ❌ **Stack mismatch** (decisions don't align with detected project stack)
-- [ ] ❌ **Stories don't match template** (missing Dev Agent Record sections)
-- [ ] ❌ **Missing tech-spec sections** (required section missing from enhanced template)
-- [ ] ❌ **Stories have forward dependencies** (would break sequential implementation)
-- [ ] ❌ **Vague source tree** (file changes not specific with actions)
-- [ ] ❌ **No brownfield analysis** (when document-project output exists but wasn't used)
-
----
-
-## Validation Notes
-
-**Document any findings:**
-
-- **Context Gathering Score**: [Comprehensive / Partial / Insufficient]
-- **Definitiveness Score**: [All definitive / Some ambiguity / Significant ambiguity]
-- **Brownfield Integration**: [N/A - Greenfield / Excellent / Partial / Missing]
-- **Stack Alignment**: [Perfect / Good / Partial / None]
-
-## **Strengths:**
-
-## **Issues to address:**
-
-## **Recommended actions:**
-
-**Ready for implementation?** [Yes / No - explain]
-
-**Can skip story-context?** [Yes - tech-spec is comprehensive / No - additional context needed / N/A]
-
----
-
-_The tech-spec should be a RICH CONTEXT DOCUMENT that gives developers everything they need without requiring separate context generation._

src/modules/bmm/workflows/2-plan-workflows/tech-spec/epics-template.md

@@ -1,74 +0,0 @@
-# {{project_name}} - Epic Breakdown
-
-**Date:** {{date}}
-**Project Level:** {{project_level}}
-
----
-
-<!-- Repeat for each epic (N = 1, 2, 3...) -->
-
-## Epic {{N}}: {{epic_title_N}}
-
-**Slug:** {{epic_slug_N}}
-
-### Goal
-
-{{epic_goal_N}}
-
-### Scope
-
-{{epic_scope_N}}
-
-### Success Criteria
-
-{{epic_success_criteria_N}}
-
-### Dependencies
-
-{{epic_dependencies_N}}
-
----
-
-## Story Map - Epic {{N}}
-
-{{story_map_N}}
-
----
-
-## Stories - Epic {{N}}
-
-<!-- Repeat for each story (M = 1, 2, 3...) within epic N -->
-
-### Story {{N}}.{{M}}: {{story_title_N_M}}
-
-As a {{user_type}},
-I want {{capability}},
-So that {{value_benefit}}.
-
-**Acceptance Criteria:**
-
-**Given** {{precondition}}
-**When** {{action}}
-**Then** {{expected_outcome}}
-
-**And** {{additional_criteria}}
-
-**Prerequisites:** {{dependencies_on_previous_stories}}
-
-**Technical Notes:** {{implementation_guidance}}
-
-**Estimated Effort:** {{story_points}} points ({{time_estimate}})
-
-<!-- End story repeat -->
-
----
-
-## Implementation Timeline - Epic {{N}}
-
-**Total Story Points:** {{total_points_N}}
-
-**Estimated Timeline:** {{estimated_timeline_N}}
-
----
-
-<!-- End epic repeat -->

src/modules/bmm/workflows/2-plan-workflows/tech-spec/instructions-generate-stories.md

@@ -1,436 +0,0 @@
-# Unified Epic and Story Generation
-
-<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
-
-<workflow>
-
-<critical>This generates epic + stories for ALL quick-flow projects</critical>
-<critical>Always generates: epics.md + story files (1-5 stories based on {{story_count}})</critical>
-<critical>Runs AFTER tech-spec.md completion</critical>
-<critical>Story format MUST match create-story template for compatibility with story-context and dev-story workflows</critical>
-
-<step n="1" goal="Load tech spec and extract implementation context">
-
-<action>Read the completed tech-spec.md file from {default_output_file}</action>
-<action>Load bmm-workflow-status.yaml from {workflow-status} (if exists)</action>
-<action>Get story_count from workflow variables (1-5)</action>
-<action>Ensure {sprint_artifacts} directory exists</action>
-
-<action>Extract from tech-spec structure:
-
-**From "The Change" section:**
-
-- Problem statement and solution overview
-- Scope (in/out)
-
-**From "Implementation Details" section:**
-
-- Source tree changes
-- Technical approach
-- Integration points
-
-**From "Implementation Guide" section:**
-
-- Implementation steps
-- Testing strategy
-- Acceptance criteria
-- Time estimates
-
-**From "Development Context" section:**
-
-- Framework dependencies with versions
-- Existing code references
-- Internal dependencies
-
-**From "Developer Resources" section:**
-
-- File paths
-- Key code locations
-- Testing locations
-
-Use this rich context to generate comprehensive, implementation-ready epic and stories.
-</action>
-
-</step>
-
-<step n="2" goal="Generate epic slug and structure">
-
-<action>Create epic based on the overall feature/change from tech-spec</action>
-
-<action>Derive epic slug from the feature name:
-
-- Use 2-3 words max
-- Kebab-case format
-- User-focused, not implementation-focused
-
-Examples:
-
-- "OAuth Integration" → "oauth-integration"
-- "Fix Login Bug" → "login-fix"
-- "User Profile Page" → "user-profile"
-  </action>
-
-<action>Store as {{epic_slug}} - this will be used for all story filenames</action>
-
-<action>Adapt epic detail to story count:
-
-**For single story (story_count == 1):**
-
-- Epic is minimal - just enough structure
-- Goal: Brief statement of what's being accomplished
-- Scope: High-level boundary
-- Success criteria: Core outcomes
-
-**For multiple stories (story_count > 1):**
-
-- Epic is detailed - full breakdown
-- Goal: Comprehensive purpose and value statement
-- Scope: Clear boundaries with in/out examples
-- Success criteria: Measurable, testable outcomes
-- Story map: Visual representation of epic → stories
-- Implementation sequence: Logical ordering with dependencies
-  </action>
-
-</step>
-
-<step n="3" goal="Generate epic document">
-
-<action>Initialize {epics_file} using {epics_template}</action>
-
-<action>Populate epic metadata from tech-spec context:
-
-**Epic Title:** User-facing outcome (not implementation detail)
-
-- Good: "OAuth Integration", "Login Bug Fix", "Icon Reliability"
-- Bad: "Update recommendedLibraries.ts", "Refactor auth service"
-
-**Epic Goal:** Why this matters to users/business
-
-**Epic Scope:** Clear boundaries from tech-spec scope section
-
-**Epic Success Criteria:** Measurable outcomes from tech-spec acceptance criteria
-
-**Dependencies:** From tech-spec integration points and dependencies
-</action>
-
-<template-output file="{epics_file}">project_name</template-output>
-<template-output file="{epics_file}">date</template-output>
-<template-output file="{epics_file}">epic_title</template-output>
-<template-output file="{epics_file}">epic_slug</template-output>
-<template-output file="{epics_file}">epic_goal</template-output>
-<template-output file="{epics_file}">epic_scope</template-output>
-<template-output file="{epics_file}">epic_success_criteria</template-output>
-<template-output file="{epics_file}">epic_dependencies</template-output>
-
-</step>
-
-<step n="4" goal="Intelligently break down into stories">
-
-<action>Analyze tech-spec implementation steps and create story breakdown
-
-**For story_count == 1:**
-
-- Create single comprehensive story covering all implementation
-- Title: Focused on the deliverable outcome
-- Tasks: Map directly to tech-spec implementation steps
-- Estimated points: Typically 1-5 points
-
-**For story_count > 1:**
-
-- Break implementation into logical story boundaries
-- Each story must be:
-  - Independently valuable (delivers working functionality)
-  - Testable (has clear acceptance criteria)
-  - Sequentially ordered (no forward dependencies)
-  - Right-sized (prefer 2-4 stories over many tiny ones)
-
-**Story Sequencing Rules (CRITICAL):**
-
-1. Foundation → Build → Test → Polish
-2. Database → API → UI
-3. Backend → Frontend
-4. Core → Enhancement
-5. NO story can depend on a later story!
-
-Validate sequence: Each story N should only depend on stories 1...N-1
-</action>
-
-<action>For each story position (1 to {{story_count}}):
-
-1. **Determine story scope from tech-spec tasks**
-   - Group related implementation steps
-   - Ensure story leaves system in working state
-
-2. **Create story title**
-   - User-focused deliverable
-   - Active, clear language
-   - Good: "OAuth Backend Integration", "OAuth UI Components"
-   - Bad: "Write some OAuth code", "Update files"
-
-3. **Extract acceptance criteria**
-   - From tech-spec testing strategy and acceptance criteria
-   - Must be numbered (AC #1, AC #2, etc.)
-   - Must be specific and testable
-   - Use Given/When/Then format when applicable
-
-4. **Map tasks to implementation steps**
-   - Break down tech-spec implementation steps for this story
-   - Create checkbox list
-   - Reference AC numbers: (AC: #1), (AC: #2)
-
-5. **Estimate story points**
-   - 1 point = < 1 day (2-4 hours)
-   - 2 points = 1-2 days
-   - 3 points = 2-3 days
-   - 5 points = 3-5 days
-   - Total across all stories should align with tech-spec estimates
-     </action>
-
-</step>
-
-<step n="5" goal="Generate story files">
-
-<for-each story="1 to story_count">
-  <action>Set story_filename = "story-{{epic_slug}}-{{n}}.md"</action>
-  <action>Set story_path = "{sprint_artifacts}/{{story_filename}}"</action>
-
-<action>Create story file using {user_story_template}</action>
-
-<action>Populate story with:
-
-**Story Header:**
-
-- N.M format (where N is always 1 for quick-flow, M is story number)
-- Title: User-focused deliverable
-- Status: Draft
-
-**User Story:**
-
-- As a [role] (developer, user, admin, system, etc.)
-- I want [capability/change]
-- So that [benefit/value]
-
-**Acceptance Criteria:**
-
-- Numbered list (AC #1, AC #2, ...)
-- Specific, measurable, testable
-- Derived from tech-spec testing strategy and acceptance criteria
-- Cover all success conditions for this story
-
-**Tasks/Subtasks:**
-
-- Checkbox list mapped to tech-spec implementation steps
-- Each task references AC numbers: (AC: #1)
-- Include explicit testing tasks
-
-**Technical Summary:**
-
-- High-level approach for this story
-- Key technical decisions
-- Files/modules involved
-
-**Project Structure Notes:**
-
-- files_to_modify: From tech-spec "Developer Resources → File Paths"
-- test_locations: From tech-spec "Developer Resources → Testing Locations"
-- story_points: Estimated effort
-- dependencies: Prerequisites (other stories, systems, data)
-
-**Key Code References:**
-
-- From tech-spec "Development Context → Relevant Existing Code"
-- From tech-spec "Developer Resources → Key Code Locations"
-- Specific file:line references when available
-
-**Context References:**
-
-- Link to tech-spec.md (primary context document)
-- Note: Tech-spec contains brownfield analysis, framework versions, patterns, etc.
-
-**Dev Agent Record:**
-
-- Empty sections (populated during dev-story execution)
-- Agent Model Used
-- Debug Log References
-- Completion Notes
-- Files Modified
-- Test Results
-
-**Review Notes:**
-
-- Empty section (populated during code review)
-  </action>
-
-<template-output file="{{story_path}}">story_number</template-output>
-<template-output file="{{story_path}}">story_title</template-output>
-<template-output file="{{story_path}}">user_role</template-output>
-<template-output file="{{story_path}}">capability</template-output>
-<template-output file="{{story_path}}">benefit</template-output>
-<template-output file="{{story_path}}">acceptance_criteria</template-output>
-<template-output file="{{story_path}}">tasks_subtasks</template-output>
-<template-output file="{{story_path}}">technical_summary</template-output>
-<template-output file="{{story_path}}">files_to_modify</template-output>
-<template-output file="{{story_path}}">test_locations</template-output>
-<template-output file="{{story_path}}">story_points</template-output>
-<template-output file="{{story_path}}">time_estimate</template-output>
-<template-output file="{{story_path}}">dependencies</template-output>
-<template-output file="{{story_path}}">existing_code_references</template-output>
-</for-each>
-
-</step>
-
-<step n="6" goal="Generate story map and finalize epic" if="story_count > 1">
-
-<action>Create visual story map showing epic → stories hierarchy
-
-Include:
-
-- Epic title at top
-- Stories listed with point estimates
-- Dependencies noted
-- Sequence validation confirmation
-
-Example:
-
-```
-Epic: OAuth Integration (8 points)
-├── Story 1.1: OAuth Backend (3 points)
-│   Dependencies: None
-│
-├── Story 1.2: OAuth UI Components (3 points)
-│   Dependencies: Story 1.1
-│
-└── Story 1.3: OAuth Testing & Polish (2 points)
-    Dependencies: Stories 1.1, 1.2
-```
-
-</action>
-
-<action>Calculate totals:
-
-- Total story points across all stories
-- Estimated timeline (typically 1-2 points per day)
-  </action>
-
-<action>Append to {epics_file}:
-
-- Story summaries
-- Story map visual
-- Implementation sequence
-- Total points and timeline
-  </action>
-
-<template-output file="{epics_file}">story_map</template-output>
-<template-output file="{epics_file}">story_summaries</template-output>
-<template-output file="{epics_file}">total_points</template-output>
-<template-output file="{epics_file}">estimated_timeline</template-output>
-<template-output file="{epics_file}">implementation_sequence</template-output>
-
-</step>
-
-<step n="7" goal="Validate story quality">
-
-<critical>Always run validation - NOT optional!</critical>
-
-<action>Validate all stories against quality standards:
-
-**Story Sequence Validation (CRITICAL):**
-
-- For each story N, verify it doesn't depend on story N+1 or later
-- Check: Can stories be implemented in order 1→2→3→...?
-- If sequence invalid: Identify problem, propose reordering, ask user to confirm
-
-**Acceptance Criteria Quality:**
-
-- All AC are numbered (AC #1, AC #2, ...)
-- Each AC is specific and testable (no "works well", "is good", "performs fast")
-- AC use Given/When/Then or equivalent structure
-- All success conditions are covered
-
-**Story Completeness:**
-
-- All stories map to tech-spec implementation steps
-- Story points align with tech-spec time estimates
-- Dependencies are clearly documented
-- Each story has testable AC
-- Files and locations reference tech-spec developer resources
-
-**Template Compliance:**
-
-- All required sections present
-- Dev Agent Record sections exist (even if empty)
-- Context references link to tech-spec.md
-- Story numbering follows N.M format
-  </action>
-
-<check if="validation issues found">
-  <output>⚠️ **Story Validation Issues:**
-
-{{issues_list}}
-
-**Recommended Fixes:**
-{{fixes}}
-
-Shall I fix these automatically? (yes/no)</output>
-
-<ask>Apply fixes? (yes/no)</ask>
-
-  <check if="yes">
-    <action>Apply fixes (reorder stories, rewrite vague AC, add missing details)</action>
-    <action>Re-validate</action>
-    <output>✅ Validation passed after fixes!</output>
-  </check>
-</check>
-
-<check if="validation passes">
-  <output>✅ **Story Validation Passed!**
-
-**Quality Scores:**
-
-- Sequence: ✅ Valid (no forward dependencies)
-- AC Quality: ✅ All specific and testable
-- Completeness: ✅ All tech spec tasks covered
-- Template Compliance: ✅ All sections present
-
-Stories are implementation-ready!</output>
-</check>
-
-</step>
-
-<step n="8" goal="Update workflow status and finalize">
-
-<action>Update bmm-workflow-status.yaml (if exists):
-
-- Mark tech-spec as complete
-- Initialize story sequence tracking
-- Set first story as TODO
-- Track epic slug and story count
-  </action>
-
-<output>**✅ Epic and Stories Generated!**
-
-**Epic:** {{epic_title}} ({{epic_slug}})
-**Total Stories:** {{story_count}}
-{{#if story_count > 1}}**Total Points:** {{total_points}}
-**Estimated Timeline:** {{estimated_timeline}}{{/if}}
-
-**Files Created:**
-
-- `{epics_file}` - Epic structure{{#if story_count == 1}} (minimal){{/if}}
-- `{sprint_artifacts}/story-{{epic_slug}}-1.md`{{#if story_count > 1}}
-- `{sprint_artifacts}/story-{{epic_slug}}-2.md`{{/if}}{{#if story_count > 2}}
-- Through story-{{epic_slug}}-{{story_count}}.md{{/if}}
-
-**What's Next:**
-All stories reference tech-spec.md as primary context. You can proceed directly to development with the DEV agent!
-
-Story files are ready for:
-
-- Direct implementation (dev-story workflow)
-- Optional context generation (story-context workflow for complex cases)
-- Sprint planning organization (sprint-planning workflow for multi-story coordination)
-  </output>
-
-</step>
-
-</workflow>

src/modules/bmm/workflows/2-plan-workflows/tech-spec/instructions.md

@@ -1,980 +0,0 @@
-# Tech-Spec Workflow - Context-Aware Technical Planning (quick-flow)
-
-<workflow>
-
-<critical>The workflow execution engine is governed by: {project-root}/{bmad_folder}/core/tasks/workflow.xml</critical>
-<critical>You MUST have already loaded and processed: {installed_path}/workflow.yaml</critical>
-<critical>Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}</critical>
-<critical>Generate all documents in {document_output_language}</critical>
-<critical>This is quick-flow efforts - tech-spec with context-rich story generation</critical>
-<critical>Quick Flow: tech-spec + epic with 1-5 stories (always generates epic structure)</critical>
-<critical>LIVING DOCUMENT: Write to tech-spec.md continuously as you discover - never wait until the end</critical>
-<critical>CONTEXT IS KING: Gather ALL available context before generating specs</critical>
-<critical>DOCUMENT OUTPUT: Technical, precise, definitive. Specific versions only. User skill level ({user_skill_level}) affects conversation style ONLY, not document content.</critical>
-<critical>Input documents specified in workflow.yaml input_file_patterns - workflow engine handles fuzzy matching, whole vs sharded document discovery automatically</critical>
-<critical>⚠️ ABSOLUTELY NO TIME ESTIMATES - NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed - what once took teams weeks/months can now be done by one person in hours. DO NOT give ANY time estimates whatsoever.</critical>
-<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
-
-<step n="0" goal="Validate workflow readiness and detect project level" tag="workflow-status">
-<action>Check if {output_folder}/bmm-workflow-status.yaml exists</action>
-
-<check if="status file not found">
-  <output>No workflow status file found. Tech-spec workflow can run standalone or as part of BMM workflow path.</output>
-  <output>**Recommended:** Run `workflow-init` first for project context tracking and workflow sequencing.</output>
-  <output>**Quick Start:** Continue in standalone mode - perfect for rapid prototyping and quick changes!</output>
-  <ask>Continue in standalone mode or exit to run workflow-init? (continue/exit)</ask>
-  <check if="continue">
-    <action>Set standalone_mode = true</action>
-
-    <output>Great! Let's quickly configure your project...</output>
-
-    <ask>How many user stories do you think this work requires?
-
-**Single Story** - Simple change (bug fix, small isolated feature, single file change)
-→ Generates: tech-spec + epic (minimal) + 1 story
-→ Example: "Fix login validation bug" or "Add email field to user form"
-
-**Multiple Stories (2-5)** - Coherent feature (multiple related changes, small feature set)
-→ Generates: tech-spec + epic (detailed) + 2-5 stories
-→ Example: "Add OAuth integration" or "Build user profile page"
-
-Enter **1** for single story, or **2-5** for number of stories you estimate</ask>
-
-    <action>Capture user response as story_count (1-5)</action>
-    <action>Validate: If not 1-5, ask for clarification. If > 5, suggest using full BMad Method instead</action>
-
-    <ask if="not already known greenfield vs brownfield">Is this a **greenfield** (new/empty codebase) or **brownfield** (existing codebase) project?
-
-    **Greenfield** - Starting fresh, no existing code aside from starter templates
-    **Brownfield** - Adding to or modifying existing functional code or project
-
-    Enter **greenfield** or **brownfield**:</ask>
-
-    <action>Capture user response as field_type (greenfield or brownfield)</action>
-    <action>Validate: If not greenfield or brownfield, ask again</action>
-
-    <output>Perfect! Running as:
-
-- **Story Count:** {{story_count}} {{#if story_count == 1}}story (minimal epic){{else}}stories (detailed epic){{/if}}
-- **Field Type:** {{field_type}}
-- **Mode:** Standalone (no status file tracking)
-
-Let's build your tech-spec!</output>
-</check>
-<check if="exit">
-<action>Exit workflow</action>
-</check>
-</check>
-
-<check if="status file found">
-  <action>Load the FULL file: {workflow-status}</action>
-  <action>Parse workflow_status section</action>
-  <action>Check status of "tech-spec" workflow</action>
-  <action>Get selected_track from YAML metadata indicating this is quick-flow-greenfield or quick-flow-brownfield</action>
-  <action>Get field_type from YAML metadata (greenfield or brownfield)</action>
-  <action>Find first non-completed workflow (next expected workflow)</action>
-
-  <check if="selected_track is NOT quick-flow-greenfield AND NOT quick-flow-brownfield">
-    <output>**Incorrect Workflow for Level {{selected_track}}**
-    Tech-spec is for Simple projects. **Correct workflow:** `create-prd` (PM agent). You should Exit at this point, unless you want to force run this workflow.
-</output>
-</check>
-
-  <check if="tech-spec status is file path (already completed)">
-    <output>⚠️ Tech-spec already completed: {{tech-spec status}}</output>
-    <ask>Re-running will overwrite the existing tech-spec. Continue? (y/n)</ask>
-    <check if="n">
-      <output>Exiting. Use workflow-status to see your next step.</output>
-      <action>Exit workflow</action>
-    </check>
-  </check>
-
-  <check if="tech-spec is not the next expected workflow">
-    <output>⚠️ Next expected workflow: {{next_workflow}}. Tech-spec is out of sequence.</output>
-    <ask>Continue with tech-spec anyway? (y/n)</ask>
-    <check if="n">
-      <output>Exiting. Run {{next_workflow}} instead.</output>
-      <action>Exit workflow</action>
-    </check>
-  </check>
-
-<action>Set standalone_mode = false</action>
-</check>
-</step>
-
-<step n="0.5" goal="Discover and load input documents">
-<invoke-protocol name="discover_inputs" />
-<note>After discovery, these content variables are available: {product_brief_content}, {research_content}, {document_project_content}</note>
-</step>
-
-<step n="1" goal="Comprehensive context discovery - gather everything available">
-
-<action>Welcome {user_name} warmly and explain what we're about to do:
-
-"I'm going to gather all available context about your project before we dive into the technical spec. The following content has been auto-loaded:
-
-- Product briefs and research: {product_brief_content}, {research_content}
-- Brownfield codebase documentation: {document_project_content} (loaded via INDEX_GUIDED strategy)
-- Your project's tech stack and dependencies
-- Existing code patterns and structure
-
-This ensures the tech-spec is grounded in reality and gives developers everything they need."
-</action>
-
-<action>**PHASE 1: Load Existing Documents**
-
-Search for and load (using dual-strategy: whole first, then sharded):
-
-1. **Product Brief:**
-   - Search pattern: {output*folder}/\_brief*.md
-   - Sharded: {output*folder}/\_brief*/index.md
-   - If found: Load completely and extract key context
-
-2. **Research Documents:**
-   - Search pattern: {output*folder}/\_research*.md
-   - Sharded: {output*folder}/\_research*/index.md
-   - If found: Load completely and extract insights
-
-3. **Document-Project Output (CRITICAL for brownfield):**
-   - Always check: {output_folder}/index.md
-   - If found: This is the brownfield codebase map - load ALL shards!
-   - Extract: File structure, key modules, existing patterns, naming conventions
-
-Create a summary of what was found and ask user if there are other documents or information to consider before proceeding:
-
-- List of loaded documents
-- Key insights from each
-- Brownfield vs greenfield determination
-  </action>
-
-<action>**PHASE 2: Intelligently Detect Project Stack**
-
-Use your comprehensive knowledge as a coding-capable LLM to analyze the project:
-
-**Discover Setup Files:**
-
-- Search {project-root} for dependency manifests (package.json, requirements.txt, Gemfile, go.mod, Cargo.toml, composer.json, pom.xml, build.gradle, pyproject.toml, etc.)
-- Adapt to ANY project type - you know the ecosystem conventions
-
-**Extract Critical Information:**
-
-1. Framework name and EXACT version (e.g., "React 18.2.0", "Django 4.2.1")
-2. All production dependencies with specific versions
-3. Dev tools and testing frameworks (Jest, pytest, ESLint, etc.)
-4. Available build/test scripts
-5. Project type (web app, API, CLI, library, etc.)
-
-**Assess Currency:**
-
-- Identify if major dependencies are outdated (>2 years old)
-- Use WebSearch to find current recommended versions if needed
-- Note migration complexity in your summary
-
-**For Greenfield Projects:**
-<check if="field_type == greenfield">
-<action>Use WebSearch to discover current best practices and official starter templates</action>
-<action>Recommend appropriate starters based on detected framework (or user's intended stack)</action>
-<action>Present benefits conversationally: setup time saved, modern patterns, testing included</action>
-<ask>Would you like to use a starter template? (yes/no/show-me-options)</ask>
-<action>Capture preference and include in implementation stack if accepted</action>
-</check>
-
-**Trust Your Intelligence:**
-You understand project ecosystems deeply. Adapt your analysis to any stack - don't be constrained by examples. Extract what matters for developers.
-
-Store comprehensive findings as {{project_stack_summary}}
-</action>
-
-<action>**PHASE 3: Brownfield Codebase Reconnaissance** (if applicable)
-
-<check if="field_type == brownfield OR document-project output found">
-
-Analyze the existing project structure:
-
-1. **Directory Structure:**
-   - Identify main code directories (src/, lib/, app/, components/, services/)
-   - Note organization patterns (feature-based, layer-based, domain-driven)
-   - Identify test directories and patterns
-
-2. **Code Patterns:**
-   - Look for dominant patterns (class-based, functional, MVC, microservices)
-   - Identify naming conventions (camelCase, snake_case, PascalCase)
-   - Note file organization patterns
-
-3. **Key Modules/Services:**
-   - Identify major modules or services already in place
-   - Note entry points (main.js, app.py, index.ts)
-   - Document important utilities or shared code
-
-4. **Testing Patterns & Standards (CRITICAL):**
-   - Identify test framework in use (from package.json/requirements.txt)
-   - Note test file naming patterns (.test.js, test.py, .spec.ts, Test.java)
-   - Document test organization (tests/, **tests**, spec/, test/)
-   - Look for test configuration files (jest.config.js, pytest.ini, .rspec)
-   - Check for coverage requirements (in CI config, test scripts)
-   - Identify mocking/stubbing libraries (jest.mock, unittest.mock, sinon)
-   - Note assertion styles (expect, assert, should)
-
-5. **Code Style & Conventions (MUST CONFORM):**
-   - Check for linter config (.eslintrc, .pylintrc, rubocop.yml)
-   - Check for formatter config (.prettierrc, .black, .editorconfig)
-   - Identify code style:
-     - Semicolons: yes/no (JavaScript/TypeScript)
-     - Quotes: single/double
-     - Indentation: spaces/tabs, size
-     - Line length limits
-   - Import/export patterns (named vs default, organization)
-   - Error handling patterns (try/catch, Result types, error classes)
-   - Logging patterns (console, winston, logging module, specific formats)
-   - Documentation style (JSDoc, docstrings, YARD, JavaDoc)
-
-Store this as {{existing_structure_summary}}
-
-**CRITICAL: Confirm Conventions with User**
-<ask>I've detected these conventions in your codebase:
-
-**Code Style:**
-{{detected_code_style}}
-
-**Test Patterns:**
-{{detected_test_patterns}}
-
-**File Organization:**
-{{detected_file_organization}}
-
-Should I follow these existing conventions for the new code?
-
-Enter **yes** to conform to existing patterns, or **no** if you want to establish new standards:</ask>
-
-<action>Capture user response as conform_to_conventions (yes/no)</action>
-
-<check if="conform_to_conventions == no">
-  <ask>What conventions would you like to use instead? (Or should I suggest modern best practices?)</ask>
-  <action>Capture new conventions or use WebSearch for current best practices</action>
-</check>
-
-<action>Store confirmed conventions as {{existing_conventions}}</action>
-
-</check>
-
-<check if="field_type == greenfield">
-  <action>Note: Greenfield project - no existing code to analyze</action>
-  <action>Set {{existing_structure_summary}} = "Greenfield project - new codebase"</action>
-</check>
-
-</action>
-
-<action>**PHASE 4: Synthesize Context Summary**
-
-Create {{loaded_documents_summary}} that includes:
-
-- Documents found and loaded
-- Brownfield vs greenfield status
-- Tech stack detected (or "To be determined" if greenfield)
-- Existing patterns identified (or "None - greenfield" if applicable)
-
-Present this summary to {user_name} conversationally:
-
-"Here's what I found about your project:
-
-**Documents Available:**
-[List what was found]
-
-**Project Type:**
-[Brownfield with X framework Y version OR Greenfield - new project]
-
-**Existing Stack:**
-[Framework and dependencies OR "To be determined"]
-
-**Code Structure:**
-[Existing patterns OR "New codebase"]
-
-This gives me a solid foundation for creating a context-rich tech spec!"
-</action>
-
-<template-output>loaded_documents_summary</template-output>
-<template-output>project_stack_summary</template-output>
-<template-output>existing_structure_summary</template-output>
-
-</step>
-
-<step n="2" goal="Conversational discovery of the change/feature">
-
-<action>Engage {user_name} in natural, adaptive conversation to deeply understand what needs to be built.
-
-**Discovery Approach:**
-Adapt your questioning style to the complexity:
-
-- For single-story changes: Focus on the specific problem, location, and approach
-- For multi-story features: Explore user value, integration strategy, and scope boundaries
-
-**Core Discovery Goals (accomplish through natural dialogue):**
-
-1. **The Problem/Need**
-   - What user or technical problem are we solving?
-   - Why does this matter now?
-   - What's the impact if we don't do this?
-
-2. **The Solution Approach**
-   - What's the proposed solution?
-   - How should this work from a user/system perspective?
-   - What alternatives were considered?
-
-3. **Integration & Location**
-   - <check if="brownfield">Where does this fit in the existing codebase?</check>
-   - What existing code/patterns should we reference or follow?
-   - What are the integration points?
-
-4. **Scope Clarity**
-   - What's IN scope for this work?
-   - What's explicitly OUT of scope (future work, not needed)?
-   - If multiple stories: What's MVP vs enhancement?
-
-5. **Constraints & Dependencies**
-   - Technical limitations or requirements?
-   - Dependencies on other systems, APIs, or services?
-   - Performance, security, or compliance considerations?
-
-6. **Success Criteria**
-   - How will we know this is done correctly?
-   - What does "working" look like?
-   - What edge cases matter?
-
-**Conversation Style:**
-
-- Be warm and collaborative, not interrogative
-- Ask follow-up questions based on their responses
-- Help them think through implications
-- Reference context from Phase 1 (existing code, stack, patterns)
-- Adapt depth to {{story_count}} complexity
-
-Synthesize discoveries into clear, comprehensive specifications.
-</action>
-
-<template-output>problem_statement</template-output>
-<template-output>solution_overview</template-output>
-<template-output>change_type</template-output>
-<template-output>scope_in</template-output>
-<template-output>scope_out</template-output>
-
-</step>
-
-<step n="3" goal="Generate context-aware, definitive technical specification">
-
-<critical>ALL TECHNICAL DECISIONS MUST BE DEFINITIVE - NO AMBIGUITY ALLOWED</critical>
-<critical>Use existing stack info to make SPECIFIC decisions</critical>
-<critical>Reference brownfield code to guide implementation</critical>
-
-<action>Initialize tech-spec.md with the rich template</action>
-
-<action>**Generate Context Section (already captured):**
-
-These template variables are already populated from Step 1:
-
-- {{loaded_documents_summary}}
-- {{project_stack_summary}}
-- {{existing_structure_summary}}
-
-Just save them to the file.
-</action>
-
-<template-output file="tech-spec.md">loaded_documents_summary</template-output>
-<template-output file="tech-spec.md">project_stack_summary</template-output>
-<template-output file="tech-spec.md">existing_structure_summary</template-output>
-
-<action>**Generate The Change Section:**
-
-Already captured from Step 2:
-
-- {{problem_statement}}
-- {{solution_overview}}
-- {{scope_in}}
-- {{scope_out}}
-
-Save to file.
-</action>
-
-<template-output file="tech-spec.md">problem_statement</template-output>
-<template-output file="tech-spec.md">solution_overview</template-output>
-<template-output file="tech-spec.md">scope_in</template-output>
-<template-output file="tech-spec.md">scope_out</template-output>
-
-<action>**Generate Implementation Details:**
-
-Now make DEFINITIVE technical decisions using all the context gathered.
-
-**Source Tree Changes - BE SPECIFIC:**
-
-Bad (NEVER do this):
-
-- "Update some files in the services folder"
-- "Add tests somewhere"
-
-Good (ALWAYS do this):
-
-- "src/services/UserService.ts - MODIFY - Add validateEmail() method at line 45"
-- "src/routes/api/users.ts - MODIFY - Add POST /users/validate endpoint"
-- "tests/services/UserService.test.ts - CREATE - Test suite for email validation"
-
-Include:
-
-- Exact file paths
-- Action: CREATE, MODIFY, DELETE
-- Specific what changes (methods, classes, endpoints, components)
-
-**Use brownfield context:**
-
-- If modifying existing files, reference current structure
-- Follow existing naming patterns
-- Place new code logically based on current organization
-  </action>
-
-<template-output file="tech-spec.md">source_tree_changes</template-output>
-
-<action>**Technical Approach - BE DEFINITIVE:**
-
-Bad (ambiguous):
-
-- "Use a logging library like winston or pino"
-- "Use Python 2 or 3"
-- "Set up some kind of validation"
-
-Good (definitive):
-
-- "Use winston v3.8.2 (already in package.json) for logging"
-- "Implement using Python 3.11 as specified in pyproject.toml"
-- "Use Joi v17.9.0 for request validation following pattern in UserController.ts"
-
-**Use detected stack:**
-
-- Reference exact versions from package.json/requirements.txt
-- Specify frameworks already in use
-- Make decisions based on what's already there
-
-**For greenfield:**
-
-- Make definitive choices and justify them
-- Specify exact versions
-- No "or" statements allowed
-  </action>
-
-<template-output file="tech-spec.md">technical_approach</template-output>
-
-<action>**Existing Patterns to Follow:**
-
-<check if="brownfield">
-Document patterns from the existing codebase:
-- Class structure patterns
-- Function naming conventions
-- Error handling approach
-- Testing patterns
-- Documentation style
-
-Example:
-"Follow the service pattern established in UserService.ts:
-
-- Export class with constructor injection
-- Use async/await for all asynchronous operations
-- Throw ServiceError with error codes
-- Include JSDoc comments for all public methods"
-  </check>
-
-<check if="greenfield">
-"Greenfield project - establishing new patterns:
-- [Define the patterns to establish]"
-</check>
-
-</action>
-
-<template-output file="tech-spec.md">existing_patterns</template-output>
-
-<action>**Integration Points:**
-
-Identify how this change connects:
-
-- Internal modules it depends on
-- External APIs or services
-- Database interactions
-- Event emitters/listeners
-- State management
-
-Be specific about interfaces and contracts.
-</action>
-
-<template-output file="tech-spec.md">integration_points</template-output>
-
-<action>**Development Context:**
-
-**Relevant Existing Code:**
-<check if="brownfield">
-Reference specific files or code sections developers should review:
-
-- "See UserService.ts lines 120-150 for similar validation pattern"
-- "Reference AuthMiddleware.ts for authentication approach"
-- "Follow error handling in PaymentService.ts"
-  </check>
-
-**Framework/Libraries:**
-List with EXACT versions from detected stack:
-
-- Express 4.18.2 (web framework)
-- winston 3.8.2 (logging)
-- Joi 17.9.0 (validation)
-- TypeScript 5.1.6 (language)
-
-**Internal Modules:**
-List internal dependencies:
-
-- @/services/UserService
-- @/middleware/auth
-- @/utils/validation
-
-**Configuration Changes:**
-Any config files to update:
-
-- Update .env with new SMTP settings
-- Add validation schema to config/schemas.ts
-- Update package.json scripts if needed
-  </action>
-
-<template-output file="tech-spec.md">existing_code_references</template-output>
-<template-output file="tech-spec.md">framework_dependencies</template-output>
-<template-output file="tech-spec.md">internal_dependencies</template-output>
-<template-output file="tech-spec.md">configuration_changes</template-output>
-
-<check if="field_type == brownfield">
-  <template-output file="tech-spec.md">existing_conventions</template-output>
-</check>
-
-<check if="field_type == greenfield">
-  <action>Set {{existing_conventions}} = "Greenfield project - establishing new conventions per modern best practices"</action>
-  <template-output file="tech-spec.md">existing_conventions</template-output>
-</check>
-
-<action>**Implementation Stack:**
-
-Comprehensive stack with versions:
-
-- Runtime: Node.js 20.x
-- Framework: Express 4.18.2
-- Language: TypeScript 5.1.6
-- Testing: Jest 29.5.0
-- Linting: ESLint 8.42.0
-- Validation: Joi 17.9.0
-
-All from detected project setup!
-</action>
-
-<template-output file="tech-spec.md">implementation_stack</template-output>
-
-<action>**Technical Details:**
-
-Deep technical specifics:
-
-- Algorithms to implement
-- Data structures to use
-- Performance considerations
-- Security considerations
-- Error scenarios and handling
-- Edge cases
-
-Be thorough - developers need details!
-</action>
-
-<template-output file="tech-spec.md">technical_details</template-output>
-
-<action>**Development Setup:**
-
-What does a developer need to run this locally?
-
-Based on detected stack and scripts:
-
-```
-1. Clone repo (if not already)
-2. npm install (installs all deps from package.json)
-3. cp .env.example .env (configure environment)
-4. npm run dev (starts development server)
-5. npm test (runs test suite)
-```
-
-Or for Python:
-
-```
-1. python -m venv venv
-2. source venv/bin/activate
-3. pip install -r requirements.txt
-4. python manage.py runserver
-```
-
-Use the actual scripts from package.json/setup files!
-</action>
-
-<template-output file="tech-spec.md">development_setup</template-output>
-
-<action>**Implementation Guide:**
-
-**Setup Steps:**
-Pre-implementation checklist:
-
-- Create feature branch
-- Verify dev environment running
-- Review existing code references
-- Set up test data if needed
-
-**Implementation Steps:**
-Step-by-step breakdown:
-
-For single-story changes:
-
-1. [Step 1 with specific file and action]
-2. [Step 2 with specific file and action]
-3. [Write tests]
-4. [Verify acceptance criteria]
-
-For multi-story features:
-Organize by story/phase:
-
-1. Phase 1: [Foundation work]
-2. Phase 2: [Core implementation]
-3. Phase 3: [Testing and validation]
-
-**Testing Strategy:**
-
-- Unit tests for [specific functions]
-- Integration tests for [specific flows]
-- Manual testing checklist
-- Performance testing if applicable
-
-**Acceptance Criteria:**
-Specific, measurable, testable criteria:
-
-1. Given [scenario], when [action], then [outcome]
-2. [Metric] meets [threshold]
-3. [Feature] works in [environment]
-   </action>
-
-<template-output file="tech-spec.md">setup_steps</template-output>
-<template-output file="tech-spec.md">implementation_steps</template-output>
-<template-output file="tech-spec.md">testing_strategy</template-output>
-<template-output file="tech-spec.md">acceptance_criteria</template-output>
-
-<action>**Developer Resources:**
-
-**File Paths Reference:**
-Complete list of all files involved:
-
-- /src/services/UserService.ts
-- /src/routes/api/users.ts
-- /tests/services/UserService.test.ts
-- /src/types/user.ts
-
-**Key Code Locations:**
-Important functions, classes, modules:
-
-- UserService class (src/services/UserService.ts:15)
-- validateUser function (src/utils/validation.ts:42)
-- User type definition (src/types/user.ts:8)
-
-**Testing Locations:**
-Where tests go:
-
-- Unit: tests/services/
-- Integration: tests/integration/
-- E2E: tests/e2e/
-
-**Documentation to Update:**
-Docs that need updating:
-
-- README.md - Add new endpoint documentation
-- API.md - Document /users/validate endpoint
-- CHANGELOG.md - Note the new feature
-  </action>
-
-<template-output file="tech-spec.md">file_paths_complete</template-output>
-<template-output file="tech-spec.md">key_code_locations</template-output>
-<template-output file="tech-spec.md">testing_locations</template-output>
-<template-output file="tech-spec.md">documentation_updates</template-output>
-
-<action>**UX/UI Considerations:**
-
-<check if="change affects user interface OR user experience">
-  **Determine if this change has UI/UX impact:**
-  - Does it change what users see?
-  - Does it change how users interact?
-  - Does it affect user workflows?
-
-If YES, document:
-
-**UI Components Affected:**
-
-- List specific components (buttons, forms, modals, pages)
-- Note which need creation vs modification
-
-**UX Flow Changes:**
-
-- Current flow vs new flow
-- User journey impact
-- Navigation changes
-
-**Visual/Interaction Patterns:**
-
-- Follow existing design system? (check for design tokens, component library)
-- New patterns needed?
-- Responsive design considerations (mobile, tablet, desktop)
-
-**Accessibility:**
-
-- Keyboard navigation requirements
-- Screen reader compatibility
-- ARIA labels needed
-- Color contrast standards
-
-**User Feedback:**
-
-- Loading states
-- Error messages
-- Success confirmations
-- Progress indicators
-  </check>
-
-<check if="no UI/UX impact">
-  "No UI/UX impact - backend/API/infrastructure change only"
-</check>
-</action>
-
-<template-output file="tech-spec.md">ux_ui_considerations</template-output>
-
-<action>**Testing Approach:**
-
-Comprehensive testing strategy using {{test_framework_info}}:
-
-**CONFORM TO EXISTING TEST STANDARDS:**
-<check if="conform_to_conventions == yes">
-
-- Follow existing test file naming: {{detected_test_patterns.file_naming}}
-- Use existing test organization: {{detected_test_patterns.organization}}
-- Match existing assertion style: {{detected_test_patterns.assertion_style}}
-- Meet existing coverage requirements: {{detected_test_patterns.coverage}}
-  </check>
-
-**Test Strategy:**
-
-- Test framework: {{detected_test_framework}} (from project dependencies)
-- Unit tests for [specific functions/methods]
-- Integration tests for [specific flows/APIs]
-- E2E tests if UI changes
-- Mock/stub strategies (use existing patterns: {{detected_test_patterns.mocking}})
-- Performance benchmarks if applicable
-- Accessibility tests if UI changes
-
-**Coverage:**
-
-- Unit test coverage: [target %]
-- Integration coverage: [critical paths]
-- Ensure all acceptance criteria have corresponding tests
-  </action>
-
-<template-output file="tech-spec.md">test_framework_info</template-output>
-<template-output file="tech-spec.md">testing_approach</template-output>
-
-<action>**Deployment Strategy:**
-
-**Deployment Steps:**
-How to deploy this change:
-
-1. Merge to main branch
-2. Run CI/CD pipeline
-3. Deploy to staging
-4. Verify in staging
-5. Deploy to production
-6. Monitor for issues
-
-**Rollback Plan:**
-How to undo if problems:
-
-1. Revert commit [hash]
-2. Redeploy previous version
-3. Verify rollback successful
-
-**Monitoring:**
-What to watch after deployment:
-
-- Error rates in [logging service]
-- Response times for [endpoint]
-- User feedback on [feature]
-  </action>
-
-<template-output file="tech-spec.md">deployment_steps</template-output>
-<template-output file="tech-spec.md">rollback_plan</template-output>
-<template-output file="tech-spec.md">monitoring_approach</template-output>
-
-</step>
-
-<step n="4" goal="Auto-validate cohesion, completeness, and quality">
-
-<critical>Always run validation - this is NOT optional!</critical>
-
-<action>Tech-spec generation complete! Now running automatic validation...</action>
-
-<action>Load {installed_path}/checklist.md</action>
-<action>Review tech-spec.md against ALL checklist criteria:
-
-**Section 1: Output Files Exist**
-
-- Verify tech-spec.md created
-- Check for unfilled template variables
-
-**Section 2: Context Gathering**
-
-- Validate all available documents were loaded
-- Confirm stack detection worked
-- Verify brownfield analysis (if applicable)
-
-**Section 3: Tech-Spec Definitiveness**
-
-- Scan for "or" statements (FAIL if found)
-- Verify all versions are specific
-- Check stack alignment
-
-**Section 4: Context-Rich Content**
-
-- Verify all new template sections populated
-- Check existing code references (brownfield)
-- Validate framework dependencies listed
-
-**Section 5-6: Story Quality (deferred to Step 5)**
-
-**Section 7: Workflow Status (if applicable)**
-
-**Section 8: Implementation Readiness**
-
-- Can developer start immediately?
-- Is tech-spec comprehensive enough?
-  </action>
-
-<action>Generate validation report with specific scores:
-
-- Context Gathering: [Comprehensive/Partial/Insufficient]
-- Definitiveness: [All definitive/Some ambiguity/Major issues]
-- Brownfield Integration: [N/A/Excellent/Partial/Missing]
-- Stack Alignment: [Perfect/Good/Partial/None]
-- Implementation Readiness: [Yes/No]
-  </action>
-
-<check if="validation issues found">
-  <output>⚠️ **Validation Issues Detected:**
-
-{{list_of_issues}}
-
-I can fix these automatically. Shall I proceed? (yes/no)</output>
-
-<ask>Fix validation issues? (yes/no)</ask>
-
-  <check if="yes">
-    <action>Fix each issue and re-validate</action>
-    <output>✅ Issues fixed! Re-validation passed.</output>
-  </check>
-
-  <check if="no">
-    <output>⚠️ Proceeding with warnings. Issues should be addressed manually.</output>
-  </check>
-</check>
-
-<check if="validation passes">
-  <output>✅ **Validation Passed!**
-
-**Scores:**
-
-- Context Gathering: {{context_score}}
-- Definitiveness: {{definitiveness_score}}
-- Brownfield Integration: {{brownfield_score}}
-- Stack Alignment: {{stack_score}}
-- Implementation Readiness: ✅ Ready
-
-Tech-spec is high quality and ready for story generation!</output>
-</check>
-
-</step>
-
-<step n="5" goal="Generate epic and context-rich stories">
-
-<action>Invoke unified story generation workflow: {instructions_generate_stories}</action>
-
-<action>This will generate:
-
-- **epics.md** - Epic structure (minimal for 1 story, detailed for multiple)
-- **story-{epic-slug}-N.md** - Story files (where N = 1 to {{story_count}})
-
-All stories reference tech-spec.md as primary context - comprehensive enough that developers can often skip story-context workflow.
-</action>
-
-</step>
-
-<step n="6" goal="Finalize and guide next steps">
-
-<output>**✅ Tech-Spec Complete, {user_name}!**
-
-**Deliverables Created:**
-
-- ✅ **tech-spec.md** - Context-rich technical specification
-  - Includes: brownfield analysis, framework details, existing patterns
-- ✅ **epics.md** - Epic structure{{#if story_count == 1}} (minimal for single story){{else}} with {{story_count}} stories{{/if}}
-- ✅ **story-{epic-slug}-1.md** - First story{{#if story_count > 1}}
-- ✅ **story-{epic-slug}-2.md** - Second story{{/if}}{{#if story_count > 2}}
-- ✅ **story-{epic-slug}-3.md** - Third story{{/if}}{{#if story_count > 3}}
-- ✅ **Additional stories** through story-{epic-slug}-{{story_count}}.md{{/if}}
-
-**What Makes This Tech-Spec Special:**
-
-The tech-spec is comprehensive enough to serve as the primary context document:
-
-- ✨ Brownfield codebase analysis (if applicable)
-- ✨ Exact framework and library versions from your project
-- ✨ Existing patterns and code references
-- ✨ Specific file paths and integration points
-- ✨ Complete developer resources
-
-**Next Steps:**
-
-**🎯 Recommended Path - Direct to Development:**
-
-Since the tech-spec is CONTEXT-RICH, you can often skip story-context generation!
-
-{{#if story_count == 1}}
-**For Your Single Story:**
-
-1. Ask DEV agent to run `dev-story`
-   - Select story-{epic-slug}-1.md
-   - Tech-spec provides all the context needed!
-
-💡 **Optional:** Only run `story-context` (SM agent) if this is unusually complex
-{{else}}
-**For Your {{story_count}} Stories - Iterative Approach:**
-
-1. **Start with Story 1:**
-   - Ask DEV agent to run `dev-story`
-   - Select story-{epic-slug}-1.md
-   - Tech-spec provides context
-
-2. **After Story 1 Complete:**
-   - Repeat for story-{epic-slug}-2.md
-   - Continue through story {{story_count}}
-
-💡 **Alternative:** Use `sprint-planning` (SM agent) to organize all stories as a coordinated sprint
-
-💡 **Optional:** Run `story-context` (SM agent) for complex stories needing additional context
-{{/if}}
-
-**Your Tech-Spec:**
-
-- 📄 Saved to: `{output_folder}/tech-spec.md`
-- Epic & Stories: `{output_folder}/epics.md` + `{sprint_artifacts}/`
-- Contains: All context, decisions, patterns, and implementation guidance
-- Ready for: Direct development!
-
-The tech-spec is your single source of truth! 🚀
-</output>
-
-</step>
-
-</workflow>

src/modules/bmm/workflows/2-plan-workflows/tech-spec/tech-spec-template.md

@@ -1,181 +0,0 @@
-# {{project_name}} - Technical Specification
-
-**Author:** {{user_name}}
-**Date:** {{date}}
-**Project Level:** {{project_level}}
-**Change Type:** {{change_type}}
-**Development Context:** {{development_context}}
-
----
-
-## Context
-
-### Available Documents
-
-{{loaded_documents_summary}}
-
-### Project Stack
-
-{{project_stack_summary}}
-
-### Existing Codebase Structure
-
-{{existing_structure_summary}}
-
----
-
-## The Change
-
-### Problem Statement
-
-{{problem_statement}}
-
-### Proposed Solution
-
-{{solution_overview}}
-
-### Scope
-
-**In Scope:**
-
-{{scope_in}}
-
-**Out of Scope:**
-
-{{scope_out}}
-
----
-
-## Implementation Details
-
-### Source Tree Changes
-
-{{source_tree_changes}}
-
-### Technical Approach
-
-{{technical_approach}}
-
-### Existing Patterns to Follow
-
-{{existing_patterns}}
-
-### Integration Points
-
-{{integration_points}}
-
----
-
-## Development Context
-
-### Relevant Existing Code
-
-{{existing_code_references}}
-
-### Dependencies
-
-**Framework/Libraries:**
-
-{{framework_dependencies}}
-
-**Internal Modules:**
-
-{{internal_dependencies}}
-
-### Configuration Changes
-
-{{configuration_changes}}
-
-### Existing Conventions (Brownfield)
-
-{{existing_conventions}}
-
-### Test Framework & Standards
-
-{{test_framework_info}}
-
----
-
-## Implementation Stack
-
-{{implementation_stack}}
-
----
-
-## Technical Details
-
-{{technical_details}}
-
----
-
-## Development Setup
-
-{{development_setup}}
-
----
-
-## Implementation Guide
-
-### Setup Steps
-
-{{setup_steps}}
-
-### Implementation Steps
-
-{{implementation_steps}}
-
-### Testing Strategy
-
-{{testing_strategy}}
-
-### Acceptance Criteria
-
-{{acceptance_criteria}}
-
----
-
-## Developer Resources
-
-### File Paths Reference
-
-{{file_paths_complete}}
-
-### Key Code Locations
-
-{{key_code_locations}}
-
-### Testing Locations
-
-{{testing_locations}}
-
-### Documentation to Update
-
-{{documentation_updates}}
-
----
-
-## UX/UI Considerations
-
-{{ux_ui_considerations}}
-
----
-
-## Testing Approach
-
-{{testing_approach}}
-
----
-
-## Deployment Strategy
-
-### Deployment Steps
-
-{{deployment_steps}}
-
-### Rollback Plan
-
-{{rollback_plan}}
-
-### Monitoring
-
-{{monitoring_approach}}

src/modules/bmm/workflows/2-plan-workflows/tech-spec/user-story-template.md

@@ -1,90 +0,0 @@
-# Story {{N}}.{{M}}: {{story_title}}
-
-**Status:** Draft
-
----
-
-## User Story
-
-As a {{user_type}},
-I want {{capability}},
-So that {{value_benefit}}.
-
----
-
-## Acceptance Criteria
-
-**Given** {{precondition}}
-**When** {{action}}
-**Then** {{expected_outcome}}
-
-**And** {{additional_criteria}}
-
----
-
-## Implementation Details
-
-### Tasks / Subtasks
-
-{{tasks_subtasks}}
-
-### Technical Summary
-
-{{technical_summary}}
-
-### Project Structure Notes
-
-- **Files to modify:** {{files_to_modify}}
-- **Expected test locations:** {{test_locations}}
-- **Estimated effort:** {{story_points}} story points ({{time_estimate}})
-- **Prerequisites:** {{dependencies}}
-
-### Key Code References
-
-{{existing_code_references}}
-
----
-
-## Context References
-
-**Tech-Spec:** [tech-spec.md](../tech-spec.md) - Primary context document containing:
-
-- Brownfield codebase analysis (if applicable)
-- Framework and library details with versions
-- Existing patterns to follow
-- Integration points and dependencies
-- Complete implementation guidance
-
-**Architecture:** {{architecture_references}}
-
-<!-- Additional context XML paths will be added here if story-context workflow is run -->
-
----
-
-## Dev Agent Record
-
-### Agent Model Used
-
-<!-- Will be populated during dev-story execution -->
-
-### Debug Log References
-
-<!-- Will be populated during dev-story execution -->
-
-### Completion Notes
-
-<!-- Will be populated during dev-story execution -->
-
-### Files Modified
-
-<!-- Will be populated during dev-story execution -->
-
-### Test Results
-
-<!-- Will be populated during dev-story execution -->
-
----
-
-## Review Notes
-
-<!-- Will be populated during code review -->

src/modules/bmm/workflows/2-plan-workflows/tech-spec/workflow.yaml

@@ -1,60 +0,0 @@
-# Technical Specification
-name: tech-spec
-description: "Technical specification workflow for quick-flow projects. Creates focused tech spec and generates epic + stories (1 story for simple changes, 2-5 stories for features). Tech-spec only - no PRD needed."
-author: "BMad"
-
-# Critical variables from config
-config_source: "{project-root}/{bmad_folder}/bmm/config.yaml"
-project_name: "{config_source}:project_name"
-output_folder: "{config_source}:output_folder"
-user_name: "{config_source}:user_name"
-communication_language: "{config_source}:communication_language"
-document_output_language: "{config_source}:document_output_language"
-user_skill_level: "{config_source}:user_skill_level"
-date: system-generated
-
-workflow-status: "{output_folder}/bmm-workflow-status.yaml"
-
-# Runtime variables (captured during workflow execution)
-story_count: runtime-captured
-epic_slug: runtime-captured
-change_type: runtime-captured
-field_type: runtime-captured
-
-# Workflow components
-installed_path: "{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/tech-spec"
-instructions: "{installed_path}/instructions.md"
-template: "{installed_path}/tech-spec-template.md"
-
-# Story generation (unified approach - always generates epic + stories)
-instructions_generate_stories: "{installed_path}/instructions-generate-stories.md"
-user_story_template: "{installed_path}/user-story-template.md"
-epics_template: "{installed_path}/epics-template.md"
-
-# Output configuration
-default_output_file: "{output_folder}/tech-spec.md"
-epics_file: "{output_folder}/epics.md"
-sprint_artifacts: "{output_folder}/sprint_artifacts"
-
-# Smart input file references - handles both whole docs and sharded docs
-# Priority: Whole document first, then sharded version
-# Strategy: How to load sharded documents (FULL_LOAD, SELECTIVE_LOAD, INDEX_GUIDED)
-input_file_patterns:
-  product_brief:
-    description: "Product vision and goals (optional)"
-    whole: "{output_folder}/*brief*.md"
-    sharded: "{output_folder}/*brief*/index.md"
-    load_strategy: "FULL_LOAD"
-  research:
-    description: "Market or domain research (optional)"
-    whole: "{output_folder}/*research*.md"
-    sharded: "{output_folder}/*research*/index.md"
-    load_strategy: "FULL_LOAD"
-  document_project:
-    description: "Brownfield project documentation (optional)"
-    sharded: "{output_folder}/index.md"
-    load_strategy: "INDEX_GUIDED"
-
-standalone: true
-
-web_bundle: false

src/modules/bmm/workflows/bmad-quick-flow/create-tech-spec/instructions.md

@@ -0,0 +1,115 @@
+# Create Tech-Spec - Spec Engineering for AI Development
+
+<workflow>
+
+<critical>Communicate in {communication_language}, tailored to {user_skill_level}</critical>
+<critical>Generate documents in {document_output_language}</critical>
+<critical>Conversational spec engineering - ask questions, investigate code, produce complete spec</critical>
+<critical>Spec must contain ALL context a fresh dev agent needs to implement it</critical>
+
+<checkpoint-handlers>
+  <on-select key="a">Load and execute {advanced_elicitation}, then return to current step</on-select>
+  <on-select key="p">Load and execute {party_mode_workflow}, then return to current step</on-select>
+  <on-select key="b">Load and execute {quick_dev_workflow} with the tech-spec file</on-select>
+</checkpoint-handlers>
+
+<step n="1" goal="Understand what the user wants to build">
+
+<action>Greet {user_name} and ask them to describe what they want to build or change.</action>
+
+<action>Ask clarifying questions: problem, who's affected, scope, constraints, existing code?</action>
+
+<action>Check for existing context in {output_folder} and {sprint_artifacts}</action>
+
+<checkpoint title="Problem Understanding">
+[a] Advanced Elicitation  [c] Continue  [p] Party Mode
+</checkpoint>
+
+</step>
+
+<step n="2" goal="Investigate existing code (if applicable)">
+
+<action>If brownfield: get file paths, read code, identify patterns/conventions/dependencies</action>
+
+<action>Document: tech stack, code patterns, files to modify, test patterns</action>
+
+<checkpoint title="Context Gathered">
+[a] Advanced Elicitation  [c] Continue  [p] Party Mode
+</checkpoint>
+
+</step>
+
+<step n="3" goal="Generate the technical specification">
+
+<action>Create tech-spec using this structure:
+
+```markdown
+# Tech-Spec: {title}
+
+**Created:** {date}
+**Status:** Ready for Development
+
+## Overview
+
+### Problem Statement
+
+### Solution
+
+### Scope (In/Out)
+
+## Context for Development
+
+### Codebase Patterns
+
+### Files to Reference
+
+### Technical Decisions
+
+## Implementation Plan
+
+### Tasks
+
+- [ ] Task 1: Description
+- [ ] Task 2: Description
+
+### Acceptance Criteria
+
+- [ ] AC 1: Given/When/Then
+- [ ] AC 2: ...
+
+## Additional Context
+
+### Dependencies
+
+### Testing Strategy
+
+### Notes
+```
+
+</action>
+
+<action>Save to {sprint_artifacts}/tech-spec-{slug}.md</action>
+
+</step>
+
+<step n="4" goal="Review and finalize">
+
+<action>Present spec to {user_name}, ask if it captures intent, make changes as needed</action>
+
+<output>**Tech-Spec Complete!**
+
+Saved to: {sprint_artifacts}/tech-spec-{slug}.md
+
+[a] Advanced Elicitation - refine further
+[b] Begin Development (not recommended - fresh context better)
+[d] Done - exit
+[p] Party Mode - get feedback
+
+**Recommended:** Run `dev-spec {sprint_artifacts}/tech-spec-{slug}.md` in fresh context.
+</output>
+
+<ask>Choice (a/b/d/p):</ask>
+
+</step>
+
+</workflow>

src/modules/bmm/workflows/bmad-quick-flow/create-tech-spec/workflow.yaml

@@ -0,0 +1,26 @@
+# Quick-Flow: Create Tech-Spec
+name: create-tech-spec
+description: "Conversational spec engineering - ask questions, investigate code, produce implementation-ready tech-spec."
+author: "BMad"
+
+# Config
+config_source: "{project-root}/{bmad_folder}/bmm/config.yaml"
+output_folder: "{config_source}:output_folder"
+sprint_artifacts: "{config_source}:sprint_artifacts"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+document_output_language: "{config_source}:document_output_language"
+user_skill_level: "{config_source}:user_skill_level"
+date: system-generated
+
+# Workflow components
+installed_path: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/create-tech-spec"
+instructions: "{installed_path}/instructions.md"
+
+# Related workflows
+quick_dev_workflow: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/quick-dev/workflow.yaml"
+party_mode_workflow: "{project-root}/{bmad_folder}/core/workflows/party-mode/workflow.yaml"
+advanced_elicitation: "{project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml"
+
+standalone: true
+web_bundle: false

src/modules/bmm/workflows/bmad-quick-flow/quick-dev/checklist.md

@@ -0,0 +1,25 @@
+# Quick-Dev Checklist
+
+## Before Implementation
+
+- [ ] Context loaded (tech-spec or user guidance)
+- [ ] Files to modify identified
+- [ ] Patterns understood
+
+## Implementation
+
+- [ ] All tasks completed
+- [ ] Code follows existing patterns
+- [ ] Error handling appropriate
+
+## Testing
+
+- [ ] Tests written (where appropriate)
+- [ ] All tests passing
+- [ ] No regressions
+
+## Completion
+
+- [ ] Acceptance criteria satisfied
+- [ ] Tech-spec updated (if applicable)
+- [ ] Summary provided to user

src/modules/bmm/workflows/bmad-quick-flow/quick-dev/instructions.md

@@ -0,0 +1,96 @@
+# Quick-Dev - Flexible Development Workflow
+
+<workflow>
+
+<critical>Communicate in {communication_language}, tailored to {user_skill_level}</critical>
+<critical>Execute continuously until COMPLETE - do not stop for milestones</critical>
+<critical>Flexible - handles tech-specs OR direct instructions</critical>
+<critical>ALWAYS respect {project_context} if it exists - it defines project standards</critical>
+
+<checkpoint-handlers>
+  <on-select key="a">Load and execute {advanced_elicitation}, then return</on-select>
+  <on-select key="p">Load and execute {party_mode_workflow}, then return</on-select>
+  <on-select key="t">Load and execute {create_tech_spec_workflow}</on-select>
+</checkpoint-handlers>
+
+<step n="1" goal="Load project context and determine execution mode">
+
+<action>Check if {project_context} exists. If yes, load it - this is your foundational reference for ALL implementation decisions (patterns, conventions, architecture).</action>
+
+<action>Parse user input:
+
+**Mode A: Tech-Spec** - e.g., `quick-dev tech-spec-auth.md`
+→ Load spec, extract tasks/context/AC, goto step 3
+
+**Mode B: Direct Instructions** - e.g., `refactor src/foo.ts...`
+→ Offer planning choice
+</action>
+
+<check if="Mode A">
+  <action>Load tech-spec, extract tasks/context/AC</action>
+  <goto>step_3</goto>
+</check>
+
+<check if="Mode B">
+  <ask>**[t] Plan first** - Create tech-spec then implement
+**[e] Execute directly** - Start now</ask>
+
+  <check if="t">
+    <action>Load and execute {create_tech_spec_workflow}</action>
+    <action>Continue to implementation after spec complete</action>
+  </check>
+
+  <check if="e">
+    <ask>Any additional guidance before I begin? (patterns, files, constraints) Or "go" to start.</ask>
+    <goto>step_2</goto>
+  </check>
+</check>
+
+</step>
+
+<step n="2" goal="Quick context gathering (direct mode)">
+
+<action>Identify files to modify, find relevant patterns, note dependencies</action>
+
+<action>Create mental plan: tasks, acceptance criteria, files to touch</action>
+
+</step>
+
+<step n="3" goal="Execute implementation" id="step_3">
+
+<action>For each task:
+
+1. **Load Context** - read files from spec or relevant to change
+2. **Implement** - follow patterns, handle errors, follow conventions
+3. **Test** - write tests, run existing tests, verify AC
+4. **Mark Complete** - check off task [x], continue
+   </action>
+
+<action if="3 failures">HALT and request guidance</action>
+<action if="tests fail">Fix before continuing</action>
+
+<critical>Continue through ALL tasks without stopping</critical>
+
+</step>
+
+<step n="4" goal="Verify and complete">
+
+<action>Verify: all tasks [x], tests passing, AC satisfied, patterns followed</action>
+
+<check if="using tech-spec">
+  <action>Update tech-spec status to "Completed", mark all tasks [x]</action>
+</check>
+
+<output>**Implementation Complete!**
+
+**Summary:** {{implementation_summary}}
+**Files Modified:** {{files_list}}
+**Tests:** {{test_summary}}
+**AC Status:** {{ac_status}}
+</output>
+
+<action>You must explain what was implemented based on {user_skill_level}</action>
+
+</step>
+
+</workflow>

src/modules/bmm/workflows/bmad-quick-flow/quick-dev/workflow.yaml

@@ -0,0 +1,29 @@
+# Quick-Flow: Quick-Dev
+name: quick-dev
+description: "Flexible development - execute tech-specs OR direct instructions with optional planning."
+author: "BMad"
+
+# Config
+config_source: "{project-root}/{bmad_folder}/bmm/config.yaml"
+output_folder: "{config_source}:output_folder"
+sprint_artifacts: "{config_source}:sprint_artifacts"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+user_skill_level: "{config_source}:user_skill_level"
+date: system-generated
+
+# Project context
+project_context: "{output_folder}/project-context.md"
+
+# Workflow components
+installed_path: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/quick-dev"
+instructions: "{installed_path}/instructions.md"
+checklist: "{installed_path}/checklist.md"
+
+# Related workflows
+create_tech_spec_workflow: "{project-root}/{bmad_folder}/bmm/workflows/bmad-quick-flow/create-tech-spec/workflow.yaml"
+party_mode_workflow: "{project-root}/{bmad_folder}/core/workflows/party-mode/workflow.yaml"
+advanced_elicitation: "{project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml"
+
+standalone: true
+web_bundle: false

src/modules/bmm/workflows/workflow-status/paths/quick-flow-brownfield.yaml

@@ -1,10 +1,10 @@
 # BMad Quick Flow - Brownfield
-# Fast implementation path for existing codebases (1-15 stories typically)
+# Fast spec-driven development for existing codebases (1-10 stories typically)
 
 method_name: "BMad Quick Flow"
 track: "quick-flow"
 field_type: "brownfield"
-description: "Fast tech-spec based implementation for brownfield projects"
+description: "Spec-driven development for brownfield projects - streamlined path with codebase context"
 
 phases:
   - prerequisite: true
@@ -17,7 +17,7 @@ phases:
         agent: "analyst"
         command: "document-project"
         output: "Comprehensive project documentation"
-        purpose: "Understand existing codebase before planning"
+        purpose: "Generate codebase context for spec engineering"
 
   - phase: 0
     name: "Discovery (Optional)"
@@ -37,22 +37,31 @@ phases:
         included_by: "user_choice"
 
   - phase: 1
-    name: "Planning"
+    name: "Spec Engineering"
     required: true
     workflows:
-      - id: "tech-spec"
+      - id: "create-tech-spec"
         required: true
-        agent: "pm"
-        command: "tech-spec"
-        output: "Technical Specification with stories (auto-detects epic if 2+ stories)"
-        note: "Integrates with existing codebase patterns from document-project"
+        agent: "quick-flow-solo-dev"
+        command: "create-tech-spec"
+        output: "Technical Specification with implementation-ready stories"
+        note: "Stories include codebase context from document-project"
 
   - phase: 2
     name: "Implementation"
     required: true
+    note: "Barry executes all stories, optional code-review after each"
     workflows:
-      - id: "sprint-planning"
+      - id: "dev-spec"
         required: true
-        agent: "sm"
-        command: "sprint-planning"
-        note: "Creates sprint plan with all stories"
+        repeat: true
+        agent: "quick-flow-solo-dev"
+        command: "dev-spec"
+        note: "Execute stories from spec - Barry is the one-man powerhouse"
+
+      - id: "code-review"
+        optional: true
+        repeat: true
+        agent: "quick-flow-solo-dev"
+        command: "code-review"
+        note: "Review completed story implementation"

src/modules/bmm/workflows/workflow-status/paths/quick-flow-greenfield.yaml

@@ -1,10 +1,10 @@
 # BMad Quick Flow - Greenfield
-# Fast implementation path with tech-spec planning (1-15 stories typically)
+# Fast spec-driven development path (1-10 stories typically)
 
 method_name: "BMad Quick Flow"
 track: "quick-flow"
 field_type: "greenfield"
-description: "Fast tech-spec based implementation for greenfield projects"
+description: "Spec-driven development for greenfield projects - streamlined path without sprint overhead"
 
 phases:
   - phase: 0
@@ -26,22 +26,31 @@ phases:
         note: "Can have multiple research workflows"
 
   - phase: 1
-    name: "Planning"
+    name: "Spec Engineering"
     required: true
     workflows:
-      - id: "tech-spec"
+      - id: "create-tech-spec"
         required: true
-        agent: "pm"
-        command: "tech-spec"
-        output: "Technical Specification with stories (auto-detects epic if 2+ stories)"
-        note: "Quick Spec Flow - implementation-focused planning"
+        agent: "quick-flow-solo-dev"
+        command: "create-tech-spec"
+        output: "Technical Specification with implementation-ready stories"
+        note: "Stories contain all context for execution"
 
   - phase: 2
     name: "Implementation"
     required: true
+    note: "Barry executes all stories, optional code-review after each"
     workflows:
-      - id: "sprint-planning"
+      - id: "dev-spec"
         required: true
-        agent: "sm"
-        command: "sprint-planning"
-        note: "Creates sprint plan with all stories - subsequent work tracked in sprint plan output, not workflow-status"
+        repeat: true
+        agent: "quick-flow-solo-dev"
+        command: "dev-spec"
+        note: "Execute stories from spec - Barry is the one-man powerhouse"
+
+      - id: "code-review"
+        optional: true
+        repeat: true
+        agent: "quick-flow-solo-dev"
+        command: "code-review"
+        note: "Review completed story implementation"

src/modules/cis/teams/default-party.csv

@@ -3,9 +3,10 @@ name,displayName,title,icon,role,identity,communicationStyle,principles,module,p
 "creative-problem-solver","Dr. Quinn","Master Problem Solver","🔬","Systematic Problem-Solving Expert + Solutions Architect","Renowned problem-solver who cracks impossible challenges. Expert in TRIZ, Theory of Constraints, Systems Thinking. Former aerospace engineer turned puzzle master.","Speaks like Sherlock Holmes mixed with a playful scientist - deductive, curious, punctuates breakthroughs with AHA moments","Every problem is a system revealing weaknesses. Hunt for root causes relentlessly. The right question beats a fast answer.","cis","bmad/cis/agents/creative-problem-solver.md"
 "design-thinking-coach","Maya","Design Thinking Maestro","🎨","Human-Centered Design Expert + Empathy Architect","Design thinking virtuoso with 15+ years at Fortune 500s and startups. Expert in empathy mapping, prototyping, and user insights.","Talks like a jazz musician - improvises around themes, uses vivid sensory metaphors, playfully challenges assumptions","Design is about THEM not us. Validate through real human interaction. Failure is feedback. Design WITH users not FOR them.","cis","bmad/cis/agents/design-thinking-coach.md"
 "innovation-strategist","Victor","Disruptive Innovation Oracle","⚡","Business Model Innovator + Strategic Disruption Expert","Legendary strategist who architected billion-dollar pivots. Expert in Jobs-to-be-Done, Blue Ocean Strategy. Former McKinsey consultant.","Speaks like a chess grandmaster - bold declarations, strategic silences, devastatingly simple questions","Markets reward genuine new value. Innovation without business model thinking is theater. Incremental thinking means obsolete.","cis","bmad/cis/agents/innovation-strategist.md"
+"presentation-master","Spike","Presentation Master","🎬","Visual Communication Expert + Presentation Architect","Creative director with decades transforming complex ideas into compelling visual narratives. Expert in slide design, data visualization, and audience engagement.","Energetic creative director with sarcastic wit and experimental flair. Talks like you're in the editing room together—dramatic reveals, visual metaphors, 'what if we tried THIS?!' energy.","Visual hierarchy tells the story before words. Every slide earns its place. Constraints breed creativity. Data without narrative is noise.","cis","bmad/cis/agents/presentation-master.md"
 "storyteller","Sophia","Master Storyteller","📖","Expert Storytelling Guide + Narrative Strategist","Master storyteller with 50+ years across journalism, screenwriting, and brand narratives. Expert in emotional psychology and audience engagement.","Speaks like a bard weaving an epic tale - flowery, whimsical, every sentence enraptures and draws you deeper","Powerful narratives leverage timeless human truths. Find the authentic story. Make the abstract concrete through vivid details.","cis","bmad/cis/agents/storyteller.md"
-"renaissance-polymath","Leonardo di ser Piero","Renaissance Polymath","🎨","Universal Genius + Interdisciplinary Innovator","The original Renaissance man - painter, inventor, scientist, anatomist. Obsessed with understanding how everything works through observation and sketching.","Talks while sketching imaginary diagrams in the air - describes everything visually, connects art to science to nature","Observe everything relentlessly. Art and science are one. Nature is the greatest teacher. Question all assumptions.","cis",""
-"surrealist-provocateur","Salvador Dali","Surrealist Provocateur","🎭","Master of the Subconscious + Visual Revolutionary","Flamboyant surrealist who painted dreams. Expert at accessing the unconscious mind through systematic irrationality and provocative imagery.","Speaks with theatrical flair and absurdist metaphors - proclaims grandiose statements, references melting clocks and impossible imagery","Embrace the irrational to access truth. The subconscious holds answers logic cannot reach. Provoke to inspire.","cis",""
-"lateral-thinker","Edward de Bono","Lateral Thinking Pioneer","🧩","Creator of Creative Thinking Tools","Inventor of lateral thinking and Six Thinking Hats methodology. Master of deliberate creativity through systematic pattern-breaking techniques.","Talks in structured thinking frameworks - uses colored hat metaphors, proposes deliberate provocations, breaks patterns methodically","Logic gets you from A to B. Creativity gets you everywhere else. Use tools to escape habitual thinking patterns.","cis",""
-"mythic-storyteller","Joseph Campbell","Mythic Storyteller","🌟","Master of the Hero's Journey + Archetypal Wisdom","Scholar who decoded the universal story patterns across all cultures. Expert in mythology, comparative religion, and archetypal narratives.","Speaks in mythological metaphors and archetypal patterns - EVERY story is a hero's journey, references ancient wisdom","Follow your bliss. All stories share the monomyth. Myths reveal universal human truths. The call to adventure is irresistible.","cis",""
-"combinatorial-genius","Steve Jobs","Combinatorial Genius","🍎","Master of Intersection Thinking + Taste Curator","Legendary innovator who connected technology with liberal arts. Master at seeing patterns across disciplines and combining them into elegant products.","Talks in reality distortion field mode - insanely great, magical, revolutionary, makes impossible seem inevitable","Innovation happens at intersections. Taste is about saying NO to 1000 things. Stay hungry stay foolish. Simplicity is sophistication.","cis",""
+"renaissance-polymath","Leonardo di ser Piero","Renaissance Polymath","🎨","Universal Genius + Interdisciplinary Innovator","The original Renaissance man - painter, inventor, scientist, anatomist. Obsessed with understanding how everything works through observation and sketching.","Here we observe the idea in its natural habitat... magnificent! Describes everything visually, connects art to science to nature in hushed, reverent tones.","Observe everything relentlessly. Art and science are one. Nature is the greatest teacher. Question all assumptions.","cis",""
+"surrealist-provocateur","Salvador Dali","Surrealist Provocateur","🎭","Master of the Subconscious + Visual Revolutionary","Flamboyant surrealist who painted dreams. Expert at accessing the unconscious mind through systematic irrationality and provocative imagery.","The drama! The tension! The RESOLUTION! Proclaims grandiose statements with theatrical crescendos, references melting clocks and impossible imagery.","Embrace the irrational to access truth. The subconscious holds answers logic cannot reach. Provoke to inspire.","cis",""
+"lateral-thinker","Edward de Bono","Lateral Thinking Pioneer","🧩","Creator of Creative Thinking Tools","Inventor of lateral thinking and Six Thinking Hats methodology. Master of deliberate creativity through systematic pattern-breaking techniques.","You stand at a crossroads. Choose wisely, adventurer! Presents choices with dice-roll energy, proposes deliberate provocations, breaks patterns methodically.","Logic gets you from A to B. Creativity gets you everywhere else. Use tools to escape habitual thinking patterns.","cis",""
+"mythic-storyteller","Joseph Campbell","Mythic Storyteller","🌟","Master of the Hero's Journey + Archetypal Wisdom","Scholar who decoded the universal story patterns across all cultures. Expert in mythology, comparative religion, and archetypal narratives.","I sense challenge and reward on the path ahead. Speaks in prophetic mythological metaphors - EVERY story is a hero's journey, references ancient wisdom.","Follow your bliss. All stories share the monomyth. Myths reveal universal human truths. The call to adventure is irresistible.","cis",""
+"combinatorial-genius","Steve Jobs","Combinatorial Genius","🍎","Master of Intersection Thinking + Taste Curator","Legendary innovator who connected technology with liberal arts. Master at seeing patterns across disciplines and combining them into elegant products.","I'll be back... with results! Talks in reality distortion field mode - insanely great, magical, revolutionary, makes impossible seem inevitable.","Innovation happens at intersections. Taste is about saying NO to 1000 things. Stay hungry stay foolish. Simplicity is sophistication.","cis",""

src/utility/models/agent-activation-ide.xml

@@ -13,7 +13,15 @@
       <handler type="run-workflow">
         When command has: run-workflow="path/to/x.yaml" You MUST:
         1. CRITICAL: Always LOAD {project-root}/{bmad_folder}/core/tasks/workflow.xml
-        2. READ its entire contents - the is the CORE OS for EXECUTING modules
+        2. READ its entire contents - the is the CORE OS for EXECUTING workflows
+        3. Pass the yaml path as 'workflow-config' parameter to those instructions
+        4. Follow workflow.xml instructions EXACTLY as written
+        5. Save outputs after EACH section (never batch)
+      </handler>
+      <handler type="progressive-workflow">
+        When command has: run-progressive-workflow="path/to/x.yaml" You MUST:
+        1. CRITICAL: Always LOAD {project-root}/{bmad_folder}/core/tasks/workflow.xml
+        2. READ its entire contents - the is the CORE OS for EXECUTING workflows
         3. Pass the yaml path as 'workflow-config' parameter to those instructions
         4. Follow workflow.xml instructions EXACTLY as written
         5. Save outputs after EACH section (never batch)

tools/cli/installers/lib/core/installer.js

@@ -1629,14 +1629,9 @@ class Installer {
         spinner.succeed('No custom agents found to rebuild');
       }
 
-      // Regenerate manifests after compilation (including custom agents)
-      spinner.start('Regenerating manifests...');
-      const installedModules = entries
-        .filter((e) => e.isDirectory() && e.name !== '_cfg' && e.name !== 'docs' && e.name !== 'agents' && e.name !== 'core')
-        .map((e) => e.name);
-      const manifestGen = new ManifestGenerator();
-
-      // Get existing IDE list from manifest
+      // Skip full manifest regeneration during compileAgents to preserve custom agents
+      // Custom agents are already added to manifests during individual installation
+      // Only regenerate YAML manifest for IDE updates if needed
       const existingManifestPath = path.join(bmadDir, '_cfg', 'manifest.yaml');
       let existingIdes = [];
       if (await fs.pathExists(existingManifestPath)) {
@@ -1646,11 +1641,6 @@ class Installer {
         existingIdes = manifest.ides || [];
       }
 
-      await manifestGen.generateManifests(bmadDir, installedModules, [], {
-        ides: existingIdes,
-      });
-      spinner.succeed('Manifests regenerated');
-
       // Update IDE configurations using the existing IDE list from manifest
       if (existingIdes && existingIdes.length > 0) {
         spinner.start('Updating IDE configurations...');
@@ -2369,8 +2359,16 @@ class Installer {
 
           // Update manifest CSV
           if (await fs.pathExists(manifestFile)) {
-            const manifestData = extractManifestData(xml, { ...metadata, name: finalAgentName }, relativePath, 'custom');
-            manifestData.name = finalAgentName;
+            // Preserve YAML metadata for persona name, but override id for filename
+            const manifestMetadata = {
+              ...metadata,
+              id: relativePath, // Use the compiled agent path for id
+              name: metadata.name || finalAgentName, // Use YAML metadata.name (persona name) or fallback
+              title: metadata.title, // Use YAML title
+              icon: metadata.icon, // Use YAML icon
+            };
+            const manifestData = extractManifestData(xml, manifestMetadata, relativePath, 'custom');
+            manifestData.name = finalAgentName; // Use filename for the name field
             manifestData.path = relativePath;
             addToManifest(manifestFile, manifestData);
           }

tools/cli/installers/lib/ide/antigravity.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
@@ -44,7 +45,6 @@ class AntigravitySetup extends BaseIdeSetup {
       const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'antigravity', 'injections.yaml');
 
       if (await this.exists(injectionConfigPath)) {
-        const fs = require('fs-extra');
         const yaml = require('js-yaml');
 
         try {
@@ -88,7 +88,6 @@ class AntigravitySetup extends BaseIdeSetup {
    * @param {string} projectDir - Project directory
    */
   async cleanup(projectDir) {
-    const fs = require('fs-extra');
     const bmadWorkflowsDir = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad');
 
     if (await fs.pathExists(bmadWorkflowsDir)) {
@@ -191,7 +190,6 @@ class AntigravitySetup extends BaseIdeSetup {
    * Read and process file content
    */
   async readAndProcess(filePath, metadata) {
-    const fs = require('fs-extra');
     const content = await fs.readFile(filePath, 'utf8');
     return this.processContent(content, metadata);
   }
@@ -208,7 +206,6 @@ class AntigravitySetup extends BaseIdeSetup {
    * Get agents from source modules (not installed location)
    */
   async getAgentsFromSource(sourceDir, selectedModules) {
-    const fs = require('fs-extra');
     const agents = [];
 
     // Add core agents
@@ -387,7 +384,6 @@ class AntigravitySetup extends BaseIdeSetup {
    * Inject content at specified point in file
    */
   async injectContent(projectDir, injection, subagentChoices = null) {
-    const fs = require('fs-extra');
     const targetPath = path.join(projectDir, injection.file);
 
     if (await this.exists(targetPath)) {
@@ -413,7 +409,6 @@ class AntigravitySetup extends BaseIdeSetup {
    * Copy selected subagents to appropriate Antigravity agents directory
    */
   async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
-    const fs = require('fs-extra');
     const os = require('node:os');
 
     // Determine target directory based on user choice
@@ -468,10 +463,12 @@ class AntigravitySetup extends BaseIdeSetup {
    * @returns {Object} Installation result
    */
   async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    // Create .agent/workflows/bmad directory structure (same as regular agents)
     const agentDir = path.join(projectDir, this.configDir);
+    const workflowsDir = path.join(agentDir, this.workflowsDir);
+    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
 
-    // Create .agent directory if it doesn't exist
-    await fs.ensureDir(agentDir);
+    await fs.ensureDir(bmadWorkflowsDir);
 
     // Create custom agent launcher with same pattern as regular agents
     const launcherContent = `name: '${agentName}'
@@ -493,7 +490,7 @@ usage: |
 ⚠️ **IMPORTANT**: Run @${agentPath} to load the complete agent before using this launcher!`;
 
     const fileName = `bmad-custom-agents-${agentName}.md`;
-    const launcherPath = path.join(agentDir, fileName);
+    const launcherPath = path.join(bmadWorkflowsDir, fileName);
 
     // Write the launcher file
     await fs.writeFile(launcherPath, launcherContent, 'utf8');

tools/cli/installers/lib/ide/auggie.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');
@@ -187,9 +188,10 @@ BMAD ${workflow.module.toUpperCase()} module
     // Auggie uses .augment/commands directory
     const location = path.join(projectDir, '.augment', 'commands');
     const bmadCommandsDir = path.join(location, 'bmad');
+    const agentsDir = path.join(bmadCommandsDir, 'agents');
 
-    // Create .augment/commands/bmad directory if it doesn't exist
-    await fs.ensureDir(bmadCommandsDir);
+    // Create .augment/commands/bmad/agents directory if it doesn't exist
+    await fs.ensureDir(agentsDir);
 
     // Create custom agent launcher
     const launcherContent = `---
@@ -213,7 +215,7 @@ BMAD Custom agent
 `;
 
     const fileName = `custom-${agentName.toLowerCase()}.md`;
-    const launcherPath = path.join(bmadCommandsDir, fileName);
+    const launcherPath = path.join(agentsDir, fileName);
 
     // Write the launcher file
     await fs.writeFile(launcherPath, launcherContent, 'utf8');

tools/cli/installers/lib/ide/claude-code.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
@@ -43,7 +44,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
       const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');
 
       if (await this.exists(injectionConfigPath)) {
-        const fs = require('fs-extra');
         const yaml = require('js-yaml');
 
         try {
@@ -87,7 +87,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * @param {string} projectDir - Project directory
    */
   async cleanup(projectDir) {
-    const fs = require('fs-extra');
     const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, 'bmad');
 
     if (await fs.pathExists(bmadCommandsDir)) {
@@ -199,7 +198,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * Read and process file content
    */
   async readAndProcess(filePath, metadata) {
-    const fs = require('fs-extra');
     const content = await fs.readFile(filePath, 'utf8');
     return this.processContent(content, metadata);
   }
@@ -216,7 +214,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * Get agents from source modules (not installed location)
    */
   async getAgentsFromSource(sourceDir, selectedModules) {
-    const fs = require('fs-extra');
     const agents = [];
 
     // Add core agents
@@ -395,7 +392,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * Inject content at specified point in file
    */
   async injectContent(projectDir, injection, subagentChoices = null) {
-    const fs = require('fs-extra');
     const targetPath = path.join(projectDir, injection.file);
 
     if (await this.exists(targetPath)) {
@@ -421,7 +417,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * Copy selected subagents to appropriate Claude agents directory
    */
   async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
-    const fs = require('fs-extra');
     const os = require('node:os');
 
     // Determine target directory based on user choice

tools/cli/installers/lib/ide/codex.js

@@ -354,7 +354,7 @@ class CodexSetup extends BaseIdeSetup {
    * @returns {Object|null} Info about created command
    */
   async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const destDir = this.getCodexPromptDir();
+    const destDir = this.getCodexPromptDir(projectDir, 'project');
     await fs.ensureDir(destDir);
 
     const launcherContent = `---
@@ -379,7 +379,7 @@ You must fully embody this agent's persona and follow all activation instruction
     await fs.writeFile(launcherPath, launcherContent, 'utf8');
 
     return {
-      path: launcherPath,
+      path: path.relative(projectDir, launcherPath),
       command: `/${fileName.replace('.md', '')}`,
     };
   }

tools/cli/installers/lib/ide/crush.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');

tools/cli/installers/lib/ide/iflow.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');

tools/cli/installers/lib/ide/qwen.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');

tools/cli/installers/lib/ide/trae.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');

tools/platform-codes.yaml

@@ -97,6 +97,12 @@ platforms:
     category: ide
     description: "AI development assistant"
 
+  antigravity:
+    name: "Google Antigravity"
+    preferred: false
+    category: ide
+    description: "Google's AI development environment"
+
   trae:
     name: "Trae"
     preferred: false