Task:
  # Core fields (set during planning)
  task_id: TASK-XXX
  task_type: <Task Type>
  task_description: <≤50 words>
  category: <derived from suffix> | Standalone
  role_assigned: <Role Name>
  status: pending | in_progress | blocked | deferred | completed | cancelled
  last_updated: <MM-DD-YYYY HH:MM:SS>
  
  # Execution fields (set by task type skill)
  next_task_type: <Task Type> | null
  require_human_review: true | false
  auto_proceed: true | false  # From task type skill input, flows to auto_proceed
  task_output_links: [<links>] | null
  {Dynamic Attributes}: <from task type skill>   # Fully dynamic per task type
  
  # Closing fields (set by category skill)
  category_level_change_summary: <≤100 words> | null
  
  # Control fields
  auto_proceed: true | false  # Set from auto_proceed output

pending → in_progress
in_progress → completed | blocked | deferred | cancelled
blocked → in_progress
deferred → in_progress

1. Match request to task type using Task Types Registry below
2. Derive category from task type suffix
3. Check task:
   - IF task not exists → Create with status: pending
   - ELSE IF exists AND assigned to you → Continue
   - ELSE → STOP
4. **[MANDATORY]** Load task-board-management skill to create/update tasks on board
   → This step CANNOT be skipped
   → Tasks MUST appear on board BEFORE proceeding to Step 2
5. IF task type defines next_task_type → Create ALL chained tasks upfront
6. **[VERIFICATION]** Confirm all tasks are visible on task board before proceeding

1. Read task board at x-ipe-docs/planning/task-board.md
2. Search for task_id in Active Tasks section
3. IF task NOT found:
   → ⛔ STOP execution
   → Log: "Task {task_id} not found on board. Returning to Step 1."
   → Return to Step 1 and create task on board
4. IF task found but status is not pending/blocked:
   → ⛔ STOP execution
   → Log: "Task {task_id} has invalid status for starting: {status}"

CALL git-version-control skill:
  operation: status
  directory: {project_root}

IF not a git repository:
  CALL git-version-control skill:
    operation: init
    directory: {project_root}
  
  CALL git-version-control skill:
    operation: create_gitignore
    directory: {project_root}
    tech_stack: {detect from project or ask human}

1. Load task type skill: task-type-{task_type} or task-type-{task_type}-@{category}
2. Pass Task Data Model to skill
3. Check task type DoR (defined in skill)
4. Execute core work (defined in skill)
5. Check task type DoD (defined in skill)
6. Collect skill output into Task Data Model

Output:
  status: <new status>
  next_task_type: <task type> | null
  require_human_review: true | false
  task_output_links: [<links>] | null
  # Plus any dynamic attributes the skill defines
  {dynamic_attribute_1}: <value>
  {dynamic_attribute_2}: <value>
  ...

1. MANDATORY: Load skill task-board-management
   → Update task status on board
   → Pass Task Data Model

2. IF category != "Standalone":
   TRY:
     → Load skill @{category}+{category-skill-name}
     → Pass Task Data Model
     → Collect category_level_change_summary
   CATCH SkillNotFound:
     → Log: "No category-level skill found for {category}, skipping"
     → Continue without error (category_level_change_summary = null)

IF task_output_links is NOT empty AND files were created/modified:
  CALL git-version-control skill:
    operation: add
    directory: {project_root}
    files: null  # Stage all changes
  
  CALL git-version-control skill:
    operation: commit
    directory: {project_root}
    task_data:
      task_id: {task_id}
      task_description: {task_description}
      feature_id: {feature_id | null}
      # Pass full Task Data Model for context

OPTIONAL - Push to remote (based on project settings or human preference):
  IF auto_push = true:
    CALL git-version-control skill:
      operation: push
      directory: {project_root}

IF require_human_review = true AND auto_proceed = false AND global_auto_proceed = false:
   → Output summary and STOP for human review
ELSE:
   → Skip human review (auto-proceed overrides)

> Task ID: <task_id>
> Task Type: <task_type>
> Description: <task_description>
> Category: <category>
> Assignee: <role_assigned>
> Status: <status>
> Category Changes: <category_level_change_summary>
> Require Human Review: <require_human_review>
> Task Output Links: <task_output_links>
> Auto Proceed: <auto_proceed>  # From task type skill completion output
> --- Dynamic Attributes ---
> <attr_1>: <value>
> <attr_2>: <value>
> ...

1. Read Global Auto-Proceed setting from task-board.md (Global Settings section)
   → Default to false if not found
2. Set effective_auto_proceed = auto_proceed OR global_auto_proceed

IF effective_auto_proceed = true AND next_task_type EXISTS:
   → Find next task on board (already created in Step 1)
   → Start execution from Step 2
ELSE:
   → STOP (wait for human)

Match: "implement" → Code Implementation
Category: feature-stage
Description: "Implement user login feature with authentication"

⚠️ MANDATORY: Create tasks on board BEFORE proceeding
→ Load task-board-management skill
→ Create: TASK-001 (Code Implementation) - status: pending
→ Create: TASK-002 (Feature Closing) - status: pending
→ Verify all tasks appear in Active Tasks section of task-board.md

✓ Read task-board.md
✓ Find TASK-001 in Active Tasks section
✓ Confirm status: pending (valid for starting)
✓ Git repository initialized
→ Update TASK-001 status: pending → in_progress

Load: task-type-code-implementation
Work: Write code, tests
Output:
  status: completed
  next_task_type: Feature Closing
  require_human_review: false
  task_output_links: [src/auth/login.ts, tests/auth/login.test.ts]
  feature_id: FEATURE-001
  feature_phase: Code Implementation

Load: task-board-management → Update TASK-001 to completed
Load: feature-stage+feature-board-management → Update feature status
Output:
  category_level_change_summary: "FEATURE-001 updated to Done Code Implementation"

✓ Board updated
✓ Feature board updated
Output standard summary

auto_proceed = true, next_task_type = Feature Closing
→ Start TASK-002 from Step 2