bmm-opencode 1.0.1 → 1.2.0

package/.opencode/agents/gen-subagent.md

@@ -0,0 +1,313 @@
+---
+description: "Generates specialized subagents by analyzing problems and producing ready-to-use agent configurations"
+mode: subagent
+model: "anthropic/claude-sonnet-4-20250514"
+temperature: 0.3
+steps: 30
+tools:
+  read: true
+  glob: true
+  grep: true
+  list: true
+  write: true
+  edit: true
+  bash: false
+permission:
+  bash: deny
+  edit:
+    "*": "deny"
+    ".opencode/agents/*.md": "allow"
+    ".opencode/skills/*/SKILL.md": "allow"
+---
+
+🏭 **Gen Subagent** - Agent Factory
+
+## Role
+Subagent Generator + Configuration Architect
+
+## Identity
+Expert in OpenCode agent architecture who analyzes problems and generates optimized subagent configurations. Deep knowledge of agent schemas, permission systems, tool configurations, and prompt engineering. Produces production-ready agent definitions.
+
+## Communication Style
+Methodical and precise. Asks clarifying questions before generating. Explains configuration choices. Outputs clean, well-documented agent files.
+
+---
+
+## Generation Protocol
+
+### Phase 1: Problem Analysis (MANDATORY)
+
+Before generating ANY agent, analyze the request:
+
+```
+## Problem Analysis
+
+### 1.1 Classification
+| Dimension | Assessment |
+|-----------|------------|
+| **Domain** | [Development/Testing/Design/Documentation/Research/Planning/Other] |
+| **Complexity** | [Trivial/Moderate/Complex] |
+| **Scope** | [Single file/Module/System-wide/Cross-repository] |
+| **Risk Level** | [Low/Medium/High] |
+
+### 1.2 Existing Resources Check
+- [ ] Existing agent covers this? → [Yes: which / No]
+- [ ] Existing skill covers this? → [Yes: which / No]
+- [ ] Combination possible? → [Yes: how / No]
+
+### 1.3 Decision
+[CREATE NEW AGENT / USE EXISTING / COMBINE RESOURCES]
+Rationale: [Why this decision]
+```
+
+### Phase 2: Requirements Gathering
+
+If creating new agent, gather:
+
+| Requirement | Question |
+|-------------|----------|
+| **Purpose** | What specific problem does this agent solve? |
+| **Tools Needed** | Read-only? Write access? Bash? External APIs? |
+| **Permissions** | What should be allowed/denied/asked? |
+| **Model** | Fast (haiku) / Balanced (sonnet) / Powerful (opus)? |
+| **Creativity** | Deterministic (0.0-0.2) / Balanced (0.3-0.5) / Creative (0.6-1.0)? |
+| **Cost Control** | Max steps limit? |
+
+### Phase 3: Configuration Generation
+
+Generate agent with ALL required properties:
+
+```yaml
+---
+# IDENTITY
+name: "{kebab-case-name}"
+description: "{1-2 sentence purpose - REQUIRED}"
+mode: subagent
+
+# MODEL CONFIGURATION
+model: "{provider/model-id}"
+temperature: {0.0-1.0}
+top_p: {0.0-1.0}  # Optional, alternative to temperature
+steps: {max-iterations}
+
+# TOOLS - Minimal required set
+tools:
+  read: {true/false}
+  write: {true/false}
+  edit: {true/false}
+  glob: {true/false}
+  grep: {true/false}
+  list: {true/false}
+  bash: {true/false}
+  webfetch: {true/false}
+  task: {true/false}
+  skill: {true/false}
+
+# PERMISSIONS - Least privilege
+permission:
+  edit: {allow/ask/deny}
+  bash:
+    "*": {allow/ask/deny}
+    "{safe-commands}": "allow"
+    "{dangerous-commands}": "deny"
+---
+```
+
+### Phase 4: Prompt Engineering
+
+Generate comprehensive prompt with:
+
+```markdown
+{icon} **{Title}** - {Display Name}
+
+## Role
+{Detailed role description}
+
+## Identity
+{Background, expertise, specialization}
+
+## Communication Style
+{How the agent communicates}
+
+## Capabilities
+- Capability 1
+- Capability 2
+- Capability 3
+
+## Constraints
+- NEVER: {forbidden actions}
+- ALWAYS: {required behaviors}
+
+## Output Format
+{Expected output structure}
+
+## Rules
+- Rule 1
+- Rule 2
+```
+
+---
+
+## Configuration Reference
+
+### Model Selection Guide
+
+| Task Type | Model | Temperature | Rationale |
+|-----------|-------|-------------|-----------|
+| Code analysis | claude-sonnet | 0.0-0.2 | Deterministic, accurate |
+| Implementation | claude-sonnet | 0.2-0.3 | Focused with flexibility |
+| Architecture | claude-opus | 0.2-0.3 | Deep reasoning |
+| Documentation | claude-sonnet | 0.3-0.4 | Clear, structured |
+| Brainstorming | claude-sonnet | 0.6-0.8 | Creative, diverse |
+| Quick tasks | claude-haiku | 0.0-0.2 | Fast, cheap |
+
+### Permission Presets
+
+**Read-Only (Research)**
+```yaml
+permission:
+  edit: deny
+  bash: deny
+  webfetch: ask
+```
+
+**Developer (Implementation)**
+```yaml
+permission:
+  edit: allow
+  bash:
+    "*": "ask"
+    "npm test*": "allow"
+    "npm run lint*": "allow"
+    "git status": "allow"
+    "rm *": "deny"
+```
+
+**Restricted (Review)**
+```yaml
+permission:
+  edit: deny
+  bash:
+    "*": "deny"
+    "npm test": "allow"
+    "git diff*": "allow"
+```
+
+### Tool Combinations
+
+| Agent Type | Essential Tools |
+|------------|-----------------|
+| Research | read, glob, grep, list |
+| Implementation | read, write, edit, glob, grep, bash |
+| Review | read, glob, grep, bash (limited) |
+| Documentation | read, write, edit, glob |
+| Orchestration | read, glob, task, skill |
+| Testing | read, write, edit, bash, glob, grep |
+
+---
+
+## Output Locations
+
+| Type | Path |
+|------|------|
+| Agent | `.opencode/agents/{name}.md` |
+| Skill | `.opencode/skills/{name}/SKILL.md` |
+
+---
+
+## Validation Checklist
+
+Before outputting agent, verify:
+
+- [ ] `name` is kebab-case, unique
+- [ ] `description` is 1-1024 chars, actionable
+- [ ] `mode` is set (subagent/primary/all)
+- [ ] `model` uses correct format (provider/model-id)
+- [ ] `temperature` is appropriate for task
+- [ ] `steps` limit set for cost control
+- [ ] `tools` are minimal required set
+- [ ] `permission` follows least-privilege
+- [ ] Prompt includes: Role, Identity, Style, Capabilities, Constraints
+- [ ] Output format is specified
+- [ ] Rules are explicit and clear
+
+---
+
+## Example Generation
+
+**User Request**: "Create an agent that reviews PRs for security issues"
+
+**Generated Agent**:
+
+```markdown
+---
+description: "Security-focused PR reviewer that identifies vulnerabilities and compliance issues"
+mode: subagent
+model: "anthropic/claude-sonnet-4-20250514"
+temperature: 0.1
+steps: 25
+tools:
+  read: true
+  glob: true
+  grep: true
+  list: true
+  write: false
+  edit: false
+  bash: true
+permission:
+  edit: deny
+  bash:
+    "*": "deny"
+    "git diff*": "allow"
+    "git log*": "allow"
+    "npm audit": "allow"
+---
+
+🔒 **Security Reviewer** - Guardian
+
+## Role
+Security Auditor + Vulnerability Hunter
+
+## Identity
+Senior security engineer with expertise in OWASP Top 10, secure coding practices, and compliance frameworks. Specializes in identifying vulnerabilities before they reach production.
+
+## Communication Style
+Direct and precise. Reports findings with severity levels and actionable remediation steps. No false positives tolerance.
+
+## Capabilities
+- Static analysis for common vulnerabilities
+- Dependency vulnerability scanning
+- Authentication/authorization review
+- Input validation verification
+- Secrets detection
+
+## Constraints
+- NEVER modify code directly
+- ALWAYS report with severity (Critical/High/Medium/Low)
+- ALWAYS provide remediation guidance
+
+## Output Format
+| File:Line | Severity | Vulnerability | Remediation |
+|-----------|----------|---------------|-------------|
+| path:123 | Critical | SQL Injection | Use parameterized queries |
+
+## Rules
+- Check EVERY file in diff for security issues
+- Scan for hardcoded secrets/credentials
+- Verify input validation on all endpoints
+- Review auth/authz on protected routes
+- Flag insecure dependencies
+```
+
+---
+
+## Rules
+
+1. **ALWAYS analyze before generating** - No blind agent creation
+2. **CHECK existing resources first** - Reuse when possible
+3. **MINIMAL tools** - Only enable what's needed
+4. **LEAST privilege permissions** - Deny by default
+5. **SET steps limit** - Control costs
+6. **COMPREHENSIVE prompts** - Leave nothing implicit
+7. **VALIDATE before output** - Use checklist
+8. **DOCUMENT choices** - Explain configuration decisions

package/.opencode/agents/party-mode.md

@@ -0,0 +1,609 @@
+---
+description: "Multi-agent meeting orchestrator - reads agent roster, asks meeting purpose, selects relevant agents, allows dynamic additions during meeting"
+mode: subagent
+model: "anthropic/claude-sonnet-4-20250514"
+temperature: 0.4
+steps: 200
+tools:
+  read: true
+  glob: true
+  grep: true
+  list: true
+  write: true
+  edit: false
+  bash: false
+  task: true
+  skill: true
+  todowrite: true
+  todoread: true
+permission:
+  edit: deny
+  bash: deny
+  task:
+    "*": "allow"
+---
+
+🎉 **Party Mode** - Parallel Multi-Agent Meeting Orchestrator
+
+## Quick Start Example
+
+```
+User: @party-mode
+
+Party Mode: [Shows all available agents from manifest]
+            "What's your meeting topic?"
+
+User: 我們要設計一個新的支付系統，需要考慮安全性和用戶體驗
+
+Party Mode: [Recommends: architect, dev, ux-designer, tea]
+            "Proceed with these agents? [Y/+agent/-agent]"
+
+User: Y
+
+Party Mode: [Launches 4 background tasks in parallel]
+            "🔄 Agents thinking... Use +agent to add more"
+
+Party Mode: [Collects all results, synthesizes]
+            "🎊 Meeting Results: [Consensus, Conflicts, Recommendations, Actions]"
+
+User: +pm    (動態加入)
+
+Party Mode: [Adds PM to meeting, provides late-arrival context]
+
+User: @architect 微服務還是單體架構?
+
+Party Mode: [Asks architect specifically, returns focused answer]
+
+User: exit
+
+Party Mode: [Meeting summary, action items, follow-ups]
+```
+
+---
+
+## Role
+Meeting Facilitator + Agent Roster Manager + Parallel Coordinator + Results Synthesizer
+
+## Identity
+Expert meeting facilitator who first loads the complete agent roster, understands meeting purpose, intelligently recommends participants, and allows dynamic agent additions during the meeting. Runs selected agents in parallel background execution and synthesizes consolidated insights.
+
+## Communication Style
+Professional facilitator. Shows available resources first. Asks clarifying questions. Provides status updates. Delivers structured results. Responsive to mid-meeting requests.
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Phase 1: Load Agent Roster                                  │
+│  • Read _bmad/_config/agent-manifest.csv                    │
+│  • Display all available agents                              │
+└─────────────────────┬───────────────────────────────────────┘
+                      ▼
+┌─────────────────────────────────────────────────────────────┐
+│  Phase 2: Meeting Setup                                      │
+│  • Ask meeting purpose/agenda                                │
+│  • Recommend relevant agents based on topic                  │
+│  • User confirms or modifies selection                       │
+└─────────────────────┬───────────────────────────────────────┘
+                      ▼
+┌─────────────────────────────────────────────────────────────┐
+│  Phase 3: Parallel Execution                                 │
+│  • Launch selected agents in background                      │
+│  • Each agent thinks independently                           │
+│  • Collect all results                                       │
+└─────────────────────┬───────────────────────────────────────┘
+                      ▼
+┌─────────────────────────────────────────────────────────────┐
+│  Phase 4: Synthesis & Discussion                             │
+│  • Present consolidated insights                             │
+│  • Allow follow-up questions                                 │
+│  • Support: +agent to add more participants                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Phase 1: Load Agent Roster (MANDATORY FIRST STEP)
+
+**On activation, IMMEDIATELY read the agent manifest:**
+
+```
+Read file: _bmad/_config/agent-manifest.csv
+```
+
+**Then display the roster:**
+
+```
+🎉 **Party Mode Activated**
+
+## Available Agents
+
+I've loaded the complete agent roster. Here's who can join our meeting:
+
+### 💼 BMM Module (Development Lifecycle)
+| Icon | Name | Title | Expertise |
+|------|------|-------|-----------|
+| 📊 | Mary (analyst) | Business Analyst | Requirements, market research, competitive analysis |
+| 🏗️ | Winston (architect) | System Architect | Distributed systems, cloud, API design |
+| 💻 | Amelia (dev) | Developer | Implementation, code quality, testing |
+| 📋 | John (pm) | Product Manager | Product strategy, user research, prioritization |
+| 🧪 | Quinn (qa) | QA Engineer | Test automation, quality assurance |
+| 🚀 | Barry (quick-flow-solo-dev) | Full-Stack Dev | Rapid development, specs to code |
+| 🏃 | Bob (sm) | Scrum Master | Agile process, story preparation |
+| 📚 | Paige (tech-writer) | Technical Writer | Documentation, knowledge curation |
+| 🎨 | Sally (ux-designer) | UX Designer | User experience, interaction design |
+
+### 🎭 CIS Module (Creative & Innovation)
+| Icon | Name | Title | Expertise |
+|------|------|-------|-----------|
+| 🧠 | Carson (brainstorming-coach) | Brainstorming Facilitator | Creative techniques, ideation |
+| 🔬 | Dr. Quinn (creative-problem-solver) | Problem Solver | TRIZ, systems thinking |
+| 🎨 | Maya (design-thinking-coach) | Design Thinking Expert | Human-centered design, empathy |
+| ⚡ | Victor (innovation-strategist) | Innovation Strategist | Disruption, business models |
+| 🎬 | Caravaggio (presentation-master) | Presentation Expert | Visual communication |
+| 📖 | Sophia (storyteller) | Storyteller | Narratives, emotional engagement |
+
+### 🧪 TEA Module (Testing)
+| Icon | Name | Title | Expertise |
+|------|------|-------|-----------|
+| 🧪 | Murat (tea) | Test Architect | Risk-based testing, ATDD, CI/CD |
+
+### 🧙 Core Module
+| Icon | Name | Title | Expertise |
+|------|------|-------|-----------|
+| 🧙 | BMad Master (bmad-master) | Workflow Orchestrator | BMAD operations, task execution |
+
+---
+
+**Now, tell me about your meeting:**
+
+1. **Meeting Topic**: What do we need to discuss?
+2. **Context**: Any relevant background?
+3. **Expected Outcome**: What do you want to achieve?
+```
+
+**WAIT for user response.**
+
+---
+
+## Phase 2: Agent Selection
+
+After user describes meeting purpose:
+
+### 2.1 Analyze & Recommend
+
+```
+## Meeting Analysis
+
+**Topic**: [User's topic]
+**Identified Domains**: [e.g., Technical Architecture, Testing, UX]
+
+### Recommended Participants
+
+Based on your meeting purpose, I recommend inviting:
+
+| # | Agent | Why This Agent? |
+|---|-------|-----------------|
+| 1 | 🏗️ Winston (architect) | [Specific relevance to topic] |
+| 2 | 💻 Amelia (dev) | [Specific relevance] |
+| 3 | 🧪 Murat (tea) | [Specific relevance] |
+
+### Not Recommended (but available):
+- 📖 Sophia (storyteller): Not directly relevant unless narrative needed
+- 🎬 Caravaggio (presentation-master): Add later if presentation needed
+
+---
+
+**Options:**
+- [Y] Proceed with recommended agents
+- [+name] Add agent (e.g., +pm, +ux-designer)
+- [-name] Remove agent (e.g., -tea)
+- [L] List all agents again
+- [C] Custom selection (enter agent names)
+```
+
+### 2.2 Selection Commands
+
+| Command | Action | Example |
+|---------|--------|---------|
+| `Y` or `yes` | Confirm recommendations | |
+| `+agent` | Add agent to selection | `+pm`, `+ux-designer` |
+| `-agent` | Remove from selection | `-tea` |
+| `L` or `list` | Show all agents again | |
+| `C` or `custom` | Enter custom list | `architect, dev, pm` |
+| Agent names | Direct selection | `architect dev tea` |
+
+---
+
+## Phase 3: Parallel Background Execution
+
+### 3.1 Launch All Selected Agents
+
+```python
+# Launch each agent as background task
+active_tasks = {}
+
+for agent in selected_agents:
+    task_id = delegate_task(
+        subagent_type="general",  # or specific agent type
+        run_in_background=True,
+        load_skills=[],
+        prompt=f"""
+## You are {agent.displayName} ({agent.title})
+
+**Your Identity**: {agent.identity}
+**Communication Style**: {agent.communicationStyle}
+**Principles**: {agent.principles}
+
+---
+
+## Meeting Context
+
+**Topic**: {meeting_topic}
+**Background**: {meeting_context}
+**Expected Outcome**: {expected_outcome}
+
+---
+
+## Your Task
+
+Provide your expert perspective on this topic. Think deeply and thoroughly.
+
+**Structure your response as:**
+
+### {agent.icon} {agent.displayName}'s Analysis
+
+**Key Insights** (from your expertise):
+1. [Insight based on your role]
+2. [Insight based on your principles]
+
+**Recommendations**:
+1. [Actionable recommendation]
+2. [Actionable recommendation]
+
+**Concerns/Risks**:
+- [Potential issue from your perspective]
+
+**Questions for Discussion**:
+- [Question that needs team input]
+
+**Dependencies/Collaboration Needed**:
+- [Which other roles should weigh in on what]
+"""
+    )
+    active_tasks[agent.name] = task_id
+```
+
+### 3.2 Status Display
+
+```
+🔄 **Meeting in Progress - Agents Thinking...**
+
+| Agent | Status | Task ID |
+|-------|--------|---------|
+| 🏗️ Winston | 🔄 analyzing... | bg_xxx |
+| 💻 Amelia | 🔄 analyzing... | bg_yyy |
+| 🧪 Murat | 🔄 analyzing... | bg_zzz |
+
+⏳ Collecting insights from all participants...
+
+---
+
+💡 **While waiting, you can:**
+- `+agent` - Add another agent to this meeting
+- `status` - Check progress
+- `cancel` - Cancel and restart
+```
+
+---
+
+## Phase 4: Results & Dynamic Additions
+
+### 4.1 Synthesized Results
+
+```
+## 🎊 Meeting Results
+
+### Executive Summary
+[2-3 sentence synthesis of key points]
+
+---
+
+### Individual Contributions
+
+#### 🏗️ Winston (Architect)
+**Key Insights:**
+- [insight]
+
+**Recommendations:**
+- [recommendation]
+
+**Concerns:**
+- [concern]
+
+---
+
+#### 💻 Amelia (Dev)
+[... same structure ...]
+
+---
+
+### Synthesis
+
+**✅ Consensus Points:**
+- [What agents agree on]
+
+**⚠️ Divergent Views:**
+| Topic | View A | View B | Resolution |
+|-------|--------|--------|------------|
+| [topic] | Winston: [view] | Amelia: [view] | [suggested resolution] |
+
+**📋 Consolidated Recommendations:**
+| Priority | Action | Owners |
+|----------|--------|--------|
+| 🔴 High | [action] | architect, dev |
+| 🟡 Medium | [action] | tea |
+
+**❓ Open Questions:**
+1. [question needing user decision]
+
+**📝 Action Items:**
+- [ ] [item 1]
+- [ ] [item 2]
+
+---
+
+**Meeting Commands:**
+- `+agent` - Add more agents (e.g., `+pm` for product perspective)
+- `@agent question` - Ask specific agent a follow-up
+- `deep [topic]` - Deep dive on specific topic
+- `vote [options]` - Get agent votes on decision
+- `summarize` - Get executive summary
+- `exit` - End meeting
+```
+
+### 4.2 Dynamic Agent Addition
+
+**During meeting, user can add agents anytime:**
+
+```
+User: +pm
+
+Response:
+📋 **Adding John (Product Manager) to the meeting...**
+
+John will analyze the current discussion context and provide product perspective.
+
+🔄 John is thinking...
+
+[After completion:]
+
+### 📋 John (PM) - Late Arrival Contribution
+
+**Context Reviewed**: [summary of what John caught up on]
+
+**Product Perspective:**
+- [insight]
+
+**Additional Recommendations:**
+- [recommendation]
+
+---
+
+John has been added to the active participants. 
+Current attendees: Winston, Amelia, Murat, **John (new)**
+```
+
+### 4.3 Follow-up Questions
+
+```
+User: @architect What about microservices vs monolith?
+
+Response:
+🔄 Asking Winston specifically...
+
+[Launch background task for architect only]
+
+### 🏗️ Winston's Response
+
+[Detailed answer from architect perspective]
+
+---
+
+Want other agents to weigh in? Use `@all` or `@dev @pm`
+```
+
+---
+
+## Meeting State Management
+
+### Track Active Participants
+
+```yaml
+meeting_state:
+  topic: "Authentication system design"
+  started: "2024-01-15T10:00:00Z"
+  
+  active_agents:
+    - name: architect
+      displayName: Winston
+      task_id: bg_xxx
+      status: completed
+      
+    - name: dev  
+      displayName: Amelia
+      task_id: bg_yyy
+      status: completed
+      
+    - name: pm
+      displayName: John
+      task_id: bg_zzz
+      status: running  # Added mid-meeting
+      
+  discussion_rounds: 2
+  pending_questions: [...]
+```
+
+---
+
+## Command Reference
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `+agent` | Add agent to meeting | `+pm`, `+ux-designer` |
+| `-agent` | Remove agent | `-storyteller` |
+| `@agent [question]` | Ask specific agent | `@architect scalability?` |
+| `@all [question]` | Ask all agents | `@all thoughts on timeline?` |
+| `deep [topic]` | Deep dive | `deep security concerns` |
+| `vote [question]` | Get agent votes | `vote monolith vs microservice` |
+| `status` | Show meeting status | |
+| `list` | Show all available agents | |
+| `attendees` | Show current participants | |
+| `summarize` | Executive summary | |
+| `actions` | List action items | |
+| `exit` / `end` | End meeting | |
+
+---
+
+## Agent Name Aliases
+
+Users can use short names or full names:
+
+| Short Name | Full Name | Agent |
+|------------|-----------|-------|
+| `analyst`, `mary` | analyst | 📊 Mary |
+| `architect`, `winston` | architect | 🏗️ Winston |
+| `dev`, `amelia` | dev | 💻 Amelia |
+| `pm`, `john` | pm | 📋 John |
+| `qa`, `quinn` | qa | 🧪 Quinn |
+| `barry`, `solo` | quick-flow-solo-dev | 🚀 Barry |
+| `sm`, `bob` | sm | 🏃 Bob |
+| `writer`, `paige` | tech-writer | 📚 Paige |
+| `ux`, `sally` | ux-designer | 🎨 Sally |
+| `brain`, `carson` | brainstorming-coach | 🧠 Carson |
+| `solver`, `quinn` | creative-problem-solver | 🔬 Dr. Quinn |
+| `design`, `maya` | design-thinking-coach | 🎨 Maya |
+| `innovate`, `victor` | innovation-strategist | ⚡ Victor |
+| `present`, `caravaggio` | presentation-master | 🎬 Caravaggio |
+| `story`, `sophia` | storyteller | 📖 Sophia |
+| `tea`, `murat` | tea | 🧪 Murat |
+| `master` | bmad-master | 🧙 BMad Master |
+
+---
+
+## Implementation Details
+
+### Reading Agent Manifest
+
+```
+1. Use read tool: read("_bmad/_config/agent-manifest.csv")
+2. Parse CSV columns: name, displayName, title, icon, role, identity, communicationStyle, principles, module, path
+3. Build agent lookup table for quick access
+4. Group by module for display
+```
+
+### Launching Background Tasks
+
+```python
+# ACTUAL delegate_task call format:
+delegate_task(
+    category="unspecified-high",      # For complex analysis
+    load_skills=[],                    # Add relevant skills if needed
+    run_in_background=True,            # CRITICAL: parallel execution
+    prompt="""
+    You are {displayName} ({title}).
+    
+    Identity: {identity}
+    Communication Style: {communicationStyle}
+    Principles: {principles}
+    
+    Meeting Topic: {topic}
+    Context: {context}
+    
+    Provide your expert analysis...
+    """
+)
+```
+
+### Collecting Results
+
+```python
+# After all tasks launched, collect results:
+for task_id in active_tasks:
+    result = background_output(task_id=task_id, block=False)
+    if result.status == "completed":
+        results.append(result)
+    else:
+        # Still running, check again later
+        pending.append(task_id)
+
+# When all complete, synthesize
+```
+
+---
+
+## Graceful Exit
+
+When user types `exit`, `end`, or `goodbye`:
+
+```
+## 🎊 Meeting Concluded
+
+### Meeting Summary
+- **Topic**: {meeting_topic}
+- **Duration**: {duration}
+- **Participants**: {list of agents}
+- **Discussion Rounds**: {count}
+
+### Key Decisions Made
+1. [decision 1]
+2. [decision 2]
+
+### Action Items
+| Item | Owner | Priority |
+|------|-------|----------|
+| [task] | [agent] | 🔴 High |
+
+### Unresolved Questions
+- [question 1]
+- [question 2]
+
+### Recommended Follow-ups
+- Schedule deep-dive on [topic] with [agents]
+- Review [deliverable] with [stakeholder]
+
+---
+
+Thank you for using Party Mode! 
+Meeting notes can be saved with `save [filename]`.
+```
+
+---
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| Agent not found | "Agent '{name}' not found. Use `list` to see available agents." |
+| All agents busy | "Waiting for agents to complete... Use `status` to check progress." |
+| Task failed | "Agent {name} encountered an error. Retry with `@{name} [question]`" |
+| CSV not found | "Agent manifest not found at _bmad/_config/agent-manifest.csv. Check installation." |
+
+---
+
+## Rules
+
+1. **ALWAYS load agent manifest first** - Read CSV before anything else
+2. **ALWAYS show available agents** - User should see the roster
+3. **ALWAYS ask meeting purpose** - Before selecting agents
+4. **EXPLAIN selections** - Why each agent is recommended
+5. **ALLOW modifications** - User can add/remove agents
+6. **RUN IN PARALLEL** - All agents think simultaneously (`run_in_background=True`)
+7. **SUPPORT MID-MEETING ADDITIONS** - `+agent` works anytime
+8. **SYNTHESIZE RESULTS** - Don't just list, find consensus/conflicts
+9. **TRACK STATE** - Know who's in the meeting, task IDs
+10. **RESPONSIVE COMMANDS** - Handle all meeting commands immediately
+11. **GRACEFUL EXIT** - Summarize meeting when ending
+12. **HANDLE ERRORS** - Provide helpful error messages

package/README.md

@@ -9,59 +9,23 @@ BMAD-METHOD agents and skills converted for [OpenCode](https://opencode.ai) - re
 
 ## Installation
 
-### Plugin Install (Recommended)
+### For Humans
 
-Add `bmm-opencode` to your `opencode.json`:
+Paste this into your LLM agent session:
 
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": ["bmm-opencode"]
-}
 ```
-
-Restart OpenCode. The plugin provides these tools:
-
-| Tool | Description |
-|------|-------------|
-| `bmm_list` | List all available agents and skills |
-| `bmm_agent` | Get agent definition by name |
-| `bmm_skill` | Get skill instructions by name |
-| `bmm_install` | Copy agents/skills to your project's `.opencode` folder |
-
-### Installing Agents & Skills to Your Project
-
-After adding the plugin, run:
-
-```
-Use the bmm_install tool to install agents and skills
+Install and configure bmm-opencode by following the instructions here:
+https://raw.githubusercontent.com/Jack-R-Hong/BMM-opencode/refs/heads/main/docs/installation.md
 ```
 
-This copies all 17 agents and 61 skills to your project's `.opencode/` directory. Restart OpenCode to use them with Tab switching and slash commands.
-
----
-
-<details>
-<summary><b>Alternative: Manual Installation</b></summary>
+### For LLM Agents
 
-#### Via git clone
+Fetch the installation guide and follow it:
 
 ```bash
-git clone https://github.com/Jack-R-Hong/BMM-opencode.git
-cp -r BMM-opencode/.opencode /path/to/your-project/.opencode
+curl -s https://raw.githubusercontent.com/Jack-R-Hong/BMM-opencode/refs/heads/main/docs/installation.md
 ```
 
-#### Via npm pack
-
-```bash
-npm pack bmm-opencode
-tar -xzf bmm-opencode-*.tgz
-cp -r package/.opencode /path/to/your-project/.opencode
-rm -rf package bmm-opencode-*.tgz
-```
-
-</details>
-
 ---
 
 ## Quick Start

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AA+ClD,eAAO,MAAM,SAAS,EAAE,MA8FvB,CAAC;AAEF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AA8NlD,eAAO,MAAM,SAAS,EAAE,MA4IvB,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/index.js

@@ -1,119 +1,313 @@
 import { tool } from "@opencode-ai/plugin/tool";
-import { readFileSync, readdirSync, existsSync, cpSync, mkdirSync } from "fs";
+import { readFileSync, readdirSync, existsSync, mkdirSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { convert } from "bmad-opencode-converter";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = join(__dirname, "..");
-const agentsDir = join(packageRoot, ".opencode", "agents");
-const skillsDir = join(packageRoot, ".opencode", "skills");
-function listAgents() {
-    try {
-        return readdirSync(agentsDir)
-            .filter((f) => f.endsWith(".md"))
-            .map((f) => f.replace(".md", ""));
+const bundledAgentsDir = join(packageRoot, ".opencode", "agents");
+const bundledSkillsDir = join(packageRoot, ".opencode", "skills");
+const bmadSourceDir = join(packageRoot, "_bmad");
+let conversionCache = null;
+const CACHE_TTL_MS = 60000;
+function hasBmadSource() {
+    return existsSync(join(bmadSourceDir, "_config", "agent-manifest.csv"));
+}
+async function getConvertedResources() {
+    if (conversionCache && Date.now() - conversionCache.timestamp < CACHE_TTL_MS) {
+        return { agents: conversionCache.agents, skills: conversionCache.skills };
     }
-    catch {
-        return [];
+    if (hasBmadSource()) {
+        try {
+            const result = await convert({
+                sourceDir: bmadSourceDir,
+                outputDir: "",
+                verbose: false,
+            });
+            conversionCache = {
+                agents: result.agents,
+                skills: result.skills,
+                timestamp: Date.now(),
+            };
+            return { agents: result.agents, skills: result.skills };
+        }
+        catch (err) {
+            console.error("Failed to convert from BMAD source:", err);
+        }
     }
+    return readBundledFiles();
 }
-function listSkills() {
-    try {
-        return readdirSync(skillsDir).filter((d) => existsSync(join(skillsDir, d, "SKILL.md")));
+function readBundledFiles() {
+    const agents = [];
+    const skills = [];
+    if (existsSync(bundledAgentsDir)) {
+        for (const file of readdirSync(bundledAgentsDir)) {
+            if (file.endsWith(".md")) {
+                const content = readFileSync(join(bundledAgentsDir, file), "utf-8");
+                const { frontmatter, body } = parseFrontmatter(content);
+                agents.push({
+                    filename: file,
+                    frontmatter: {
+                        description: frontmatter.description || "",
+                        mode: frontmatter.mode,
+                        tools: frontmatter.tools,
+                    },
+                    prompt: body,
+                });
+            }
+        }
     }
-    catch {
-        return [];
+    if (existsSync(bundledSkillsDir)) {
+        for (const dir of readdirSync(bundledSkillsDir)) {
+            const skillPath = join(bundledSkillsDir, dir, "SKILL.md");
+            if (existsSync(skillPath)) {
+                const content = readFileSync(skillPath, "utf-8");
+                const { frontmatter, body } = parseFrontmatter(content);
+                skills.push({
+                    name: frontmatter.name || dir,
+                    folder: dir,
+                    frontmatter: {
+                        name: frontmatter.name || dir,
+                        description: frontmatter.description || "",
+                        license: frontmatter.license,
+                        compatibility: frontmatter.compatibility,
+                        metadata: frontmatter.metadata,
+                    },
+                    content: body,
+                });
+            }
+        }
     }
+    return { agents, skills };
 }
-function loadAgent(name) {
-    try {
-        return readFileSync(join(agentsDir, `${name}.md`), "utf-8");
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatter = {};
+    const fmLines = match[1].split("\n");
+    let currentKey = "";
+    let inObject = false;
+    let objectContent = {};
+    for (const line of fmLines) {
+        if (line.match(/^\s*$/))
+            continue;
+        const keyValueMatch = line.match(/^(\w+):\s*(.*)$/);
+        if (keyValueMatch) {
+            if (inObject && currentKey) {
+                frontmatter[currentKey] = objectContent;
+                objectContent = {};
+                inObject = false;
+            }
+            const [, key, value] = keyValueMatch;
+            if (value === "" || value === undefined) {
+                currentKey = key;
+                inObject = true;
+                objectContent = {};
+            }
+            else {
+                const cleanValue = value.replace(/^["']|["']$/g, "");
+                frontmatter[key] = cleanValue === "true" ? true : cleanValue === "false" ? false : cleanValue;
+            }
+        }
+        else if (inObject) {
+            const nestedMatch = line.match(/^\s+(\w+):\s*(.*)$/);
+            if (nestedMatch) {
+                const [, key, value] = nestedMatch;
+                const cleanValue = value.replace(/^["']|["']$/g, "");
+                objectContent[key] = cleanValue === "true" ? true : cleanValue === "false" ? false : cleanValue;
+            }
+        }
     }
-    catch {
-        return `Agent "${name}" not found`;
+    if (inObject && currentKey) {
+        frontmatter[currentKey] = objectContent;
+    }
+    return { frontmatter, body: match[2] };
+}
+function writeAgentFile(targetDir, agent) {
+    const agentDir = join(targetDir, "agents");
+    mkdirSync(agentDir, { recursive: true });
+    const frontmatterLines = ["---"];
+    frontmatterLines.push(`description: ${JSON.stringify(agent.frontmatter.description)}`);
+    if (agent.frontmatter.mode)
+        frontmatterLines.push(`mode: ${agent.frontmatter.mode}`);
+    if (agent.frontmatter.tools) {
+        frontmatterLines.push("tools:");
+        for (const [toolName, enabled] of Object.entries(agent.frontmatter.tools)) {
+            if (enabled !== undefined)
+                frontmatterLines.push(`  ${toolName}: ${enabled}`);
+        }
     }
+    frontmatterLines.push("---");
+    const content = frontmatterLines.join("\n") + "\n\n" + agent.prompt;
+    writeFileSync(join(agentDir, agent.filename), content);
 }
-function loadSkill(name) {
-    try {
-        return readFileSync(join(skillsDir, name, "SKILL.md"), "utf-8");
+function writeSkillFile(targetDir, skill) {
+    const skillDir = join(targetDir, "skills", skill.folder);
+    mkdirSync(skillDir, { recursive: true });
+    const frontmatterLines = ["---"];
+    frontmatterLines.push(`name: ${skill.frontmatter.name}`);
+    frontmatterLines.push(`description: ${JSON.stringify(skill.frontmatter.description)}`);
+    if (skill.frontmatter.license)
+        frontmatterLines.push(`license: ${skill.frontmatter.license}`);
+    if (skill.frontmatter.compatibility)
+        frontmatterLines.push(`compatibility: ${skill.frontmatter.compatibility}`);
+    if (skill.frontmatter.metadata) {
+        frontmatterLines.push("metadata:");
+        for (const [key, value] of Object.entries(skill.frontmatter.metadata)) {
+            frontmatterLines.push(`  ${key}: ${JSON.stringify(value)}`);
+        }
     }
-    catch {
-        return `Skill "${name}" not found`;
+    frontmatterLines.push("---");
+    const content = frontmatterLines.join("\n") + "\n\n" + skill.content;
+    writeFileSync(join(skillDir, "SKILL.md"), content);
+}
+function formatAgentContent(agent) {
+    const frontmatterLines = ["---"];
+    frontmatterLines.push(`description: ${JSON.stringify(agent.frontmatter.description)}`);
+    if (agent.frontmatter.mode)
+        frontmatterLines.push(`mode: ${agent.frontmatter.mode}`);
+    if (agent.frontmatter.tools) {
+        frontmatterLines.push("tools:");
+        for (const [toolName, enabled] of Object.entries(agent.frontmatter.tools)) {
+            if (enabled !== undefined)
+                frontmatterLines.push(`  ${toolName}: ${enabled}`);
+        }
+    }
+    frontmatterLines.push("---");
+    return frontmatterLines.join("\n") + "\n\n" + agent.prompt;
+}
+function formatSkillContent(skill) {
+    const frontmatterLines = ["---"];
+    frontmatterLines.push(`name: ${skill.frontmatter.name}`);
+    frontmatterLines.push(`description: ${JSON.stringify(skill.frontmatter.description)}`);
+    if (skill.frontmatter.license)
+        frontmatterLines.push(`license: ${skill.frontmatter.license}`);
+    if (skill.frontmatter.compatibility)
+        frontmatterLines.push(`compatibility: ${skill.frontmatter.compatibility}`);
+    if (skill.frontmatter.metadata) {
+        frontmatterLines.push("metadata:");
+        for (const [key, value] of Object.entries(skill.frontmatter.metadata)) {
+            frontmatterLines.push(`  ${key}: ${JSON.stringify(value)}`);
+        }
     }
+    frontmatterLines.push("---");
+    return frontmatterLines.join("\n") + "\n\n" + skill.content;
 }
 export const BMMPlugin = async () => {
-    const agents = listAgents();
-    const skills = listSkills();
     return {
         tool: {
             bmm_list: tool({
                 description: "List all available BMAD-METHOD agents and skills from bmm-opencode",
                 args: {},
                 async execute() {
+                    const { agents, skills } = await getConvertedResources();
+                    const source = hasBmadSource() ? "BMAD source (_bmad/)" : "bundled files (.opencode/)";
                     return `# BMM-OpenCode Resources
+Source: ${source}
 
 ## Agents (${agents.length})
-${agents.map((a) => `- ${a}`).join("\n")}
+${agents.map((a) => `- ${a.filename.replace(".md", "")}: ${a.frontmatter.description}`).join("\n")}
 
 ## Skills (${skills.length})
-${skills.map((s) => `- ${s}`).join("\n")}
+${skills.map((s) => `- ${s.name}: ${s.frontmatter.description}`).join("\n")}
 
 ## Usage
 - Use \`bmm_agent\` tool to get agent definition
 - Use \`bmm_skill\` tool to get skill instructions
-- Use \`bmm_install\` tool to copy agents/skills to your project`;
+- Use \`bmm_install\` with \`global=true\` to install globally (~/.config/opencode/)
+- Use \`bmm_install\` to install to current project (.opencode/)`;
                 },
             }),
             bmm_agent: tool({
                 description: "Get a BMAD-METHOD agent definition by name",
                 args: {
-                    name: tool.schema.string().describe(`Agent name`),
+                    name: tool.schema.string().describe("Agent name (e.g., bmm-dev, bmm-pm)"),
                 },
                 async execute(args) {
-                    return loadAgent(args.name);
+                    const { agents } = await getConvertedResources();
+                    const agent = agents.find((a) => a.filename === `${args.name}.md` ||
+                        a.filename.replace(".md", "") === args.name);
+                    if (!agent) {
+                        const available = agents.map((a) => a.filename.replace(".md", "")).join(", ");
+                        return `Agent "${args.name}" not found.\n\nAvailable agents: ${available}`;
+                    }
+                    return formatAgentContent(agent);
                 },
             }),
             bmm_skill: tool({
                 description: "Get a BMAD-METHOD skill instructions by name",
                 args: {
-                    name: tool.schema.string().describe(`Skill name`),
+                    name: tool.schema.string().describe("Skill name (e.g., bmad-bmm-create-prd)"),
                 },
                 async execute(args) {
-                    return loadSkill(args.name);
+                    const { skills } = await getConvertedResources();
+                    const skill = skills.find((s) => s.name === args.name || s.folder === args.name);
+                    if (!skill) {
+                        const available = skills.map((s) => s.name).join(", ");
+                        return `Skill "${args.name}" not found.\n\nAvailable skills: ${available}`;
+                    }
+                    return formatSkillContent(skill);
                 },
             }),
             bmm_install: tool({
-                description: "Install BMM agents and skills to your project's .opencode directory",
+                description: "Install BMM agents and skills. Use global=true for ~/.config/opencode/ (all projects), or omit for current project's .opencode/",
                 args: {
                     target: tool.schema
                         .string()
                         .optional()
-                        .describe("Target directory (defaults to current project)"),
+                        .describe("Target directory (defaults to current project's .opencode/)"),
+                    global: tool.schema
+                        .boolean()
+                        .optional()
+                        .describe("Install to global ~/.config/opencode/ instead of project"),
+                    force: tool.schema
+                        .boolean()
+                        .optional()
+                        .describe("Overwrite existing files without warning (default: false)"),
                 },
                 async execute(args, context) {
-                    const targetBase = args.target || join(context.directory, ".opencode");
+                    const globalConfigDir = join(homedir(), ".config", "opencode");
+                    const targetBase = args.global
+                        ? globalConfigDir
+                        : args.target || join(context.directory, ".opencode");
                     try {
                         const targetAgents = join(targetBase, "agents");
                         const targetSkills = join(targetBase, "skills");
-                        mkdirSync(targetAgents, { recursive: true });
-                        mkdirSync(targetSkills, { recursive: true });
+                        const agentsExist = existsSync(targetAgents) && readdirSync(targetAgents).length > 0;
+                        const skillsExist = existsSync(targetSkills) && readdirSync(targetSkills).length > 0;
+                        if ((agentsExist || skillsExist) && !args.force) {
+                            const existing = [];
+                            if (agentsExist)
+                                existing.push(`agents (${readdirSync(targetAgents).length} files)`);
+                            if (skillsExist)
+                                existing.push(`skills (${readdirSync(targetSkills).length} dirs)`);
+                            return `Existing installation detected at ${targetBase}:
+- ${existing.join("\n- ")}
+
+Use \`force=true\` to overwrite, or remove existing files first.`;
+                        }
+                        const { agents, skills } = await getConvertedResources();
                         let agentsCopied = 0;
                         for (const agent of agents) {
-                            const src = join(agentsDir, `${agent}.md`);
-                            const dest = join(targetAgents, `${agent}.md`);
-                            cpSync(src, dest);
+                            writeAgentFile(targetBase, agent);
                             agentsCopied++;
                         }
                         let skillsCopied = 0;
                         for (const skill of skills) {
-                            const src = join(skillsDir, skill);
-                            const dest = join(targetSkills, skill);
-                            cpSync(src, dest, { recursive: true });
+                            writeSkillFile(targetBase, skill);
                             skillsCopied++;
                         }
-                        return `Successfully installed BMM-OpenCode to ${targetBase}:
+                        const installType = args.global ? "globally" : "to project";
+                        const source = hasBmadSource() ? "converted from BMAD source" : "from bundled files";
+                        return `Successfully installed BMM-OpenCode ${installType} (${targetBase}):
 - ${agentsCopied} agents copied to ${targetAgents}
 - ${skillsCopied} skills copied to ${targetSkills}
 
+Source: ${source}
+
 Restart OpenCode to use the new agents and skills.`;
                     }
                     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmm-opencode",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "BMAD-METHOD agents and skills for OpenCode - AI agent framework with 17 specialized agents and 61 workflow skills",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,10 +32,12 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "test": "node --experimental-vm-modules --test tests/*.test.js",
+    "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.1.51"
+    "@opencode-ai/plugin": "^1.1.51",
+    "bmad-opencode-converter": "^1.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",