sdlc-subagents 0.1.1 → 0.1.2

package/commands/commit.md

@@ -0,0 +1,7 @@
+Create a new commit for all of our uncommitted changes
+run git status && git diff HEAD && git status --porcelain to see what files are uncommitted
+add the untracked and changed files
+
+Add an atomic commit message with an appropriate message
+
+add a tag such as "feat", "fix", "docs", etc. that reflects our work

package/commands/create-prd.md

@@ -0,0 +1,151 @@
+---
+description: Create a Product Requirements Document from conversation
+argument-hint: [output-filename]
+---
+
+# Create PRD: Generate Product Requirements Document
+
+## Overview
+
+Generate a comprehensive Product Requirements Document (PRD) based on the current conversation context and requirements discussed. Use the structure and sections defined below to create a thorough, professional PRD.
+
+## Output File
+
+Write the PRD to: `$ARGUMENTS` (default: `PRD.md`)
+
+## PRD Structure
+
+Create a well-structured PRD with the following sections. Adapt depth and detail based on available information:
+
+### Required Sections
+
+**1. Executive Summary**
+- Concise product overview (2-3 paragraphs)
+- Core value proposition
+- MVP goal statement
+
+**2. Mission**
+- Product mission statement
+- Core principles (3-5 key principles)
+
+**3. Target Users**
+- Primary user personas
+- Technical comfort level
+- Key user needs and pain points
+
+**4. MVP Scope**
+- **In Scope:** Core functionality for MVP (use ✅ checkboxes)
+- **Out of Scope:** Features deferred to future phases (use ❌ checkboxes)
+- Group by categories (Core Functionality, Technical, Integration, Deployment)
+
+**5. User Stories**
+- Primary user stories (5-8 stories) in format: "As a [user], I want to [action], so that [benefit]"
+- Include concrete examples for each story
+- Add technical user stories if relevant
+
+**6. Core Architecture & Patterns**
+- High-level architecture approach
+- Directory structure (if applicable)
+- Key design patterns and principles
+- Technology-specific patterns
+
+**7. Tools/Features**
+- Detailed feature specifications
+- If building an agent: Tool designs with purpose, operations, and key features
+- If building an app: Core feature breakdown
+
+**8. Technology Stack**
+- Backend/Frontend technologies with versions
+- Dependencies and libraries
+- Optional dependencies
+- Third-party integrations
+
+**9. Security & Configuration**
+- Authentication/authorization approach
+- Configuration management (environment variables, settings)
+- Security scope (in-scope and out-of-scope)
+- Deployment considerations
+
+**10. API Specification** (if applicable)
+- Endpoint definitions
+- Request/response formats
+- Authentication requirements
+- Example payloads
+
+**11. Success Criteria**
+- MVP success definition
+- Functional requirements (use ✅ checkboxes)
+- Quality indicators
+- User experience goals
+
+**12. Implementation Phases**
+- Break down into 3-4 phases
+- Each phase includes: Goal, Deliverables (✅ checkboxes), Validation criteria
+- Realistic timeline estimates
+
+**13. Future Considerations**
+- Post-MVP enhancements
+- Integration opportunities
+- Advanced features for later phases
+
+**14. Risks & Mitigations**
+- 3-5 key risks with specific mitigation strategies
+
+**15. Appendix** (if applicable)
+- Related documents
+- Key dependencies with links
+- Repository/project structure
+
+## Instructions
+
+### 1. Extract Requirements
+- Review the entire conversation history
+- Identify explicit requirements and implicit needs
+- Note technical constraints and preferences
+- Capture user goals and success criteria
+
+### 2. Synthesize Information
+- Organize requirements into appropriate sections
+- Fill in reasonable assumptions where details are missing
+- Maintain consistency across sections
+- Ensure technical feasibility
+
+### 3. Write the PRD
+- Use clear, professional language
+- Include concrete examples and specifics
+- Use markdown formatting (headings, lists, code blocks, checkboxes)
+- Add code snippets for technical sections where helpful
+- Keep Executive Summary concise but comprehensive
+
+### 4. Quality Checks
+- ✅ All required sections present
+- ✅ User stories have clear benefits
+- ✅ MVP scope is realistic and well-defined
+- ✅ Technology choices are justified
+- ✅ Implementation phases are actionable
+- ✅ Success criteria are measurable
+- ✅ Consistent terminology throughout
+
+## Style Guidelines
+
+- **Tone:** Professional, clear, action-oriented
+- **Format:** Use markdown extensively (headings, lists, code blocks, tables)
+- **Checkboxes:** Use ✅ for in-scope items, ❌ for out-of-scope
+- **Specificity:** Prefer concrete examples over abstract descriptions
+- **Length:** Comprehensive but scannable (typically 30-60 sections worth of content)
+
+## Output Confirmation
+
+After creating the PRD:
+1. Confirm the file path where it was written
+2. Provide a brief summary of the PRD contents
+3. Highlight any assumptions made due to missing information
+4. Suggest next steps (e.g., review, refinement, planning)
+
+## Notes
+
+- If critical information is missing, ask clarifying questions before generating
+- Adapt section depth based on available details
+- For highly technical products, emphasize architecture and technical stack
+- For user-facing products, emphasize user stories and experience
+- This command contains the complete PRD template structure - no external references needed

package/commands/create-rules.md

@@ -0,0 +1,156 @@
+---
+description: Create global rules (CLAUDE.md) from codebase analysis
+---
+
+# Create Global Rules
+
+Generate a CLAUDE.md file by analyzing the codebase and extracting patterns.
+
+---
+
+## Objective
+
+Create project-specific global rules that give Claude context about:
+- What this project is
+- Technologies used
+- How the code is organized
+- Patterns and conventions to follow
+- How to build, test, and validate
+
+---
+
+## Phase 1: DISCOVER
+
+### Identify Project Type
+
+First, determine what kind of project this is:
+
+| Type | Indicators |
+|------|------------|
+| Web App (Full-stack) | Separate client/server dirs, API routes |
+| Web App (Frontend) | React/Vue/Svelte, no server code |
+| API/Backend | Express/Fastify/etc, no frontend |
+| Library/Package | `main`/`exports` in package.json, publishable |
+| CLI Tool | `bin` in package.json, command-line interface |
+| Monorepo | Multiple packages, workspaces config |
+| Script/Automation | Standalone scripts, task-focused |
+
+### Analyze Configuration
+
+Look at root configuration files:
+
+```
+package.json       → dependencies, scripts, type
+tsconfig.json      → TypeScript settings
+vite.config.*      → Build tool
+*.config.js/ts     → Various tool configs
+```
+
+### Map Directory Structure
+
+Explore the codebase to understand organization:
+- Where does source code live?
+- Where are tests?
+- Any shared code?
+- Configuration locations?
+
+---
+
+## Phase 2: ANALYZE
+
+### Extract Tech Stack
+
+From package.json and config files, identify:
+- Runtime/Language (Node, Bun, Deno, browser)
+- Framework(s)
+- Database (if any)
+- Testing tools
+- Build tools
+- Linting/formatting
+
+### Identify Patterns
+
+Study existing code for:
+- **Naming**: How are files, functions, classes named?
+- **Structure**: How is code organized within files?
+- **Errors**: How are errors created and handled?
+- **Types**: How are types/interfaces defined?
+- **Tests**: How are tests structured?
+
+### Find Key Files
+
+Identify files that are important to understand:
+- Entry points
+- Configuration
+- Core business logic
+- Shared utilities
+- Type definitions
+
+---
+
+## Phase 3: GENERATE
+
+### Create CLAUDE.md
+
+Use the template at `.agents/CLAUDE-template.md` as a starting point.
+
+**Output path**: `CLAUDE.md` (project root)
+
+**Adapt to the project:**
+- Remove sections that don't apply
+- Add sections specific to this project type
+- Keep it concise - focus on what's useful
+
+**Key sections to include:**
+
+1. **Project Overview** - What is this and what does it do?
+2. **Tech Stack** - What technologies are used?
+3. **Commands** - How to dev, build, test, lint?
+4. **Structure** - How is the code organized?
+5. **Patterns** - What conventions should be followed?
+6. **Key Files** - What files are important to know?
+
+**Optional sections (add if relevant):**
+- Architecture (for complex apps)
+- API endpoints (for backends)
+- Component patterns (for frontends)
+- Database patterns (if using a DB)
+- On-demand context references
+
+---
+
+## Phase 4: OUTPUT
+
+```markdown
+## Global Rules Created
+
+**File**: `CLAUDE.md`
+
+### Project Type
+
+{Detected project type}
+
+### Tech Stack Summary
+
+{Key technologies detected}
+
+### Structure
+
+{Brief structure overview}
+
+### Next Steps
+
+1. Review the generated `CLAUDE.md`
+2. Add any project-specific notes
+3. Remove any sections that don't apply
+4. Optionally create reference docs in `.agents/reference/`
+```
+
+---
+
+## Tips
+
+- Keep CLAUDE.md focused and scannable
+- Don't duplicate information that's in other docs (link instead)
+- Focus on patterns and conventions, not exhaustive documentation
+- Update it as the project evolves

package/commands/e2e-test.md

@@ -0,0 +1,13 @@
+---
+description: Run comprehensive end-to-end testing using agent-browser
+---
+
+# E2E Test: Full Application Testing
+
+## Objective
+
+Run comprehensive end-to-end testing of the application. This launches parallel research agents, then systematically tests every user journey using the browser, takes screenshots, validates database records, and fixes any issues found.
+
+## Instructions
+
+Load the `e2e-test` skill and follow its instructions exactly, starting from the Pre-flight Check through to the final Report.

package/commands/execute.md

@@ -0,0 +1,101 @@
+---
+description: Execute an implementation plan
+argument-hint: [path-to-plan]
+---
+
+# Execute: Implement from Plan
+
+## Plan to Execute
+
+Read plan file: `$ARGUMENTS`
+
+## Execution Instructions
+
+### 1. Read and Understand
+
+- Read the ENTIRE plan carefully
+- Understand all tasks and their dependencies
+- Note the validation commands to run
+- Review the testing strategy
+
+### 2. Execute Tasks in Order
+
+For EACH task in "Step by Step Tasks":
+
+#### a. Navigate to the task
+- Identify the file and action required
+- Read existing related files if modifying
+
+#### b. Implement the task
+- Follow the detailed specifications exactly
+- Maintain consistency with existing code patterns
+- Include proper type hints and documentation
+- Add structured logging where appropriate
+
+#### c. Verify as you go
+- After each file change, check syntax
+- Ensure imports are correct
+- Verify types are properly defined
+
+### 3. Implement Testing Strategy
+
+After completing implementation tasks:
+
+- Create all test files specified in the plan
+- Implement all test cases mentioned
+- Follow the testing approach outlined
+- Ensure tests cover edge cases
+
+### 4. Run Validation Commands
+
+Execute ALL validation commands from the plan in order:
+
+```bash
+# Run each command exactly as specified in plan
+```
+
+If any command fails:
+- Fix the issue
+- Re-run the command
+- Continue only when it passes
+
+### 5. Final Verification
+
+Before completing:
+
+- ✅ All tasks from plan completed
+- ✅ All tests created and passing
+- ✅ All validation commands pass
+- ✅ Code follows project conventions
+- ✅ Documentation added/updated as needed
+
+## Output Report
+
+Provide summary:
+
+### Completed Tasks
+- List of all tasks completed
+- Files created (with paths)
+- Files modified (with paths)
+
+### Tests Added
+- Test files created
+- Test cases implemented
+- Test results
+
+### Validation Results
+```bash
+# Output from each validation command
+```
+
+### Ready for Commit
+- Confirm all changes are complete
+- Confirm all validations pass
+- Ready for `/commit` command
+
+## Notes
+
+- If you encounter issues not addressed in the plan, document them
+- If you need to deviate from the plan, explain why
+- If tests fail, fix implementation until they pass
+- Don't skip validation steps

package/commands/init-project.md

@@ -0,0 +1,61 @@
+# Initialize Project
+
+Run the following commands to set up and start the project locally:
+
+## 1. Create Environment File
+```bash
+cp .env.example .env
+```
+Creates your local environment configuration from the example template.
+
+## 2. Install Dependencies
+```bash
+uv sync
+```
+Installs all Python packages defined in pyproject.toml.
+
+## 3. Start Database
+```bash
+docker-compose up -d db
+```
+Starts PostgreSQL 18 in a Docker container on port 5433.
+
+## 4. Run Database Migrations
+```bash
+uv run alembic upgrade head
+```
+Applies all pending database migrations.
+
+## 5. Start Development Server
+```bash
+uv run uvicorn app.main:app --reload --port 8123
+```
+Starts the FastAPI server with hot-reload on port 8123.
+
+## 6. Validate Setup
+
+Check that everything is working:
+
+```bash
+# Test API health
+curl -s http://localhost:8123/health
+
+# Test database connection
+curl -s http://localhost:8123/health/db
+```
+
+Both should return `{"status":"healthy"}` responses.
+
+## Access Points
+
+- Swagger UI: http://localhost:8123/docs
+- Health Check: http://localhost:8123/health
+- Database: localhost:5433
+
+## Cleanup
+
+To stop services:
+```bash
+# Stop dev server: Ctrl+C
+# Stop database: docker-compose down
+```

package/commands/plan-feature.md

@@ -0,0 +1,433 @@
+---
+description: "Create comprehensive feature plan with deep codebase analysis and research"
+---
+
+# Plan a new task
+
+## Feature: $ARGUMENTS
+
+## Mission
+
+Transform a feature request into a **comprehensive implementation plan** through systematic codebase analysis, external research, and strategic planning.
+
+**Core Principle**: We do NOT write code in this phase. Our goal is to create a context-rich implementation plan that enables one-pass implementation success for ai agents.
+
+**Key Philosophy**: Context is King. The plan must contain ALL information needed for implementation - patterns, mandatory reading, documentation, validation commands - so the execution agent succeeds on the first attempt.
+
+## Planning Process
+
+### Phase 1: Feature Understanding
+
+**Deep Feature Analysis:**
+
+- Extract the core problem being solved
+- Identify user value and business impact
+- Determine feature type: New Capability/Enhancement/Refactor/Bug Fix
+- Assess complexity: Low/Medium/High
+- Map affected systems and components
+
+**Create User Story Format Or Refine If Story Was Provided By The User:**
+
+```
+As a <type of user>
+I want to <action/goal>
+So that <benefit/value>
+```
+
+### Phase 2: Codebase Intelligence Gathering
+
+**Use specialized agents and parallel analysis:**
+
+**1. Project Structure Analysis**
+
+- Detect primary language(s), frameworks, and runtime versions
+- Map directory structure and architectural patterns
+- Identify service/component boundaries and integration points
+- Locate configuration files (pyproject.toml, package.json, etc.)
+- Find environment setup and build processes
+
+**2. Pattern Recognition** (Use specialized subagents when beneficial)
+
+- Search for similar implementations in codebase
+- Identify coding conventions:
+  - Naming patterns (CamelCase, snake_case, kebab-case)
+  - File organization and module structure
+  - Error handling approaches
+  - Logging patterns and standards
+- Extract common patterns for the feature's domain
+- Document anti-patterns to avoid
+- Check CLAUDE.md for project-specific rules and conventions
+
+**3. Dependency Analysis**
+
+- Catalog external libraries relevant to feature
+- Understand how libraries are integrated (check imports, configs)
+- Find relevant documentation in docs/, ai_docs/, .agents/reference or ai-wiki if available
+- Note library versions and compatibility requirements
+
+**4. Testing Patterns**
+
+- Identify test framework and structure (pytest, jest, etc.)
+- Find similar test examples for reference
+- Understand test organization (unit vs integration)
+- Note coverage requirements and testing standards
+
+**5. Integration Points**
+
+- Identify existing files that need updates
+- Determine new files that need creation and their locations
+- Map router/API registration patterns
+- Understand database/model patterns if applicable
+- Identify authentication/authorization patterns if relevant
+
+**Clarify Ambiguities:**
+
+- If requirements are unclear at this point, ask the user to clarify before you continue
+- Get specific implementation preferences (libraries, approaches, patterns)
+- Resolve architectural decisions before proceeding
+
+### Phase 3: External Research & Documentation
+
+**Use specialized subagents when beneficial for external research:**
+
+**Documentation Gathering:**
+
+- Research latest library versions and best practices
+- Find official documentation with specific section anchors
+- Locate implementation examples and tutorials
+- Identify common gotchas and known issues
+- Check for breaking changes and migration guides
+
+**Technology Trends:**
+
+- Research current best practices for the technology stack
+- Find relevant blog posts, guides, or case studies
+- Identify performance optimization patterns
+- Document security considerations
+
+**Compile Research References:**
+
+```markdown
+## Relevant Documentation
+
+- [Library Official Docs](https://example.com/docs#section)
+  - Specific feature implementation guide
+  - Why: Needed for X functionality
+- [Framework Guide](https://example.com/guide#integration)
+  - Integration patterns section
+  - Why: Shows how to connect components
+```
+
+### Phase 4: Deep Strategic Thinking
+
+**Think Harder About:**
+
+- How does this feature fit into the existing architecture?
+- What are the critical dependencies and order of operations?
+- What could go wrong? (Edge cases, race conditions, errors)
+- How will this be tested comprehensively?
+- What performance implications exist?
+- Are there security considerations?
+- How maintainable is this approach?
+
+**Design Decisions:**
+
+- Choose between alternative approaches with clear rationale
+- Design for extensibility and future modifications
+- Plan for backward compatibility if needed
+- Consider scalability implications
+
+### Phase 5: Plan Structure Generation
+
+**Create comprehensive plan with the following structure:**
+
+Whats below here is a template for you to fill for th4e implementation agent:
+
+```markdown
+# Feature: <feature-name>
+
+The following plan should be complete, but its important that you validate documentation and codebase patterns and task sanity before you start implementing.
+
+Pay special attention to naming of existing utils types and models. Import from the right files etc.
+
+## Feature Description
+
+<Detailed description of the feature, its purpose, and value to users>
+
+## User Story
+
+As a <type of user>
+I want to <action/goal>
+So that <benefit/value>
+
+## Problem Statement
+
+<Clearly define the specific problem or opportunity this feature addresses>
+
+## Solution Statement
+
+<Describe the proposed solution approach and how it solves the problem>
+
+## Feature Metadata
+
+**Feature Type**: [New Capability/Enhancement/Refactor/Bug Fix]
+**Estimated Complexity**: [Low/Medium/High]
+**Primary Systems Affected**: [List of main components/services]
+**Dependencies**: [External libraries or services required]
+
+---
+
+## CONTEXT REFERENCES
+
+### Relevant Codebase Files IMPORTANT: YOU MUST READ THESE FILES BEFORE IMPLEMENTING!
+
+<List files with line numbers and relevance>
+
+- `path/to/file.py` (lines 15-45) - Why: Contains pattern for X that we'll mirror
+- `path/to/model.py` (lines 100-120) - Why: Database model structure to follow
+- `path/to/test.py` - Why: Test pattern example
+
+### New Files to Create
+
+- `path/to/new_service.py` - Service implementation for X functionality
+- `path/to/new_model.py` - Data model for Y resource
+- `tests/path/to/test_new_service.py` - Unit tests for new service
+
+### Relevant Documentation YOU SHOULD READ THESE BEFORE IMPLEMENTING!
+
+- [Documentation Link 1](https://example.com/doc1#section)
+  - Specific section: Authentication setup
+  - Why: Required for implementing secure endpoints
+- [Documentation Link 2](https://example.com/doc2#integration)
+  - Specific section: Database integration
+  - Why: Shows proper async database patterns
+
+### Patterns to Follow
+
+<Specific patterns extracted from codebase - include actual code examples from the project>
+
+**Naming Conventions:** (for example)
+
+**Error Handling:** (for example)
+
+**Logging Pattern:** (for example)
+
+**Other Relevant Patterns:** (for example)
+
+---
+
+## IMPLEMENTATION PLAN
+
+### Phase 1: Foundation
+
+<Describe foundational work needed before main implementation>
+
+**Tasks:**
+
+- Set up base structures (schemas, types, interfaces)
+- Configure necessary dependencies
+- Create foundational utilities or helpers
+
+### Phase 2: Core Implementation
+
+<Describe the main implementation work>
+
+**Tasks:**
+
+- Implement core business logic
+- Create service layer components
+- Add API endpoints or interfaces
+- Implement data models
+
+### Phase 3: Integration
+
+<Describe how feature integrates with existing functionality>
+
+**Tasks:**
+
+- Connect to existing routers/handlers
+- Register new components
+- Update configuration files
+- Add middleware or interceptors if needed
+
+### Phase 4: Testing & Validation
+
+<Describe testing approach>
+
+**Tasks:**
+
+- Implement unit tests for each component
+- Create integration tests for feature workflow
+- Add edge case tests
+- Validate against acceptance criteria
+
+---
+
+## STEP-BY-STEP TASKS
+
+IMPORTANT: Execute every task in order, top to bottom. Each task is atomic and independently testable.
+
+### Task Format Guidelines
+
+Use information-dense keywords for clarity:
+
+- **CREATE**: New files or components
+- **UPDATE**: Modify existing files
+- **ADD**: Insert new functionality into existing code
+- **REMOVE**: Delete deprecated code
+- **REFACTOR**: Restructure without changing behavior
+- **MIRROR**: Copy pattern from elsewhere in codebase
+
+### {ACTION} {target_file}
+
+- **IMPLEMENT**: {Specific implementation detail}
+- **PATTERN**: {Reference to existing pattern - file:line}
+- **IMPORTS**: {Required imports and dependencies}
+- **GOTCHA**: {Known issues or constraints to avoid}
+- **VALIDATE**: `{executable validation command}`
+
+<Continue with all tasks in dependency order...>
+
+---
+
+## TESTING STRATEGY
+
+<Define testing approach based on project's test framework and patterns discovered in during research>
+
+### Unit Tests
+
+<Scope and requirements based on project standards>
+
+Design unit tests with fixtures and assertions following existing testing approaches
+
+### Integration Tests
+
+<Scope and requirements based on project standards>
+
+### Edge Cases
+
+<List specific edge cases that must be tested for this feature>
+
+---
+
+## VALIDATION COMMANDS
+
+<Define validation commands based on project's tools discovered in Phase 2>
+
+Execute every command to ensure zero regressions and 100% feature correctness.
+
+### Level 1: Syntax & Style
+
+<Project-specific linting and formatting commands>
+
+### Level 2: Unit Tests
+
+<Project-specific unit test commands>
+
+### Level 3: Integration Tests
+
+<Project-specific integration test commands>
+
+### Level 4: Manual Validation
+
+<Feature-specific manual testing steps - API calls, UI testing, etc.>
+
+### Level 5: Additional Validation (Optional)
+
+<MCP servers or additional CLI tools if available>
+
+---
+
+## ACCEPTANCE CRITERIA
+
+<List specific, measurable criteria that must be met for completion>
+
+- [ ] Feature implements all specified functionality
+- [ ] All validation commands pass with zero errors
+- [ ] Unit test coverage meets requirements (80%+)
+- [ ] Integration tests verify end-to-end workflows
+- [ ] Code follows project conventions and patterns
+- [ ] No regressions in existing functionality
+- [ ] Documentation is updated (if applicable)
+- [ ] Performance meets requirements (if applicable)
+- [ ] Security considerations addressed (if applicable)
+
+---
+
+## COMPLETION CHECKLIST
+
+- [ ] All tasks completed in order
+- [ ] Each task validation passed immediately
+- [ ] All validation commands executed successfully
+- [ ] Full test suite passes (unit + integration)
+- [ ] No linting or type checking errors
+- [ ] Manual testing confirms feature works
+- [ ] Acceptance criteria all met
+- [ ] Code reviewed for quality and maintainability
+
+---
+
+## NOTES
+
+<Additional context, design decisions, trade-offs>
+```
+
+## Output Format
+
+**Filename**: `.agents/plans/{kebab-case-descriptive-name}.md`
+
+- Replace `{kebab-case-descriptive-name}` with short, descriptive feature name
+- Examples: `add-user-authentication.md`, `implement-search-api.md`, `refactor-database-layer.md`
+
+**Directory**: Create `.agents/plans/` if it doesn't exist
+
+## Quality Criteria
+
+### Context Completeness ✓
+
+- [ ] All necessary patterns identified and documented
+- [ ] External library usage documented with links
+- [ ] Integration points clearly mapped
+- [ ] Gotchas and anti-patterns captured
+- [ ] Every task has executable validation command
+
+### Implementation Ready ✓
+
+- [ ] Another developer could execute without additional context
+- [ ] Tasks ordered by dependency (can execute top-to-bottom)
+- [ ] Each task is atomic and independently testable
+- [ ] Pattern references include specific file:line numbers
+
+### Pattern Consistency ✓
+
+- [ ] Tasks follow existing codebase conventions
+- [ ] New patterns justified with clear rationale
+- [ ] No reinvention of existing patterns or utils
+- [ ] Testing approach matches project standards
+
+### Information Density ✓
+
+- [ ] No generic references (all specific and actionable)
+- [ ] URLs include section anchors when applicable
+- [ ] Task descriptions use codebase keywords
+- [ ] Validation commands are non interactive executable
+
+## Success Metrics
+
+**One-Pass Implementation**: Execution agent can complete feature without additional research or clarification
+
+**Validation Complete**: Every task has at least one working validation command
+
+**Context Rich**: The Plan passes "No Prior Knowledge Test" - someone unfamiliar with codebase can implement using only Plan content
+
+**Confidence Score**: #/10 that execution will succeed on first attempt
+
+## Report
+
+After creating the Plan, provide:
+
+- Summary of feature and approach
+- Full path to created Plan file
+- Complexity assessment
+- Key implementation risks or considerations
+- Estimated confidence score for one-pass success

package/commands/prime.md

@@ -0,0 +1,75 @@
+---
+description: Prime agent with codebase understanding
+---
+
+# Prime: Load Project Context
+
+## Objective
+
+Build comprehensive understanding of the codebase by analyzing structure, documentation, and key files.
+
+## Process
+
+### 1. Analyze Project Structure
+
+List all tracked files:
+!`git ls-files`
+
+Show directory structure:
+On Linux, run: `tree -L 3 -I 'node_modules|__pycache__|.git|dist|build'`
+
+### 2. Read Core Documentation
+
+- Read the PRD.md or similar spec file
+- Read CLAUDE.md or similar global rules file
+- Read README files at project root and major directories
+- Read any architecture documentation
+- Read the drizzle config so you understand the database schema
+
+### 3. Identify Key Files
+
+Based on the structure, identify and read:
+- Main entry points (main.py, index.ts, app.py, etc.)
+- Core configuration files (pyproject.toml, package.json, tsconfig.json)
+- Key model/schema definitions
+- Important service or controller files
+
+### 4. Understand Current State
+
+Check recent activity:
+!`git log -10 --oneline`
+
+Check current branch and status:
+!`git status`
+
+## Output Report
+
+Provide a concise summary covering:
+
+### Project Overview
+- Purpose and type of application
+- Primary technologies and frameworks
+- Current version/state
+
+### Architecture
+- Overall structure and organization
+- Key architectural patterns identified
+- Important directories and their purposes
+
+### Tech Stack
+- Languages and versions
+- Frameworks and major libraries
+- Build tools and package managers
+- Testing frameworks
+
+### Core Principles
+- Code style and conventions observed
+- Documentation standards
+- Testing approach
+
+### Current State
+- Active branch
+- Recent changes or development focus
+- Any immediate observations or concerns
+
+**Make this summary easy to scan - use bullet points and clear headers.**

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
@@ -121,6 +121,7 @@ function sleep(ms) {
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 var TEMPLATES_DIR = resolve(__dirname, "..", "templates");
+var COMMANDS_DIR = resolve(__dirname, "..", "commands");
 function isCommandAvailable(command) {
   try {
     const cmd = process.platform === "win32" ? `where ${command}` : `which ${command}`;
@@ -141,6 +142,13 @@ function readTemplate(relativePath) {
   const fullPath = join(TEMPLATES_DIR, relativePath);
   return readFileSync(fullPath, "utf-8");
 }
+function readCommand(filename) {
+  const fullPath = join(COMMANDS_DIR, filename);
+  return readFileSync(fullPath, "utf-8");
+}
+function listCommands() {
+  return readdirSync(COMMANDS_DIR).filter((f) => f.endsWith(".md"));
+}
 function writeFile(targetDir, relativePath, content) {
   const fullPath = join(targetDir, relativePath);
   const dir = dirname(fullPath);
@@ -261,27 +269,45 @@ async function main() {
     summaryParts.push(bgYellow(` ${missing.length} missing `));
   console.log(`  ${summaryParts.join("  ")}`);
   console.log();
-  const totalFiles = AGENTS.length + 1;
+  const totalAgentFiles = AGENTS.length + 1;
   let fileCount = 0;
-  const skillsDir = ".agents/skills";
-  const fileSpinner = createSpinner("Writing skill files...");
+  const agentsDir = ".opencode/agents";
+  const fileSpinner = createSpinner("Writing agent skill files...");
   fileSpinner.start();
   const orchestratorContent = readTemplate("skills/sdlc-orchestrator/SKILL.md");
-  writeFile(targetDir, `${skillsDir}/sdlc-orchestrator/SKILL.md`, orchestratorContent);
+  writeFile(targetDir, `${agentsDir}/sdlc-orchestrator/SKILL.md`, orchestratorContent);
   fileCount++;
   await sleep(200);
   for (const agent of AGENTS) {
     const content = readTemplate(`skills/${agent.id}/SKILL.md`);
-    writeFile(targetDir, `${skillsDir}/${agent.id}/SKILL.md`, content);
+    writeFile(targetDir, `${agentsDir}/${agent.id}/SKILL.md`, content);
     fileCount++;
     fileSpinner.stop();
     process.stdout.write(
-      `\r  ${cyan(SPINNER_FRAMES[fileCount % SPINNER_FRAMES.length])} Writing skill files... ${progressBar(fileCount, totalFiles)}`
+      `\r  ${cyan(SPINNER_FRAMES[fileCount % SPINNER_FRAMES.length])} Writing agent skill files... ${progressBar(fileCount, totalAgentFiles)}`
     );
     await sleep(200);
   }
   process.stdout.write(`\r\x1B[K`);
-  console.log(`  ${green("\u2714")} Created ${bold(String(totalFiles))} skill files in ${cyan(skillsDir + "/")}`);
+  console.log(`  ${green("\u2714")} Created ${bold(String(totalAgentFiles))} agent skill files in ${cyan(agentsDir + "/")}`);
+  console.log();
+  const commandFiles = listCommands();
+  const commandsDir = ".opencode/commands";
+  let cmdCount = 0;
+  const cmdSpinner = createSpinner("Writing command files...");
+  cmdSpinner.start();
+  for (const cmdFile of commandFiles) {
+    const content = readCommand(cmdFile);
+    writeFile(targetDir, `${commandsDir}/${cmdFile}`, content);
+    cmdCount++;
+    cmdSpinner.stop();
+    process.stdout.write(
+      `\r  ${cyan(SPINNER_FRAMES[cmdCount % SPINNER_FRAMES.length])} Writing command files... ${progressBar(cmdCount, commandFiles.length)}`
+    );
+    await sleep(150);
+  }
+  process.stdout.write(`\r\x1B[K`);
+  console.log(`  ${green("\u2714")} Created ${bold(String(cmdCount))} command files in ${cyan(commandsDir + "/")}`);
   console.log();
   const configSpinner = createSpinner("Configuring opencode.json...");
   configSpinner.start();
@@ -296,7 +322,7 @@ async function main() {
   console.log();
   console.log(dim("  \u2500\u2500\u2500 Files Created \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log();
-  console.log(`  ${cyan("\u{1F4C1} .agents/skills/")}`);
+  console.log(`  ${cyan("\u{1F4C1} .opencode/agents/")}`);
   console.log(`     ${dim("\u251C\u2500\u2500")} ${cyan("sdlc-orchestrator/")} ${dim("\u2190 master routing skill")}`);
   for (let i = 0; i < AGENTS.length; i++) {
     const agent = AGENTS[i];
@@ -308,6 +334,15 @@ async function main() {
     );
   }
   console.log();
+  console.log(`  ${cyan("\u{1F4C1} .opencode/commands/")}`);
+  const cmdFileList = listCommands();
+  for (let i = 0; i < cmdFileList.length; i++) {
+    const isLast = i === cmdFileList.length - 1;
+    const prefix = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    const name = cmdFileList[i].replace(".md", "");
+    console.log(`     ${dim(prefix)} ${cyan(cmdFileList[i])} ${dim(`\u2190 /${name}`)}`);
+  }
+  console.log();
   console.log(`  ${cyan("\u{1F4C4} opencode.json")} ${dim("\u2190 permissions + /delegate commands")}`);
   console.log();
   console.log(dim("  \u2500\u2500\u2500 Usage \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdlc-subagents",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Scaffold OpenCode as an orchestrator of multiple coding agent CLIs (Gemini, Copilot, Claude, Aider, Kimi, Cursor)",
   "bin": {
     "sdlc-subagents": "dist/index.js"
@@ -28,7 +28,8 @@
   "license": "MIT",
   "files": [
     "dist",
-    "templates"
+    "templates",
+    "commands"
   ],
   "engines": {
     "node": ">=18"