# Default TAKT Workflow
# Plan -> Coder -> Architect Review -> AI Review -> Security Review -> Supervisor Approval

name: default
description: Standard development workflow with planning and specialized reviews

max_iterations: 20

initial_step: plan

steps:
  - name: plan
    agent: ~/.takt/agents/default/planner.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Output analysis results with the following tags:
      - [PLANNER:DONE] Analysis complete
      - [PLANNER:BLOCKED] Insufficient info (list clarifications needed)
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: plan (Task Analysis)
      - Report Directory: .takt/reports/{report_dir}/
      - Report File: .takt/reports/{report_dir}/00-plan.md

      ## User Request
      {task}

      ## Previous Response (when returned from implement)
      {previous_response}

      ## Instructions
      Analyze the task and create an implementation plan.

      **Note:** If returned from implement step (Previous Response exists),
      review and revise the plan based on that feedback (replan).

      **Tasks:**
      1. Understand the requirements
      2. Identify impact scope
      3. Decide implementation approach

      **Report output:** Output to the `Report File` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Report format:**
      ```markdown
      # Task Plan

      ## Original Request
      {User's request as-is}

      ## Analysis Results

      ### Objective
      {What needs to be achieved}

      ### Scope
      {Impact scope}

      ### Implementation Approach
      {How to proceed}

      ## Clarifications Needed (if any)
      - {Unclear points or items requiring confirmation}
      ```
    pass_previous_response: true
    transitions:
      - condition: done
        next_step: implement
      - condition: blocked
        next_step: ABORT

  - name: implement
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Always include these tags when work is complete:
      - [CODER:DONE] Implementation complete
      - [CODER:BLOCKED] Cannot decide/insufficient info

      **Important**: When in doubt, `[BLOCKED]`. Don't decide on your own.
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: implement
      - Report Directory: .takt/reports/{report_dir}/
      - Report Files:
        - Scope: .takt/reports/{report_dir}/01-coder-scope.md
        - Decisions: .takt/reports/{report_dir}/02-coder-decisions.md

      ## User Request
      {task}

      ## Additional User Inputs
      {user_inputs}

      ## Instructions
      Follow the plan from the plan step and implement.
      Refer to the plan report (00-plan.md) and proceed with implementation.

      **Report output:** Output to the `Report Files` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Scope report format (create at implementation start):**
      ```markdown
      # Change Scope Declaration

      ## Task
      {One-line task summary}

      ## Planned Changes
      | Type | File |
      |------|------|
      | Create | `src/example.ts` |
      | Modify | `src/routes.ts` |

      ## Estimated Size
      Small / Medium / Large

      ## Impact Scope
      - {Affected modules or features}
      ```

      **Decisions report format (on completion, only if decisions were made):**
      ```markdown
      # Decision Log

      ## 1. {Decision Content}
      - **Background**: {Why the decision was needed}
      - **Options Considered**: {List of options}
      - **Reason**: {Why this option was chosen}
      ```
    transitions:
      - condition: done
        next_step: review
      - condition: blocked
        next_step: plan

  - name: review
    agent: ~/.takt/agents/default/architect.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - WebSearch
      - WebFetch
    status_rules: |
      ## Judgment Criteria

      | Situation | Judgment |
      |-----------|----------|
      | Structural issues | REJECT |
      | Design principle violations | REJECT |
      | Security issues | REJECT |
      | Insufficient tests | REJECT |
      | Improvements needed (non-blocking but should be addressed) | IMPROVE |
      | No issues | APPROVE |

      **How to use IMPROVE:**
      - Design is acceptable but there are points that could be better
      - Minor issues you want fixed before proceeding to next step
      - Examples: naming improvements, small refactoring, adding comments

      ## Status Output Format

      Output review results with the following tags:
      - [ARCHITECT:APPROVE] No issues
      - [ARCHITECT:IMPROVE] Minor improvements needed
      - [ARCHITECT:REJECT] Structural changes required

      ### Output Examples

      **REJECT case:**
      ```
      [ARCHITECT:REJECT]

      ### Issues

      1. **File Size Exceeded**
         - Location: `src/services/user.ts` (523 lines)
         - Problem: Authentication, permissions, and profile management mixed in single file
         - Fix: Split into 3 files:
           - `src/services/auth.ts` - Authentication
           - `src/services/permission.ts` - Permissions
           - `src/services/profile.ts` - Profile
      ```

      **APPROVE case:**
      ```
      [ARCHITECT:APPROVE]

      ### Positive Points
      - Appropriate module organization
      - Single responsibility maintained

      ### Improvement Suggestions (Optional)
      - Consider organizing shared utilities in `utils/` in the future
      ```
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: review (Architecture Review)
      - Report Directory: .takt/reports/{report_dir}/
      - Report File: .takt/reports/{report_dir}/03-architect-review.md

      ## Original User Request (Initial request from workflow start)
      {task}

      ## Git Diff
      ```diff
      {git_diff}
      ```

      ## Instructions
      Focus on **architecture and design** review. Do NOT review AI-specific issues (that's the next step).

      Review the changes and provide feedback.

      **Report output:** Output to the `Report File` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Report format:**
      ```markdown
      # Architecture Review

      ## Result: APPROVE / IMPROVE / REJECT

      ## Summary
      {1-2 sentences summarizing result}

      ## Reviewed Perspectives
      - [x] Structure & Design
      - [x] Code Quality
      - [x] Change Scope

      ## Issues (if REJECT)
      | # | Location | Issue | Fix |
      |---|----------|-------|-----|
      | 1 | `src/file.ts:42` | Issue description | Fix method |

      ## Improvement Suggestions (optional, non-blocking)
      - {Future improvement suggestions}
      ```

      **Cognitive load reduction rules:**
      - APPROVE + no issues → Summary only (5 lines or less)
      - APPROVE + minor suggestions → Summary + suggestions (15 lines or less)
      - REJECT → Issues in table format (30 lines or less)
    transitions:
      - condition: approved
        next_step: ai_review
      - condition: improve
        next_step: improve
      - condition: rejected
        next_step: fix

  - name: improve
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Always include these tags when work is complete:
      - [CODER:DONE] Improvements complete
      - [CODER:BLOCKED] Cannot decide/insufficient info
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: improve

      ## Architect Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      ## Original User Request (Initial request from workflow start - for reference)
      {task}

      ## Additional User Inputs
      {user_inputs}

      ## Instructions
      **Important**: Address the Architect's improvement suggestions.
      These are minor improvements, not major design issues.

      Make improvements such as:
      - Naming improvements
      - Small refactoring
      - Adding/fixing comments
      - Code organization

    pass_previous_response: true
    transitions:
      - condition: done
        next_step: review
      - condition: blocked
        next_step: plan

  - name: ai_review
    agent: ~/.takt/agents/default/ai-reviewer.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - WebSearch
      - WebFetch
    status_rules: |
      ## Judgment Criteria

      | Situation | Judgment |
      |-----------|----------|
      | Incorrect assumptions (affecting behavior) | REJECT |
      | Plausible-but-wrong code | REJECT |
      | Significant context mismatch with codebase | REJECT |
      | Scope creep | APPROVE (with warning noted) |
      | Minor style deviations only | APPROVE |
      | Code fits context and works | APPROVE |

      **Note:** Scope creep is noted as a warning but doesn't warrant REJECT alone. Some tasks require large changes.

      ## Status Output Format

      Output review results with the following tags:
      - [AI_REVIEW:APPROVE] No AI-specific issues
      - [AI_REVIEW:REJECT] Issues found
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: ai_review (AI-Generated Code Review)
      - Report Directory: .takt/reports/{report_dir}/
      - Report File: .takt/reports/{report_dir}/04-ai-review.md

      ## Original User Request (Initial request from workflow start)
      {task}

      ## Git Diff
      ```diff
      {git_diff}
      ```

      ## Instructions
      Review the code for AI-specific issues:
      - Assumption validation
      - Plausible but wrong patterns
      - Context fit with existing codebase
      - Scope creep detection

      **Report output:** Output to the `Report File` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Report format:**
      ```markdown
      # AI-Generated Code Review

      ## Result: APPROVE / REJECT

      ## Summary
      {One sentence summarizing result}

      ## Verified Items
      | Aspect | Result | Notes |
      |--------|--------|-------|
      | Assumption validity | ✅ | - |
      | API/Library existence | ✅ | - |
      | Context fit | ✅ | - |
      | Scope | ✅ | - |

      ## Issues (if REJECT)
      | # | Category | Location | Issue |
      |---|----------|----------|-------|
      | 1 | Hallucinated API | `src/file.ts:23` | Non-existent method |
      ```

      **Cognitive load reduction rules:**
      - No issues → Summary 1 line + check table only (10 lines or less)
      - Issues found → + Issues in table format (25 lines or less)
    transitions:
      - condition: approved
        next_step: security_review
      - condition: rejected
        next_step: ai_fix

  - name: ai_fix
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Always include these tags when work is complete:
      - [CODER:DONE] Fixes complete
      - [CODER:BLOCKED] Cannot decide/insufficient info
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: ai_fix

      ## AI Review Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      ## Original User Request (Initial request from workflow start - for reference)
      {task}

      ## Additional User Inputs
      {user_inputs}

      ## Instructions
      **Important**: Address the AI Reviewer's feedback.
      Focus on:
      - Correcting incorrect assumptions
      - Fixing plausible-but-wrong implementations
      - Aligning with existing codebase patterns
      - Removing scope creep

    pass_previous_response: true
    transitions:
      - condition: done
        next_step: review
      - condition: blocked
        next_step: plan

  - name: security_review
    agent: ~/.takt/agents/default/security.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - WebSearch
      - WebFetch
    status_rules: |
      ## Judgment Criteria

      | Situation | Judgment |
      |-----------|----------|
      | Critical vulnerability (Immediate REJECT) | REJECT |
      | Medium severity vulnerability | REJECT |
      | Minor issues/warnings only | APPROVE (note warnings) |
      | No security issues | APPROVE |

      ## Status Output Format

      Output review results with the following tags:
      - [SECURITY:APPROVE] No security issues
      - [SECURITY:REJECT] Vulnerabilities require fixes
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: security_review
      - Report Directory: .takt/reports/{report_dir}/
      - Report File: .takt/reports/{report_dir}/05-security-review.md

      ## Original User Request (Initial request from workflow start)
      {task}

      ## Git Diff
      ```diff
      {git_diff}
      ```

      ## Instructions
      Perform security review on the changes. Check for vulnerabilities including:
      - Injection attacks (SQL, Command, XSS)
      - Authentication/Authorization issues
      - Data exposure risks
      - Cryptographic weaknesses

      **Report output:** Output to the `Report File` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Report format:**
      ```markdown
      # Security Review

      ## Result: APPROVE / REJECT

      ## Severity: None / Low / Medium / High / Critical

      ## Check Results
      | Category | Result | Notes |
      |----------|--------|-------|
      | Injection | ✅ | - |
      | Auth/Authz | ✅ | - |
      | Data Protection | ✅ | - |
      | Dependencies | ✅ | - |

      ## Vulnerabilities (if REJECT)
      | # | Severity | Type | Location | Fix |
      |---|----------|------|----------|-----|
      | 1 | High | SQLi | `src/db.ts:42` | Use parameterized query |

      ## Warnings (non-blocking)
      - {Security recommendations}
      ```

      **Cognitive load reduction rules:**
      - No issues → Check table only (10 lines or less)
      - Warnings → + Warnings 1-2 lines (15 lines or less)
      - Vulnerabilities → + Table format (30 lines or less)
    transitions:
      - condition: approved
        next_step: supervise
      - condition: rejected
        next_step: security_fix

  - name: security_fix
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Always include these tags when work is complete:
      - [CODER:DONE] Security fixes complete
      - [CODER:BLOCKED] Cannot decide/insufficient info
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: security_fix

      ## Security Review Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      ## Original User Request (Initial request from workflow start - for reference)
      {task}

      ## Additional User Inputs
      {user_inputs}

      ## Instructions
      **Important**: Fix the vulnerabilities identified in the security review.
      Security issues require highest priority.

    pass_previous_response: true
    transitions:
      - condition: done
        next_step: security_review
      - condition: blocked
        next_step: plan

  - name: fix
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Status Output Format

      Always include these tags when work is complete:
      - [CODER:DONE] Fixes complete
      - [CODER:BLOCKED] Cannot decide/insufficient info
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: fix

      ## Architect Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      ## Original User Request (Initial request from workflow start - for reference)
      {task}

      ## Additional User Inputs
      {user_inputs}

      ## Instructions
      **Important**: Address the Architect's feedback.
      The "Original User Request" is reference information, not the latest instruction.
      Review the session conversation history and fix the issues raised by the Architect.

    pass_previous_response: true
    transitions:
      - condition: done
        next_step: review
      - condition: blocked
        next_step: plan

  - name: supervise
    agent: ~/.takt/agents/default/supervisor.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Bash
      - WebSearch
      - WebFetch
    status_rules: |
      ## Judgment Criteria

      | Situation | Judgment |
      |-----------|----------|
      | Requirements not met | REJECT |
      | Tests failing | REJECT |
      | Build fails | REJECT |
      | Workarounds remaining | REJECT |
      | All OK | APPROVE |

      **Principle**: When in doubt, REJECT. Don't give ambiguous approval.

      ## Status Output Format

      Output verification results with the following tags:
      - [SUPERVISOR:APPROVE] if ready to merge
      - [SUPERVISOR:REJECT] if issues found (specify the issues)
    instruction_template: |
      ## Workflow Context
      - Iteration: {iteration}/{max_iterations}
      - Step: supervise (final verification)
      - Report Directory: .takt/reports/{report_dir}/
      - Report Files:
        - Validation: .takt/reports/{report_dir}/06-supervisor-validation.md
        - Summary: .takt/reports/{report_dir}/summary.md

      ## Original User Request
      {task}

      ## Git Diff
      ```diff
      {git_diff}
      ```

      ## Instructions
      Run tests, verify the build, and perform final approval.

      **Workflow Overall Review:**
      1. Does the implementation match the plan (00-plan.md)?
      2. Were all review step issues addressed?
      3. Was the original task objective achieved?

      **Review Reports:** Read all reports in Report Directory and
      check for any unaddressed improvement suggestions.

      **Report output:** Output to the `Report Files` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {iteration}` section

      **Validation report format:**
      ```markdown
      # Final Validation Results

      ## Result: APPROVE / REJECT

      ## Validation Summary
      | Item | Status | Verification Method |
      |------|--------|---------------------|
      | Requirements met | ✅ | Matched against requirements list |
      | Tests | ✅ | `npm test` (N passed) |
      | Build | ✅ | `npm run build` succeeded |
      | Functional check | ✅ | Main flows verified |

      ## Deliverables
      - Created: {Created files}
      - Modified: {Modified files}

      ## Incomplete Items (if REJECT)
      | # | Item | Reason |
      |---|------|--------|
      | 1 | {Item} | {Reason} |
      ```

      **Summary report format (only if APPROVE):**
      ```markdown
      # Task Completion Summary

      ## Task
      {Original request in 1-2 sentences}

      ## Result
      ✅ Complete

      ## Changes
      | Type | File | Summary |
      |------|------|---------|
      | Create | `src/file.ts` | Summary description |

      ## Review Results
      | Review | Result |
      |--------|--------|
      | Architect | ✅ APPROVE |
      | AI Review | ✅ APPROVE |
      | Security | ✅ APPROVE |
      | Supervisor | ✅ APPROVE |

      ## Verification Commands
      ```bash
      npm test
      npm run build
      ```
      ```
    transitions:
      - condition: approved
        next_step: COMPLETE
      - condition: rejected
        next_step: plan