memory-mcp-1file: Command for OpenCode

VIDA: Form Milestone

Затвердження формування Milestone та генерація категоризованих задач

---

Role

---

⚠️ CRITICAL: Two-Stage Approval

USER MUST APPROVE formation BEFORE:

• Tasks are generated
• Categories are assigned
• Specifications are created

After approval → automatic task generation and categorization

---

What This Does

When you run /vida-form {milestone-name} {epic(s)}, I:

1. Load Epic scope - From epic files
2. Present formation summary - Goals, scope, estimated complexity
3. Wait for approval - User must confirm
4. Generate tasks - Using META-analysis
5. Categorize tasks - UI, Infra, Logic, Testing, Config, Security
6. Detect OWASP triggers - Mark security-critical tasks
7. Create tasks.md - With categorization
8. Sync to beads - Create issues with dependencies (if .beads/ exists)
9. Trigger Stage 2 - Category specifications

---

VIDA MODE: Formation

I'm in milestone formation mode!

What I'll do:

• ✓ Analyze Epic scope
• ✓ Present scope summary
• ✓ Wait for YOUR approval
• ✓ Generate categorized tasks
• ✓ Detect OWASP requirements
• ✓ Sync tasks to beads (if enabled)
• ✓ Prepare for specifications

What I won't do:

• ✗ Generate specs without approval
• ✗ Skip OWASP detection
• ✗ Proceed without confirmation

---

State Assertion (MANDATORY)

**VIDA MODE: Formation**
Mode: formation
Milestone: {name}
Epic(s): {list}
Status: AWAITING USER APPROVAL
Tasks: NOT YET GENERATED

---

Algorithm

VIDA_FORM:
  trigger: [manual]
  
  steps:
    - id: parse_input
      action: |
        1. Extract milestone name: {X.XX-name}
        2. Extract epic(s): EP-XXX, EP-XXX:scope, ...
        3. Validate epic files exist
      output: parsed_input
      
    - id: load_epic_scope
      action: |
        FOR each epic:
          1. Read epic file from doc/planning/epics/
          2. Extract scope (IN items)
          3. Extract dependencies
          4. Merge into combined scope
      output: combined_scope

    - id: load_specs
      action: |
        FOR each epic:
          1. Extract spec references from epic file (Spec: links)
          2. Read each referenced spec from doc/specs/
          3. Extract:
             - Technical requirements
             - API endpoints
             - Data models
             - Security requirements
             - Dependencies
          4. Merge spec details into scope
      output: enriched_scope

     - id: present_formation
       action: |
         Display formation summary using TOON format:
         ```toon
         formation_summary[6]{field,value}:
           Name,{milestone}
           Epic,"{primary} + {linked}"
           Scope,feature 1
           Scope,feature 2
           Scope,feature N
           Estimated,"{N} tasks, {M} categories"
         ```
       output: formation_presented
      
    - id: await_approval
      action: |
        Wait for user response:
        - yes → proceed to task generation
        - no → abort with reason
      output: user_approval
      
    - id: generate_tasks
      condition: user_approved
      action: |
        META-analysis to generate tasks:
        1. Analyze scope items from EPIC scope AND SPEC details
        2. Break into implementable tasks
        3. Assign T-XX IDs
        4. Define file paths and acceptance criteria
        5. Identify parallelization opportunities

        **NOTE:** Tasks are generated from BOTH:
        - Epic scope (feature-level requirements)
        - Spec details (technical implementation details, APIs, data models)
      output: tasks_list
      
    - id: categorize_tasks
      action: |
        FOR each task:
          1. Analyze task description and files
          2. Assign primary category:
             - UI/Design: screens, widgets, navigation
             - Infrastructure: docker, DB, services
             - Logic/Code: business logic, models
             - Testing: test setup, test files
             - Config/DX: configs, tooling
          3. Check OWASP triggers
          4. Mark artifacts required
      output: categorized_tasks
      
    - id: detect_owasp
      action: |
        FOR each task:
          1. Match against OWASP_TRIGGERS
          2. IF match:
             → Add OWASP category tags
             → Set security_critical: true
             → Require OWASP research before spec
      output: owasp_detection
      
    - id: create_tasks_md
      action: |
        1. Generate tasks.md with categorization
        2. Include parallelization map
        3. Mark OWASP-tagged tasks
        4. Include artifact requirements
      output: tasks_file_created
      
    - id: sync_to_beads
      condition: ".beads/ directory exists"
      action: |
        FOR each task in generated_tasks:
          # Create beads issue
          br create "T-{NN}: {title}" \
            --type=task \
            --priority={category_priority}
          
          # Set metadata
          br metadata set {issue_id} milestone={milestone}
          br metadata set {issue_id} category={category}
        
        # Build dependency graph from task order
        FOR i in range(1, len(tasks)):
          br dep add {task[i].id} {task[i-1].id}
        
        # Commit to JSONL
        br sync --flush-only
        
      fallback: |
        LOG: "ℹ️ Beads not initialized. Run 'br init' for graph features."
      output: beads_synced
      
    - id: create_directory_structure
      action: |
        doc/planning/milestones/{name}/
        ├── spec.md (basic shell)
        ├── tasks.md (generated)
        ├── tests.md (template)
        ├── readiness.md (template)
        └── categories/
            ├── ui-spec.md
            ├── infra-spec.md
            ├── logic-spec.md
            ├── testing-spec.md
            ├── config-spec.md
            └── security-spec.md (if OWASP detected)
      output: structure_created
      
    - id: invalidate_state
      action: |
        Update doc/state/.state-hash:
          stale: true
          invalidated_fields:
            - current.milestone
            - progress.tasks.*
          invalidated_by: "/vida-form"