@comfanion/workflow 3.0.0

package/src/opencode/commands/clarify.md

@@ -0,0 +1,132 @@
+---
+description: Structured clarification of requirements before creating PRD/Architecture
+agent: requirements-analyst
+---
+
+# Clarify Command
+
+## Purpose
+
+Run **before** `/prd` or `/architecture` to reduce rework. Asks structured questions to uncover gaps, ambiguities, and missing details in requirements.
+
+## Arguments
+$ARGUMENTS
+
+- Empty: Clarify requirements.md
+- "[topic]": Focus clarification on specific topic
+- "all": Comprehensive clarification
+
+## Prerequisites
+
+!`ls -la docs/requirements/requirements.md 2>/dev/null && echo "EXISTS" || echo "MISSING"`
+
+If requirements.md doesn't exist:
+→ "Run `/requirements` first to gather requirements."
+
+## Load Requirements
+
+@docs/requirements/requirements.md
+
+## Clarification Process
+
+### 1. Scan for Ambiguities
+
+Look for:
+- Vague terms ("should", "might", "could", "etc.")
+- Missing quantities ("fast", "many", "several")
+- Undefined actors ("users", "admins" - who exactly?)
+- Missing edge cases
+- Unclear priorities
+- Undefined terms
+
+### 2. Generate Structured Questions
+
+Organize questions by category:
+
+```markdown
+## Clarification Questions
+
+### Functional Gaps
+
+1. **FR-003: User Authentication**
+   - Q: What happens if login fails 3 times?
+   - Q: Is there a password reset flow?
+   - Q: What are the password requirements?
+
+2. **FR-007: Data Export**
+   - Q: What formats are required (CSV, JSON, Excel)?
+   - Q: Is there a size limit?
+
+### Non-Functional Gaps
+
+1. **NFR-001: Performance**
+   - Q: "Fast response" - what is acceptable latency? (p50, p95, p99)
+   - Q: Under what load conditions?
+
+2. **NFR-003: Availability**
+   - Q: "High availability" - what is the target uptime? (99%, 99.9%, 99.99%)
+
+### Edge Cases
+
+1. What happens when [edge case]?
+2. How should the system handle [error condition]?
+
+### User Clarifications
+
+1. "Users" - Is this end-users, admins, or both?
+2. What are the user personas?
+
+### Scope Clarifications
+
+1. Is [feature] in scope for MVP?
+2. What is explicitly out of scope?
+```
+
+### 3. Conduct Q&A Session
+
+For each question:
+1. Ask the user
+2. Record the answer
+3. Update requirements.md with clarification
+
+### 4. Document Clarifications
+
+Add a Clarifications section to requirements.md:
+
+```markdown
+## Clarifications
+
+### Session: YYYY-MM-DD
+
+**Q1: What happens if login fails 3 times?**
+A: Account is locked for 15 minutes. User receives email notification.
+→ Added to FR-003 acceptance criteria.
+
+**Q2: What is acceptable response latency?**
+A: < 200ms p95 for API calls, < 2s for page loads.
+→ Updated NFR-001 with specific metrics.
+```
+
+## Output
+
+After clarification:
+1. Updated requirements.md with answers
+2. Clarifications section added
+3. Ambiguous terms resolved
+4. Missing acceptance criteria added
+
+## Validation
+
+After clarification, verify:
+- [ ] No vague language remains
+- [ ] All quantities are specified
+- [ ] Edge cases documented
+- [ ] Actors clearly defined
+- [ ] Priorities assigned
+- [ ] Scope boundaries clear
+
+## After Clarification
+
+Suggest:
+- `/validate requirements` - Validate completeness
+- `/prd` - Create PRD with clarified requirements

package/src/opencode/commands/code-review.md

@@ -0,0 +1,96 @@
+# /code-review Command
+
+Review implemented code for quality, correctness, and adherence to standards.
+
+## Usage
+
+```
+/code-review [story-path]
+```
+
+## Arguments
+
+- `story-path` (optional): Path to story file to review. If not provided, finds stories in `review` status.
+
+## Agent
+
+This command invokes the **Dev** agent (Amelia) in review mode.
+
+## Process
+
+1. Load story file and implementation
+2. Check all acceptance criteria are met
+3. Review code quality:
+   - Follows CLAUDE.md patterns
+   - Proper error handling
+   - Appropriate test coverage
+   - No security issues
+   - Clean code principles
+4. Check tests:
+   - All tests pass
+   - Sufficient coverage
+   - Edge cases covered
+5. Document findings in story file
+6. Provide review outcome:
+   - ✅ **Approve** - Ready to merge
+   - 🔄 **Changes Requested** - Needs fixes
+   - ❌ **Blocked** - Major issues found
+
+## Skills Loaded
+
+- `code-review` - Review checklist and process
+
+## Output
+
+Updates story file with:
+- `Senior Developer Review (AI)` section
+- Review outcome
+- Action items (if any)
+- `Review Follow-ups (AI)` tasks (if changes requested)
+
+## Review Checklist
+
+### Functionality
+- [ ] All acceptance criteria satisfied
+- [ ] Edge cases handled
+- [ ] Error handling is appropriate
+
+### Code Quality
+- [ ] Follows CLAUDE.md patterns
+- [ ] No code duplication
+- [ ] Clear naming conventions
+- [ ] Appropriate comments
+
+### Testing
+- [ ] Unit tests for all new code
+- [ ] Integration tests where needed
+- [ ] All tests pass
+- [ ] Good test coverage
+
+### Security
+- [ ] No hardcoded secrets
+- [ ] Input validation present
+- [ ] No SQL injection risks
+- [ ] Proper authentication/authorization
+
+## Example
+
+```bash
+# Review stories in 'review' status
+/code-review
+
+# Review specific story
+/code-review docs/sprint-artifacts/sprint-1/stories/1-1-user-auth.md
+```
+
+## After Review
+
+- If **Approved**: Mark story as `done`
+- If **Changes Requested**: 
+  1. Review follow-up tasks added to story
+  2. Run `/dev-story` to address issues
+  3. Run `/code-review` again
+
+## Best Practice
+
+> **Tip:** For best results, run code-review using a **different** LLM than the one that implemented the story.

package/src/opencode/commands/coding-standards.md

@@ -0,0 +1,102 @@
+---
+description: Create or update coding standards documentation (modular, multiple files)
+agent: coding-standards
+---
+
+# Coding Standards Creation
+
+## Arguments
+$ARGUMENTS
+
+- "create" or empty: Create new standards from scratch
+- "edit": Edit existing standards
+- "add [topic]": Add new standards file for specific topic
+- "validate": Check standards completeness
+
+## Prerequisites
+
+Check existing standards:
+!`ls -la docs/coding-standards/ 2>/dev/null || echo "No standards yet"`
+
+Check tech stack (if code exists):
+!`ls -la src/ 2>/dev/null | head -5 || echo "No src directory"`
+
+## Input Context
+
+Load if exists:
+- @docs/requirements/requirements.md (for NFRs)
+- @docs/prd.md (for tech decisions)
+- @AGENTS.md (current rules)
+
+## Your Task
+
+### Create Mode
+
+1. **Discover tech stack**:
+   - Ask user about languages (Go, TypeScript, Python, etc.)
+   - Ask about frameworks
+   - Ask about infrastructure (DB, queues, etc.)
+
+2. **Create modular documentation** in `docs/coding-standards/`:
+   - **README.md** - Index and critical rules
+   - **project-structure.md** - Directory layout
+   - **[language]-standards.md** - Per language (go-standards.md, etc.)
+   - **architecture-patterns.md** - Required patterns
+   - **testing-standards.md** - Test requirements
+   - **api-standards.md** - API conventions (if applicable)
+   - **database-standards.md** - DB standards (if applicable)
+   - **security-standards.md** - Security rules
+   - **libraries.md** - Approved/forbidden deps
+   - **git-workflow.md** - Git conventions
+
+3. **Each file MUST be < 2000 lines**
+
+4. **Generate linter configs**:
+   - `.golangci.yml` for Go
+   - `.eslintrc.js` for TypeScript/JavaScript
+   - `.editorconfig` for all
+
+### Edit Mode
+
+1. Ask which file to edit
+2. Load and review current content
+3. Make targeted updates
+4. Ensure consistency across files
+
+### Add Topic Mode
+
+1. Determine appropriate file name
+2. Create new standards file
+3. Update README.md index
+
+## Output Structure
+
+```
+docs/coding-standards/
+├── README.md                    # Index (<500 lines)
+├── project-structure.md         
+├── go-standards.md              # (or other language)
+├── architecture-patterns.md     
+├── testing-standards.md         
+├── api-standards.md             
+├── database-standards.md        
+├── security-standards.md        
+├── libraries.md                 
+└── git-workflow.md              
+```
+
+## Validation
+
+After creating, verify:
+- [ ] README.md exists with complete index
+- [ ] All files < 2000 lines: `wc -l docs/coding-standards/*.md`
+- [ ] Each language has standards file
+- [ ] No contradictions between files
+- [ ] Examples provided for complex rules
+
+## After Completion
+
+Suggest:
+- Update AGENTS.md with critical rules
+- Run `/validate coding-standards`
+- Continue with `/prd` if not done

package/src/opencode/commands/dev-story.md

@@ -0,0 +1,80 @@
+# /dev-story Command
+
+Implement a story using red-green-refactor cycle.
+
+## Usage
+
+```
+/dev-story [story-path]
+```
+
+## Arguments
+
+- `story-path` (optional): Path to specific story file. If not provided, finds next `ready-for-dev` story from sprint-status.yaml.
+
+## Agent
+
+This command invokes the **Dev** agent (Amelia).
+
+## Process
+
+1. Find or load story file
+2. Load project context (CLAUDE.md, project-context.md)
+3. Mark story as `in-progress`
+4. For each task/subtask:
+   - 🔴 RED: Write failing test
+   - 🟢 GREEN: Implement minimal code to pass
+   - 🔵 REFACTOR: Improve while keeping tests green
+5. Mark task complete `[x]` only when tests pass
+6. Update story file (File List, Change Log, Dev Agent Record)
+7. Mark story as `review` when all tasks complete
+
+## Workflow
+
+Executes: `workflows/dev-story/instructions.md`
+
+## Skills Loaded
+
+- `dev-story` - Implementation workflow
+- `test-design` - Test writing patterns
+
+## Output
+
+- Implementation code
+- Unit tests
+- Integration tests
+- Updated story file with:
+  - Tasks marked `[x]`
+  - File List
+  - Change Log
+  - Dev Agent Record
+
+## HALT Conditions
+
+The workflow will HALT and ask for input when:
+- Additional dependencies need approval
+- 3 consecutive implementation failures
+- Required configuration is missing
+- Ambiguous requirements need clarification
+
+## Example
+
+```bash
+# Find next ready story automatically
+/dev-story
+
+# Implement specific story
+/dev-story docs/sprint-artifacts/sprint-1/stories/1-1-user-auth.md
+```
+
+## Story Status Flow
+
+```
+ready-for-dev → in-progress → review → done
+```
+
+## Next Steps After Completion
+
+1. `/code-review` - Review the implementation
+2. If approved, mark story as `done`
+3. Continue with next story

package/src/opencode/commands/diagram.md

@@ -0,0 +1,152 @@
+---
+description: Create technical diagrams (C4, sequence, ER, flowcharts) in Mermaid format
+agent: diagram-creator
+---
+
+# Diagram Creation
+
+## Arguments
+$ARGUMENTS
+
+Format: `[scope] [type]`
+
+**Scope:**
+- "system" - System-wide diagram
+- "[module-name]" - Module-specific diagram
+
+**Type:**
+- "c4-context" - C4 Level 1: System context
+- "c4-container" - C4 Level 2: Containers/services
+- "c4-component" - C4 Level 3: Module components
+- "sequence [flow-name]" - Sequence diagram for a flow
+- "erd" - Entity relationship diagram
+- "flow [process-name]" - Flowchart
+- "state [entity-name]" - State machine
+
+**Examples:**
+- `/diagram system c4-context`
+- `/diagram catalog c4-component`
+- `/diagram catalog sequence product-import`
+- `/diagram catalog erd`
+- `/diagram order flow checkout-process`
+- `/diagram offer state lifecycle`
+
+## Check Existing Diagrams
+
+!`ls -la docs/diagrams/ 2>/dev/null || echo "No diagrams yet"`
+!`ls docs/diagrams/*/ 2>/dev/null || echo ""`
+
+## Input Context
+
+Load based on scope:
+- @docs/architecture.md (always)
+- @docs/modules/[scope]/architecture.md (if module-specific)
+- @docs/modules/[scope]/data-model.md (for ERD)
+
+## Diagram Storage
+
+All diagrams go to `docs/diagrams/`:
+
+```
+docs/diagrams/
+├── README.md                    # Diagram index
+├── c4/
+│   ├── system-context.md        # L1
+│   ├── containers.md            # L2
+│   └── [module]-components.md   # L3 per module
+├── sequences/
+│   └── [flow-name].md
+├── data/
+│   ├── erd-overview.md
+│   └── [module]-erd.md
+├── flows/
+│   └── [process-name].md
+└── states/
+    └── [entity]-states.md
+```
+
+## Your Task
+
+1. **Determine diagram type** from arguments
+2. **Load relevant context** (architecture, module docs)
+3. **Create Mermaid diagram** in appropriate file
+4. **Update index** in `docs/diagrams/README.md`
+
+## Diagram Format
+
+Each diagram file:
+
+```markdown
+# [Diagram Title]
+
+## Context
+
+[When/why this diagram is useful]
+
+## Diagram
+
+\`\`\`mermaid
+[mermaid code]
+\`\`\`
+
+## Elements
+
+| Element | Type | Description |
+|---------|------|-------------|
+
+## Notes
+
+[Additional context, decisions]
+
+## Related
+
+- [Link to related diagram]
+- [Link to architecture section]
+```
+
+## Index Update
+
+After creating diagram, update `docs/diagrams/README.md`:
+
+```markdown
+# Diagrams Index
+
+## C4 Architecture
+
+| Diagram | Level | Scope | Description |
+|---------|-------|-------|-------------|
+| [System Context](./c4/system-context.md) | L1 | System | Overview |
+
+## Sequences
+
+| Diagram | Module | Flow |
+|---------|--------|------|
+
+## Data Models
+
+| Diagram | Scope |
+|---------|-------|
+
+## Process Flows
+
+| Diagram | Process |
+|---------|---------|
+
+## State Machines
+
+| Diagram | Entity |
+|---------|--------|
+```
+
+## Validation
+
+- [ ] Mermaid syntax is valid
+- [ ] Elements match architecture docs
+- [ ] Index is updated
+- [ ] Cross-references added
+
+## Tips
+
+- Keep diagrams focused (one concept per diagram)
+- Use consistent naming across diagrams
+- Link diagrams to relevant documentation sections

package/src/opencode/commands/epics.md

@@ -0,0 +1,52 @@
+---
+description: Create epics from PRD and Architecture
+agent: sm
+model: anthropic/claude-sonnet-4-20250514
+---
+
+# Epic Creation
+
+## Prerequisites
+
+**Required:**
+- @docs/prd.md - For requirements coverage
+- @docs/architecture.md - For module structure
+
+**Check:**
+!`ls -la docs/prd.md docs/architecture.md 2>/dev/null || echo "Missing PRD or Architecture"`
+
+## Task
+
+1. Load skill: `epic-writing`
+2. Analyze PRD functional requirements
+3. Review architecture module boundaries
+4. Create epics that:
+   - Cover all FRs from PRD
+   - Align with architecture modules
+   - Have clear dependencies
+   - Are sized for 1-2 weeks
+5. Load skill: `acceptance-criteria` for epic AC
+6. **Ensure every epic has AC (MANDATORY)**
+7. Save epics to sprint artifacts
+
+## Epic Creation Checklist
+
+For each epic:
+- [ ] Unique ID: `[MODULE]-E[NN]`
+- [ ] Clear responsibility
+- [ ] PRD coverage documented
+- [ ] Architecture references
+- [ ] Dependencies identified
+- [ ] **Acceptance criteria defined**
+- [ ] Branch name specified
+
+## Output
+
+Save to: `docs/sprint-artifacts/backlog/epic-NN-module-description.md`
+
+Or if assigning to sprint:
+`docs/sprint-artifacts/sprint-N/epic-NN-module-description.md`
+
+## Next Step
+
+After epics created, suggest: `/stories [epic-id]` for each epic