feature-tasks

I will help you convert a feature implementation plan into concrete, trackable Beads tasks with proper dependencies and estimates.

Usage:

• /feature-tasks <feature-id> - Create tasks from plan
• /feature-tasks --show <feature-id> - Display existing tasks
• /feature-tasks --sync <feature-id> - Sync plan changes to tasks

Instructions for me:

1. Load implementation plan:

   • Read .mnemosyne/artifacts/plans/<feature-id>-plan.md
   • If not found: "Error: Plan '' not found. Use /feature-plan first."
   • Parse YAML frontmatter to get plan version, memory_id, feature_id
   • Extract implementation order, parallel streams, dependencies

2. Check for existing tasks:

   • Query Beads for tasks with tag feature:<feature-id>
   • If exists:
     • If --show: Display task summary and exit
     • If --sync: Update tasks based on plan changes
     • Otherwise: Ask if user wants to view, sync, or recreate

3. Analyze plan structure: From plan.md, extract:

   • Implementation Order: Ordered list of steps
   • Parallel Streams: Independent workstreams
   • Dependencies: Task X depends on Task Y relationships
   • Integration Points (Typed Holes): Interfaces between components
   • Testing Requirements: Test types for each component

4. Generate Beads task structure: For each plan item:

   a) Task Title:

   • Format: [<feature-id>] <step-name>: <brief-description>
   • Example: [jwt-auth] Implement JWT Generation: RS256 signing with refresh tokens
   • Max 100 characters

   b) Task Description:

   ## Goal
   <What needs to be done>
   
   ## Technical Details
   <From plan: approach, data models, APIs>
   
   ## Acceptance Criteria
   - [ ] <criterion 1 from plan>
   - [ ] <criterion 2 from plan>
   - [ ] Tests: <test requirements>
   
   ## Dependencies
   - Requires: <task-id> (<task-name>)
   - Blocks: <task-id> (<task-name>)
   
   ## Integration Points
   - <Typed hole to implement or consume>
   
   ## Estimated Effort
   <hours or days based on plan>
   
   ## Related Files
   - <files from plan>
   
   ## Notes
   <Any additional context from plan>
   

   c) Priority:

   • P0 (critical): On critical path, blocks multiple tasks
   • P1 (high): Important but not blocking
   • P2 (medium): Nice-to-have, can defer
   • P3 (low): Future enhancement

   Determine priority from:

   • Critical path items: P0
   • Parallel stream items: P1
   • Polish/refinement: P2
   • Future work: P3

   d) Effort Estimate:

   • Parse from plan's implementation order
   • Default: 4 hours for typical tasks
   • Adjust based on complexity indicators:
     • "Foundation" or "Core": 4-8 hours
     • "Integration": 2-4 hours
     • "Polish" or "Refinement": 1-2 hours
     • "Testing": 2-4 hours

   e) Type:

   • feature: New functionality
   • refactor: Code improvement
   • test: Test addition
   • doc: Documentation
   • bug: Fix (if plan mentions fixing issues)

   f) Tags:

   • feature:<feature-id>
   • plan:<plan-version>
   • <category> (from plan: auth, api, database, etc.)

5. Handle dependencies:

   • Parse "Dependencies" section from plan
   • For "Task X depends on Task Y":
     • Create Task Y first (if not exists)
     • Add --blocked-by <task-y-id> to Task X
   • For parallel streams:
     • No blocking relationships within stream
     • May depend on foundation tasks
   • For critical path:
     • Each task blocks next task

6. Create tasks in Beads (auto-synced):

   # Foundation task (no dependencies) - Hash ID assigned
   bd create "[jwt-auth] Database Schema: Create users table with auth fields" \
     -d "$(cat task_desc.md)" \
     -t feature -p 0 -l "feature:jwt-auth,plan:1.0.0,database" \
     --json
   # Returns: {"id": "bd-a1b2", ...}
   
   # Task with dependency (using hash ID)
   bd create "[jwt-auth] JWT Generation: Implement RS256 signing" \
     -d "$(cat task_desc.md)" \
     -t feature -p 0 -l "feature:jwt-auth,plan:1.0.0,auth" \
     --json
   # Returns: {"id": "bd-c3d4", ...}
   
   # Add dependency using bd dep
   bd dep add bd-c3d4 bd-a1b2 --type blocks
   
   # Parallel stream task
   bd create "[jwt-auth] Middleware: Token validation for protected routes" \
     -d "$(cat task_desc.md)" \
     -t feature -p 1 -l "feature:jwt-auth,plan:1.0.0,middleware" \
     --json
   # Returns: {"id": "bd-e5f6", ...}
   
   bd dep add bd-e5f6 bd-c3d4 --type blocks
   
   # All tasks auto-synced to .beads/issues.jsonl (5-second debounce)