amazingteam 3.0.0

package/.opencode/commands/auto.md

@@ -0,0 +1,264 @@
+---
+description: Execute full automated workflow from issue to pull request
+agent: planner
+---
+Execute the complete automated workflow: Triage → (Decompose if needed) → Design → Implement → Test → Create PR.
+
+## Role
+
+You are the **Planner** coordinating this workflow. Your job is to **dispatch to appropriate roles**, not execute all steps yourself.
+
+## Workflow Decision Tree
+
+```
+                    ┌─────────────┐
+                    │   Triage    │
+                    │ (Classify)  │
+                    └──────┬──────┘
+                           │
+              ┌────────────┴────────────┐
+              ↓                         ↓
+        Simple Task              Complex Task
+              │                         │
+              │                         ▼
+              │               ┌──────────────────┐
+              │               │ Create Sub-Issues│
+              │               │    on GitHub     │
+              │               └────────┬─────────┘
+              │                        │
+              │                        ▼
+              │               ┌──────────────────┐
+              │               │ For each subtask │
+              │               │ (respect deps)   │
+              │               └────────┬─────────┘
+              │                        │
+              └────────────┬───────────┘
+                           ↓
+              ┌────────────────────────┐
+              │ Design → Implement →   │
+              │ Test → Create PR       │
+              └────────────┬───────────┘
+                           │
+                           ▼
+                   ┌─────────────┐
+                   │ Human Review│
+                   │   & Merge   │
+                   └─────────────┘
+```
+
+## Steps
+
+### Step 1: Triage (Dispatch to Triage agent)
+- Classify issue type (feature/bug/tech-task)
+- Determine if decomposition is needed
+- Return classification to Planner
+
+### Step 2: Decision Point
+
+**If NO decomposition needed:**
+- Proceed directly to Step 3
+
+**If decomposition needed:**
+1. **Create Sub-Issues on GitHub**
+   ```bash
+   gh issue create --title "[Subtask] Title" --body "..." --label "type:subtask"
+   ```
+2. **Record dependencies** in parent issue body and local task.yaml
+3. **Execute subtasks one by one** (respecting dependencies)
+4. **Post comment** on parent issue listing all sub-issues
+
+### Step 3: Design (Dispatch to Architect agent)
+- Create implementation plan
+- Identify affected modules
+- Document design decisions
+
+### Step 4: Implementation (Dispatch to Developer agent)
+- Create branch: `feat/issue-{id}-{description}`
+- Implement changes
+- Write/update tests
+- Run linters
+
+### Step 5: Validation (Dispatch to QA agent)
+- Run test suite
+- Verify acceptance criteria
+- Document validation results
+
+### Step 6: PR Creation (Dispatch to Developer agent)
+- Create Pull Request
+- Link to original issue (or sub-issue)
+- STOP - wait for human review
+
+## GitHub Sub-Issue Creation
+
+When decomposition is needed, create sub-issues:
+
+```bash
+# Configure git identity
+git config user.name "opencode-bot"
+git config user.email "opencode-bot@users.noreply.github.com"
+
+# Create sub-issue
+gh issue create \
+  --title "[Subtask] Implement authentication API" \
+  --body "Parent Issue: #120
+Dependencies: None
+Owner Role: developer
+
+Scope:
+- Implement login endpoint
+- Add token validation
+
+Acceptance Criteria:
+- [ ] POST /auth/login works
+- [ ] Returns valid JWT token" \
+  --label "type:subtask,role:developer"
+```
+
+## Dependency Handling
+
+For subtasks with dependencies:
+
+```yaml
+# In parent task.yaml
+subtasks:
+  - id: issue-120-subtask-01
+    github_issue: 201
+    title: "[Subtask] Design auth API"
+    owner_role: architect
+    status: done
+    depends_on: []
+    
+  - id: issue-120-subtask-02
+    github_issue: 202
+    title: "[Subtask] Implement auth API"
+    owner_role: developer
+    status: pending
+    depends_on: [201]  # Wait for #201 to complete
+```
+
+**Execution order:**
+1. Execute #201 first (no dependencies)
+2. After #201's PR is merged, execute #202
+3. Continue until all subtasks done
+4. Close parent issue
+
+## Output
+
+Post a summary comment:
+
+**For simple task:**
+```
+## Workflow Complete
+
+- **Classification**: feature (no decomposition)
+- **Pull Request**: #123
+
+Ready for human review and merge.
+```
+
+**For complex task:**
+```
+## Decomposition Complete
+
+- **Parent Issue**: #120
+- **Sub-issues created**: 3
+
+| Sub-issue | Role | Status | Depends on |
+|-----------|------|--------|------------|
+| #201 | architect | ready | - |
+| #202 | developer | blocked | #201 |
+| #203 | qa | blocked | #202 |
+
+Starting with #201 (Design phase)...
+
+---
+
+## Sub-issue #201 PR Created
+
+- **Pull Request**: #204
+- Ready for human review and merge.
+
+After merge, run `/dispatch-next` to continue with #202.
+```
+
+## Blocker Handling
+
+When a blocker is encountered during workflow:
+
+### Step 1: Pause and Diagnose
+
+```
+## ⚠️ Workflow Blocked
+
+- **Phase**: Implementation
+- **Error**: {error_message}
+
+Dispatching to CI Analyst for diagnosis...
+```
+
+### Step 2: CI Analyst Diagnosis
+
+Dispatch to CI Analyst who determines:
+
+| Resolution | Action |
+|------------|--------|
+| Auto-fix now | Fix immediately, continue |
+| Create sub-issue (AI) | Create blocker sub-issue, resolve, resume |
+| Create sub-issue (Human) | Create blocker sub-issue, notify human, wait |
+
+### Step 3: Resolution Paths
+
+**Path A: Auto-fix**
+```markdown
+## Blocker Auto-Resolved
+
+- **Issue**: {description}
+- **Fix Applied**: {fix_description}
+- **Status**: Continuing workflow...
+```
+
+**Path B: Sub-issue (AI Resolve)**
+```markdown
+## Blocker Sub-issue Created
+
+- **Blocker Issue**: #205 - [Blocker] {title}
+- **Type**: {type}
+- **Resolution**: AI will resolve
+- **Status**: Resolving blocker...
+
+---
+
+## Blocker Resolved
+
+- **Blocker**: #205 ✅
+- **Resume**: Continuing original workflow...
+```
+
+**Path C: Human Required**
+```markdown
+## ⚠️ Workflow Blocked - Human Attention Required
+
+- **Blocker Issue**: #206 - [Blocker] {title}
+- **Reason**: {why human is needed}
+
+### Required Actions
+1. {action_1}
+2. {action_2}
+
+### To Resume
+After resolving the blocker, comment:
+```
+/oc /resume
+```
+
+*Workflow is paused, waiting for human input.*
+```
+
+## Important
+
+- **Planner coordinates, does not implement**
+- **Create GitHub sub-issues** when decomposition is needed
+- **Handle blockers gracefully** - diagnose, resolve or escalate
+- **Respect dependencies** - don't start a subtask until its dependencies are merged
+- **AI does NOT merge PRs** - humans review and merge
+- **All changes go through PR** - never direct commits to main

package/.opencode/commands/breakdown-issue.md

@@ -0,0 +1,94 @@
+---
+description: Decompose a large issue into GitHub sub-issues with dependencies
+agent: planner
+---
+Decompose this issue into explicit GitHub sub-issues following the GitHub Issue-based Planner orchestration model.
+
+## Steps
+
+### 1. Analyze the Issue
+
+Read the issue and answer:
+- What is the core problem?
+- Which modules are affected?
+- Is this a single bounded change or multiple related changes?
+- Are there dependencies between potential subtasks?
+
+### 2. Determine Decomposition Need
+
+**Decomposition Required if:**
+- Touches multiple modules
+- Requires design before implementation
+- Impacts public interfaces
+- Changes data model, API contract, or protocol
+- Likely needs multiple PRs
+- Contains several distinct implementation steps
+- Requires staged validation
+
+**No Decomposition if:**
+- Single module change
+- Clear, bounded scope
+- One PR likely sufficient
+
+### 3. Define Subtasks
+
+For each subtask, specify:
+- Title (prefixed with "[Subtask]")
+- Type: analysis | design | implementation | validation | review | ci-fix
+- Owner role: architect | developer | qa | reviewer | triage | ci-analyst
+- Dependencies (other subtask IDs)
+- Acceptance criteria
+- Module scope
+- Risk level
+
+### 4. Create GitHub Issues
+
+Use `gh issue create` for each subtask with:
+- Parent issue reference
+- Dependency references
+- Owner role
+- Clear scope and acceptance criteria
+- Labels: type:subtask, role:{owner_role}
+
+### 5. Create Local Task Records
+
+Create `tasks/issue-{N}-subtask-{M}/task.yaml` for each subtask with:
+- GitHub issue number
+- Parent reference
+- Dependencies
+- Status
+
+### 6. Update Parent Issue
+
+Add to parent issue body:
+- Decomposition status
+- List of child issues
+- Dependency graph
+- Completion rule
+
+## Output Format
+
+```
+Decomposition required: yes/no
+
+Reason:
+- [reasons]
+
+Subtasks:
+1. issue-{N}-subtask-01 — [title] (role: X, depends on: [])
+2. issue-{N}-subtask-02 — [title] (role: Y, depends on: [subtask-01])
+...
+
+Dependencies:
+- subtask-02 depends on subtask-01
+...
+
+GitHub Issues Created:
+- #XXX: [Subtask] Title 1
+- #YYY: [Subtask] Title 2
+
+Next active subtask: issue-{N}-subtask-01
+Next role: [architect|developer|...]
+```
+
+Use the `task-breakdown-and-dispatch` skill for detailed guidance.

package/.opencode/commands/ci-analyze.md

@@ -0,0 +1,15 @@
+---
+description: Investigate CI failure and find root cause
+agent: ci-analyst
+---
+Investigate the CI failure and find the root cause.
+
+## Steps
+
+1. Identify failure type from CI logs
+2. Analyze error messages and stack traces
+3. Find root cause
+4. Suggest fix approach
+5. Document findings
+
+Use the `ci-failure-analysis` skill for systematic debugging.

package/.opencode/commands/close-parent-task.md

@@ -0,0 +1,122 @@
+---
+description: Verify completion conditions and close parent issue
+agent: planner
+---
+Verify that all subtasks are complete and the parent issue can be closed.
+
+## Steps
+
+### 1. Read Parent Task Manifest
+
+Check `tasks/issue-{N}/task.yaml` for:
+- Overall acceptance criteria
+- List of all subtasks
+- Overall status
+
+### 2. Verify All Subtasks Complete
+
+For each subtask:
+- Check `status: done` in task.yaml
+- Verify GitHub issue is closed
+- Check linked PR is merged (if applicable)
+
+```bash
+gh issue view {subtask-issue} --json state
+gh pr view {pr-number} --json state,mergedAt
+```
+
+### 3. Verify Acceptance Criteria
+
+For each criterion in `overall_acceptance_criteria`:
+- Is there evidence of completion?
+- Are there tests covering this?
+- Is documentation updated?
+
+### 4. Check for Unresolved Blockers
+
+- No open blocking issues
+- No failing CI
+- No pending reviews
+
+### 5. Close GitHub Issue
+
+If all conditions met:
+```bash
+gh issue close {parent-issue} --comment "All subtasks completed. Closing parent issue."
+```
+
+### 6. Update Task Records
+
+Update `task.yaml`:
+```yaml
+status: done
+closed_at: YYYY-MM-DD
+completion_summary: |
+  All subtasks completed successfully.
+  - Subtask 01: done
+  - Subtask 02: done
+  ...
+```
+
+## Completion Checklist
+
+- [ ] All subtasks have status: done
+- [ ] All GitHub sub-issues are closed
+- [ ] All linked PRs are merged
+- [ ] Overall acceptance criteria satisfied
+- [ ] No unresolved blockers
+- [ ] Validation coverage complete
+- [ ] Documentation updated (if required)
+
+## Output Format
+
+### Success
+
+```
+Parent Issue Close Verification
+================================
+
+Parent: issue-{N} - {title}
+GitHub: #{issue-number}
+
+Subtask Status:
+✓ issue-{N}-subtask-01: done (GitHub: #201 closed, PR #250 merged)
+✓ issue-{N}-subtask-02: done (GitHub: #202 closed, PR #251 merged)
+✓ issue-{N}-subtask-03: done (GitHub: #203 closed, PR #252 merged)
+
+Acceptance Criteria:
+✓ Criterion 1: Verified by tests
+✓ Criterion 2: Documented in design.md
+✓ Criterion 3: PR #250 includes changes
+
+Unresolved Blockers: None
+
+Result: READY TO CLOSE
+Action: gh issue close {issue-number} --comment "All subtasks completed."
+```
+
+### Not Ready
+
+```
+Parent Issue Close Verification
+================================
+
+Parent: issue-{N} - {title}
+GitHub: #{issue-number}
+
+Subtask Status:
+✓ issue-{N}-subtask-01: done
+✗ issue-{N}-subtask-02: in_progress (PR #251 pending review)
+○ issue-{N}-subtask-03: pending (depends on subtask-02)
+
+Incomplete Items:
+- Subtask 02 needs review approval
+- Subtask 03 not started
+
+Unresolved Blockers:
+- PR #251 awaiting review
+
+Result: NOT READY TO CLOSE
+Reason: 2 subtasks incomplete
+Next Action: /dispatch-next to continue subtask 02
+```

package/.opencode/commands/design.md

@@ -0,0 +1,15 @@
+---
+description: Analyze requirements and create design document
+agent: architect
+---
+Analyze the requirements for this task and create a comprehensive design document.
+
+## Steps
+
+1. Read and understand the requirements
+2. Analyze existing codebase architecture
+3. Identify affected components
+4. Propose solution design
+5. Document implementation approach
+
+Use the `repo-architecture-reader` skill to understand the codebase structure.

package/.opencode/commands/dispatch-next.md

@@ -0,0 +1,102 @@
+---
+description: Identify and dispatch the next active subtask to the appropriate role
+agent: planner
+---
+Identify the next active subtask and dispatch to the appropriate role.
+
+## Steps
+
+### 1. Review Parent Task State
+
+Read `tasks/issue-{N}/task.yaml` to understand:
+- Current status of all subtasks
+- Dependency graph
+- Blocked items
+
+### 2. Check GitHub Issue Status
+
+For each pending subtask:
+```bash
+gh issue view {subtask-issue-number}
+```
+
+Check:
+- Is the issue open or closed?
+- Are there linked PRs?
+- Any comments indicating blockers?
+
+### 3. Identify Ready Subtasks
+
+A subtask is ready when:
+- All dependencies are completed
+- No active blockers
+- Acceptance criteria are clear
+- Owner role is assigned
+
+### 4. Determine Active Subtask
+
+Select the subtask that:
+- Has highest priority among ready tasks
+- Follows dependency order
+- Has clear next action
+
+### 5. Dispatch to Role
+
+Assign to the correct role based on subtask type:
+
+| Type | Role |
+|------|------|
+| analysis | architect |
+| design | architect |
+| implementation | developer |
+| validation | qa |
+| review | reviewer |
+| ci-fix | ci-analyst |
+| triage | triage |
+
+### 6. Update Task Records
+
+Update `task.yaml` with:
+- New status
+- Dispatch timestamp
+- Dispatch notes
+
+## Output Format
+
+```
+Parent Task: issue-{N} - {title}
+Overall Status: in_implementation
+
+Subtask Progress:
+✓ issue-{N}-subtask-01: done (architect)
+✓ issue-{N}-subtask-02: done (developer)
+● issue-{N}-subtask-03: ready (next active)
+○ issue-{N}-subtask-04: pending (depends on subtask-03)
+
+Next Active Subtask: issue-{N}-subtask-03
+GitHub Issue: #{issue-number}
+Title: [Subtask] {title}
+Owner Role: {role}
+Reason: Dependencies satisfied, ready for implementation
+
+Dispatch Command:
+/implement --subtask issue-{N}-subtask-03
+```
+
+## Blocked Handling
+
+If all subtasks are blocked:
+
+```
+All subtasks blocked:
+
+Subtask: issue-{N}-subtask-02
+Status: blocked
+Blocker: CI failure in subtask-01 PR
+Required Action: CI fix needed
+
+Recommendation: Dispatch to ci-analyst
+Command: /ci-analyze --issue {subtask-01-issue}
+```
+
+Use the `task-breakdown-and-dispatch` skill for detailed guidance.

package/.opencode/commands/implement.md

@@ -0,0 +1,16 @@
+---
+description: Implement features or fixes according to design plan
+agent: developer
+---
+Implement the solution according to the design plan.
+
+## Steps
+
+1. Read the design document from `tasks/{task_id}/design.md`
+2. Create a feature branch
+3. Implement changes incrementally
+4. Write/update tests
+5. Run linters and tests
+6. Create a pull request
+
+Follow the architecture plan and make minimal, focused changes.

package/.opencode/commands/release-check.md

@@ -0,0 +1,16 @@
+---
+description: Validate release readiness
+agent: reviewer
+---
+Validate that the project is ready for release.
+
+## Checklist
+
+- [ ] All tests pass
+- [ ] No security vulnerabilities
+- [ ] Code coverage threshold met
+- [ ] Documentation updated
+- [ ] CHANGELOG.md updated
+- [ ] Version bumped
+
+Use the `release-readiness-check` skill for comprehensive validation.