bmad-orchestrator（bmad 协调器）

BMAD Orchestrator

Orchestrate the 4-phase BMAD Method (Breakthrough Method of Agile AI Driven Development) across OpenClaw ↔ Claude Code.

Architecture

• Phases 1-3 (Interactive): Run through OpenClaw chat with the user. You facilitate brainstorming, refine the PRD, debate architecture. The user's ideas matter most here.
• Party Mode: At key decision points, suggest running party mode on Claude Code — multiple BMAD agents debate the topic and produce richer output.
• Phase 4 (Automated): Delegate to Claude Code via tmux on the dev VM. Monitor progress, report back.

Prerequisites

• Claude Code installed on dev VM (accessible via SSH)
• BMAD framework installed in the project (_bmad/ directory with agents, workflows, commands)
• tmux available on the dev VM

State Tracking

Track workflow state in _bmad-output/orchestrator-state.yaml:

project: <name>
vm_host: <ip>
vm_user: <user>
project_path: <path>
tmux_socket: /tmp/openclaw-tmux-sockets/openclaw.sock
tmux_session: bmad-<project>
current_phase: 1|2|3|4
current_workflow: <workflow-name>
artifacts:
  brainstorming_report: null|path
  product_brief: null|path  
  prd: null|path
  ux_spec: null|path
  architecture: null|path
  epics: null|path
  sprint_status: null|path
  project_context: null|path

Phase 1: Analysis (Interactive with User)

1.1 Brainstorming (bmad-brainstorming)

Run this conversationally with the user in OpenClaw chat:

1. Ask: "What project are we building? Give me the elevator pitch."
2. Explore the problem space — ask about users, pain points, existing solutions
3. Challenge assumptions — play devil's advocate
4. Suggest Party Mode: "Want me to run party mode on Claude Code? The BMAD agents (analyst, architect, PM, dev) will debate your idea and surface things we might miss."
5. If party mode → send /bmad-brainstorming to Claude Code, capture output, share highlights
6. Synthesize into key decisions and themes
7. Produce: brainstorming-report.md

1.2 Research (bmad-bmm-research) — Optional

If the project needs market/technical/domain validation:

1. Discuss with user what needs validation
2. Send research workflow to Claude Code for heavy lifting
3. Review findings together

1.3 Product Brief (bmad-bmm-create-product-brief)

1. Start from brainstorming output
2. Walk through with user: vision, target users, success metrics, scope
3. Suggest Party Mode: "The PM and analyst agents can stress-test this brief. Run it?"
4. If party mode → send command, capture debate highlights
5. Iterate until user approves
6. Produce: product-brief.md

Phase 2: Planning (Interactive with User)

2.1 PRD (bmad-bmm-create-prd)

1. Load product brief as context
2. Walk through requirements with user section by section:

- Functional requirements (FRs) - Non-functional requirements (NFRs) - User journeys - Success metrics

1. Suggest Party Mode: "PM + architect + QA can review these requirements together. Good time to catch gaps."
2. If party mode → send command, share findings
3. Iterate until user signs off
4. Produce: prd.md

2.2 UX Design (bmad-bmm-create-ux-design) — If applicable

Only for projects with UI. Skip for backend/infrastructure tools.

Phase 3: Solutioning (Interactive with User)

3.1 Architecture (bmad-bmm-create-architecture)

1. Load PRD as context
2. Discuss technical decisions with user:

- Language/framework choices - Deployment model - Key patterns and trade-offs - ADRs (Architecture Decision Records)

1. Suggest Party Mode: "Architect + dev + QA debating the architecture will surface implementation risks early."
2. If party mode → send command, share the debate
3. Iterate with user
4. Produce: architecture.md with ADRs

3.2 Epics & Stories (bmad-bmm-create-epics-and-stories)

1. Load architecture + PRD
2. Present epic breakdown to user for review
3. Discuss story sizing, priorities, dependencies
4. Produce: epics.md with stories

3.3 Readiness Check (bmad-bmm-check-implementation-readiness)

1. Send to Claude Code for automated gate check
2. Share result: PASS / CONCERNS / FAIL
3. If CONCERNS/FAIL → discuss with user, fix gaps
4. Produce: readiness report

3.4 Project Context (bmad-bmm-generate-project-context)

1. Send to Claude Code after architecture is finalized
2. Review output with user
3. Produce: project-context.md

Phase 4: Implementation (Automated via Claude Code)

4.0 Setup

See references/tmux-setup.md for tmux session initialization.

4.1 Sprint Planning

Send to Claude Code:

/bmad-bmm-sprint-planning

Capture and save sprint-status.yaml.

4.2 Story Loop (per epic)

For each epic, for each story:

1. Create Story: Send /bmad-bmm-create-story → produces story-[slug].md
2. Dev Story: Send /bmad-bmm-dev-story → implements code + tests
3. Code Review: Send /bmad-bmm-code-review → validates quality
4. If review fails → send fixes back, re-review
5. Update sprint status
6. Commit after each story

4.3 Epic Completion

After all stories in an epic:

1. Send /bmad-bmm-retrospective for lessons learned
2. Optionally run /bmad-bmm-automate for E2E test generation
3. Commit and update sprint status

4.4 Monitoring

Set up a cron job to monitor Claude Code progress every 15 minutes. Report status updates to user via chat.

Party Mode Integration

Party mode simulates a multi-agent discussion in Claude Code. Use it at these moments:

To trigger party mode on Claude Code:

tmux send-keys -l -- "/bmad-party-mode" && sleep 0.3 && tmux send-keys Enter

Capture output, extract key insights, present to user.

Claude Code Commands Reference

See references/bmad-commands.md for the full command list.

Quick Flow (Skip Phases 1-3)

For small, well-understood work:

1. /bmad-bmm-quick-spec → tech-spec.md
2. /bmad-bmm-quick-dev → implementation

Only use when user explicitly says the project is simple and well-understood.

Sending Commands to Claude Code

See references/tmux-setup.md for the tmux interaction patterns.

Key rules:

• Split text and Enter with a delay (Claude Code TUI timing)
• Use capture-pane -S -200 to read output
• Wait for idle prompt before sending next command
• Use C-c to interrupt if stuck