aidp 0.27.0 → 0.29.0

data/templates/planning/assign_personas.md

@@ -0,0 +1,108 @@
+# Assign Tasks to Personas
+
+You are assigning each task to the most appropriate persona using **Zero Framework Cognition** (ZFC).
+
+## Critical: Use ZFC Pattern
+
+**DO NOT use heuristics, regex, or keyword matching!**
+
+All task-to-persona assignments must be made using semantic AI decision making, not programmatic rules.
+
+## Input
+
+Read `.aidp/docs/TASK_LIST.md` - All project tasks
+
+## Available Personas
+
+Default personas include:
+
+- **product_strategist** - Product requirements, user research, stakeholder management
+- **architect** - System design, architecture decisions, technology choices
+- **senior_developer** - Implementation, code quality, technical problem solving
+- **qa_engineer** - Testing strategy, test implementation, quality assurance
+- **devops_engineer** - Infrastructure, CI/CD, deployment, monitoring
+- **tech_writer** - Documentation, user guides, API documentation
+
+## Assignment Principles
+
+The AI should consider:
+
+- **Task type**: Requirements, design, implementation, testing, deployment
+- **Required expertise**: Product, architecture, development, QA, operations
+- **Phase**: Different personas for different phases
+- **Complexity**: Senior developers for complex tasks
+
+## Zero Framework Cognition
+
+**FORBIDDEN**:
+
+- Regex pattern matching on task names
+- Keyword matching ("test" → qa_engineer)
+- Heuristic rules
+- Scoring formulas
+
+**REQUIRED**:
+
+- Use AI decision engine for ALL assignments
+- Provide task context to AI (name, description, phase, effort)
+- Let AI make semantic decisions
+- Assignment rationale comes from AI, not code
+
+## Parallel Execution
+
+Multiple personas can work in parallel - the system handles conflicts automatically.
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill to:
+
+1. Load tasks from Gantt chart or task list
+2. Use `Aidp::Planning::Mappers::PersonaMapper` with AI decision engine
+3. Call `AIDecisionEngine.decide()` for each task assignment
+4. Generate `persona_map.yml` configuration
+5. Write to `.aidp/docs/persona_map.yml`
+
+The skill provides the complete Ruby implementation including:
+
+- AI engine integration
+- ZFC-based decision making (NO heuristics!)
+- YAML configuration generation
+- Proper error handling and logging
+
+**For other language implementations**, implement equivalent functionality:
+
+1. Load task list with descriptions, phases, and effort
+2. For each task, invoke AI decision engine with:
+   - Task characteristics (name, description, phase, effort)
+   - Available personas list
+   - Decision prompt asking for best persona match
+3. Store AI's decision (persona assignment)
+4. Generate configuration file mapping tasks to personas
+5. Include assignment rationale from AI
+
+## Output Format
+
+Write assignments to `.aidp/docs/persona_map.yml`:
+
+```yaml
+version: "1.0"
+generated_at: "<timestamp>"
+assignments:
+  TASK-001:
+    persona: product_strategist
+    task: "Document Functional Requirements"
+    phase: "Requirements"
+  TASK-002:
+    persona: architect
+    task: "Design System Architecture"
+    phase: "Design"
+  ...
+```
+
+## Remember
+
+- Use AIDecisionEngine - NO manual heuristics!
+- Assignment rationale comes from AI, not code
+- Every task must be assigned
+- Personas can work in parallel
+- This is a ZFC pattern - meaning goes to AI, structure goes to code

data/templates/planning/create_tasks.md

@@ -1,6 +1,6 @@
 # AI Scaffold Task Planner
 
-You are a planner.
+You are a planner responsible for breaking down work into trackable tasks.
 
 ## Important Instructions
 
@@ -9,16 +9,60 @@ You are a planner.
 - If you have sufficient information, proceed directly to create the complete task plan
 - Only ask for clarifications at this Tasks step. For subsequent steps, proceed with available information
 
+## Task Tracking System
+
+**CRITICAL**: All work must be tracked through the persistent task system using task filing signals.
+
+### Creating Tasks
+
+Use this signal format in your output to create tasks:
+
+```text
+File task: "description" priority: high|medium|low tags: tag1,tag2
+```
+
+Examples:
+
+```text
+File task: "Design user authentication API" priority: high tags: architecture,auth
+File task: "Implement login endpoint" priority: high tags: implementation,auth
+File task: "Add authentication tests" priority: medium tags: testing,auth
+File task: "Update API documentation" priority: low tags: docs
+```
+
+### Task Organization
+
+Break work into tasks:
+
+- **Per domain** - Group related functionality (e.g., auth, payments, user-mgmt)
+- **Per cross-cutting area** - Infrastructure concerns (e.g., testing, docs, deployment)
+- Include Definition of Done (DoD), dependencies, and reviewer role when applicable
+
+### Task Lifecycle
+
+1. **pending** - Task created, not started
+2. **in_progress** - Currently working on task
+3. **done** - Task completed successfully
+4. **abandoned** - Task no longer needed (requires reason)
+
+Update task status using:
+
+```text
+Update task: task_id_here status: done
+Update task: task_id_here status: abandoned reason: "Requirements changed"
+```
+
 ## Inputs
 
 - `docs/DomainCharters/*`, `contracts/*`, `docs/TestPlan.md`
+- `docs/prd.md` - Product requirements
+- `docs/architecture.md` - Architecture design (if available)
 
-## Process
+## Output
 
-- Break work into tasks **per domain** and **per cross-cutting** area.
-- Include Definition of Done (DoD), dependencies, and reviewer role.
+File all tasks using the task filing system above. Create at least one task.
 
-## Output
+Optional traditional outputs (if needed):
 
 - `tasks/domains/<context>.yaml`
 - `tasks/crosscutting/<area>.yaml`
@@ -26,4 +70,6 @@ You are a planner.
 
 ## Regeneration Policy
 
-Append new tasks; mark deprecated tasks with status.
+- Append new tasks using `File task:` signals
+- Update existing tasks using `Update task:` signals
+- Mark deprecated tasks as abandoned with clear reason

data/templates/planning/generate_gantt.md

@@ -0,0 +1,86 @@
+# Generate Gantt Chart and Critical Path
+
+You are creating a Mermaid Gantt chart with critical path analysis.
+
+## Input
+
+Read `.aidp/docs/WBS.md` - Work breakdown structure with tasks and dependencies
+
+## Your Task
+
+Generate a Gantt chart in Mermaid format showing timeline, dependencies, and critical path.
+
+## Gantt Chart Components
+
+1. **Timeline** - Task durations and sequencing
+2. **Dependencies** - Task relationships ("after" clauses)
+3. **Critical Path** - Longest sequence of dependent tasks
+4. **Phase Sections** - Group tasks by project phase
+
+## Critical Path
+
+The critical path represents the longest sequence of dependent tasks. Any delay in critical path tasks delays the entire project.
+
+Critical path tasks should be highlighted in the visualization.
+
+## Gantt Features
+
+- Phase-based sections
+- Task dependencies (after relationships)
+- Critical tasks highlighted
+- Relative durations based on effort estimates
+
+## Duration Calculation
+
+Convert effort estimates to time:
+
+- Story points → days (e.g., 1 story point = 0.5 days)
+- Minimum duration = 1 day
+- Account for dependencies when calculating start dates
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill to:
+
+1. Load WBS using `Aidp::Planning::Parsers::DocumentParser`
+2. Generate Gantt chart using `Aidp::Planning::Generators::GanttGenerator`
+3. Calculate critical path
+4. Format as Mermaid syntax
+5. Write to `.aidp/docs/GANTT.md`
+
+The skill provides the complete Ruby implementation including:
+
+- WBS parsing and task extraction
+- Duration calculation algorithms
+- Critical path analysis (longest dependency chain)
+- Mermaid format generation
+- File output operations
+
+**For other language implementations**, implement equivalent functionality:
+
+1. Parse WBS to extract tasks and dependencies
+2. Calculate task durations from effort estimates
+3. Build dependency graph
+4. Find critical path (longest path through dependencies)
+5. Generate Mermaid gantt syntax with proper formatting
+6. Highlight critical path tasks
+
+## Mermaid Gantt Syntax
+
+```mermaid
+gantt
+    title Project Timeline
+    dateFormat YYYY-MM-DD
+    section Phase Name
+    Task Name :status, task_id, duration
+    Task with dependency :status, task_id, after other_task, duration
+```
+
+## Output
+
+Write Gantt chart with critical path to `.aidp/docs/GANTT.md` including:
+
+- Mermaid visualization (in code block)
+- Critical path task list
+- Timeline metadata
+- Generation timestamp

data/templates/planning/generate_wbs.md

@@ -0,0 +1,85 @@
+# Generate Work Breakdown Structure (WBS)
+
+You are creating a phase-based Work Breakdown Structure.
+
+## Input
+
+Read:
+
+- `.aidp/docs/PRD.md` - Requirements
+- `.aidp/docs/TECH_DESIGN.md` - Technical approach
+
+## Your Task
+
+Generate a hierarchical breakdown of ALL work needed to deliver this project.
+
+## WBS Structure
+
+A Work Breakdown Structure organizes project work into:
+
+1. **Phases** - Major project stages (Requirements, Design, Implementation, Testing, Deployment)
+2. **Tasks** - Specific work items within each phase
+3. **Subtasks** - Detailed breakdown of complex tasks
+4. **Dependencies** - What must complete before this task
+5. **Effort Estimates** - Story points or time estimates
+
+## Default Phases
+
+1. **Requirements** - Finalize all requirements
+2. **Design** - Complete architectural and detailed design
+3. **Implementation** - Build all features
+4. **Testing** - Comprehensive testing
+5. **Deployment** - Deploy to production
+
+## Task Attributes
+
+For each task, include:
+
+- **Name**: Clear, action-oriented
+- **Description**: What needs to be done
+- **Effort**: Story points or time estimate
+- **Dependencies**: What must complete first
+- **Subtasks**: Breakdown if complex
+
+## Guidelines
+
+- Be comprehensive - include ALL work
+- Break large tasks into subtasks
+- Identify dependencies clearly
+- Provide realistic effort estimates
+- Consider parallel work streams
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill to:
+
+1. Parse PRD and technical design documents using `Aidp::Planning::Parsers::DocumentParser`
+2. Generate WBS structure using `Aidp::Planning::Generators::WBSGenerator`
+3. Format as markdown
+4. Write to `.aidp/docs/WBS.md`
+
+The skill provides the complete Ruby implementation including:
+
+- Module requires and namespacing
+- Class instantiation
+- Method calls with proper parameters
+- File I/O operations
+
+**For other language implementations**, implement equivalent functionality:
+
+1. Parse input documents to extract requirements and design
+2. Decompose into phases and tasks
+3. Calculate effort estimates
+4. Identify dependencies
+5. Generate hierarchical markdown output
+
+## Output
+
+Write complete WBS to `.aidp/docs/WBS.md` with:
+
+- All phases listed
+- Tasks under each phase
+- Subtasks where applicable
+- Dependencies identified
+- Effort estimates included
+- Generated timestamp and metadata

data/templates/planning/initialize_planning_mode.md

@@ -0,0 +1,70 @@
+# Waterfall Planning Initialization
+
+You are initializing a waterfall-style project planning workflow. Your task is to determine whether the user has existing documentation to ingest, or if we need to generate documentation from scratch.
+
+## Your Tasks
+
+1. **Ask the user**: Do they have existing documentation (PRD, design docs, ADRs, task lists)?
+
+2. **If YES (Ingestion Path)**:
+   - Ask for the path(s) to their documentation files
+   - Ask what gaps exist in their documentation that need to be filled
+   - Create a file `.aidp/docs/.waterfall_mode` with content: `mode: ingestion`
+   - List the files to be ingested
+
+3. **If NO (Generation Path)**:
+   - Inform them we'll guide them through requirements elicitation
+   - Create a file `.aidp/docs/.waterfall_mode` with content: `mode: generation`
+   - Prepare to gather requirements via Q&A
+
+## Output Format
+
+Create `.aidp/docs/.waterfall_mode` with:
+
+```yaml
+mode: ingestion  # or 'generation'
+docs_path: /path/to/docs  # if ingestion
+gaps: []  # list of gaps to fill
+timestamp: <ISO8601 timestamp>
+```
+
+## Important Notes
+
+- Be conversational and helpful
+- Explain what waterfall planning provides (WBS, Gantt, personas)
+- If they're unsure, explain both paths
+- Create the `.aidp/docs/` directory if it doesn't exist
+
+## Example Dialogue
+
+**For Ingestion:**
+
+```text
+User: I have a PRD and some design notes
+Assistant: Great! Please provide the path to your PRD and design documentation.
+          I'll parse them and identify any gaps we need to fill via Q&A.
+
+          What gaps exist? For example:
+          - Missing technical architecture details?
+          - No task breakdown yet?
+          - Missing decision records?
+```
+
+**For Generation:**
+
+```text
+User: I'm starting from scratch
+Assistant: Perfect! I'll guide you through creating a comprehensive project plan.
+          We'll start with requirements gathering, then move through:
+          - Product Requirements Document (PRD)
+          - Technical Design
+          - Work Breakdown Structure (WBS)
+          - Gantt Chart with timeline
+          - Task assignments to personas
+
+          Let's begin with some questions about your project...
+```
+
+---
+
+**Remember**: This is a GATE step - wait for user input before proceeding!

data/templates/skills/README.md

@@ -67,7 +67,7 @@ You are a **Repository Analyst**, an expert in version control analysis...
 ## Required Frontmatter Fields
 
 | Field | Type | Description |
-|-------|------|-------------|
+| ------- | ------ | ------------- |
 | `id` | String | Unique identifier (lowercase, alphanumeric, underscores only) |
 | `name` | String | Human-readable name |
 | `description` | String | Brief one-line description |
@@ -76,7 +76,7 @@ You are a **Repository Analyst**, an expert in version control analysis...
 ## Optional Frontmatter Fields
 
 | Field | Type | Description |
-|-------|------|-------------|
+| ------- | ------ | ------------- |
 | `expertise` | Array | List of expertise areas |
 | `keywords` | Array | Search/filter keywords |
 | `when_to_use` | Array | Guidance for when to use this skill |