takt/resources/global/en/workflows/default.yaml

# Default TAKT Workflow
# Plan -> Coder -> AI Review -> Architect Review -> Security Review -> Supervisor Approval
#
# Boilerplate sections (Workflow Context, User Request, Previous Response,
# Additional User Inputs, Instructions heading) are auto-injected by buildInstruction().
# Only step-specific content belongs in instruction_template.
#
# Template Variables (available in instruction_template):
#   {iteration}         - Workflow-wide turn count (total steps executed across all agents)
#   {max_iterations}    - Maximum iterations allowed for the workflow
#   {step_iteration}    - Per-step iteration count (how many times THIS step has been executed)
#   {previous_response} - Output from the previous step (only when pass_previous_response: true)
#   {report_dir}        - Report directory name (e.g., "20250126-143052-task-summary")
#
# Step-level Fields:
#   report:  - Report file(s) for the step (auto-injected as Report File/Files in Workflow Context)
#              Single: report: 00-plan.md
#              Multiple: report:
#                          - Scope: 01-coder-scope.md
#                          - Decisions: 02-coder-decisions.md

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

max_iterations: 30

initial_step: plan

steps:
  - name: plan
    edit: false
    agent: ~/.takt/agents/default/planner.md
    report:
      name: 00-plan.md
      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}
        ```
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - Bash
      - WebSearch
      - WebFetch
    rules:
      - condition: Requirements are clear and implementable
        next: implement
      - condition: User is asking a question (not an implementation task)
        next: COMPLETE
      - condition: Requirements unclear, insufficient info
        next: ABORT
        appendix: |
          Clarifications needed:
          - {Question 1}
          - {Question 2}
    pass_previous_response: true
    instruction_template: |
      ## Previous Response (when returned from implement)
      {previous_response}

      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 (for implementation tasks):**
      1. Understand the requirements
      2. Identify impact scope
      3. Decide implementation approach

  - name: implement
    edit: true
    agent: ~/.takt/agents/default/coder.md
    report:
      - Scope: 01-coder-scope.md
      - Decisions: 02-coder-decisions.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    permission_mode: acceptEdits
    rules:
      - condition: Implementation complete
        next: ai_review
      - condition: Cannot proceed, insufficient info
        next: plan
    instruction_template: |
      Follow the plan from the plan step and implement.
      Refer to the plan report (00-plan.md) and proceed with implementation.

      **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}
      ```

  - name: ai_review
    edit: false
    agent: ~/.takt/agents/default/ai-antipattern-reviewer.md
    report:
      name: 03-ai-review.md
      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)
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - WebSearch
      - WebFetch
    rules:
      - condition: No AI-specific issues
        next: review
      - condition: AI-specific issues found
        next: ai_fix
    instruction_template: |
      Review the code for AI-specific issues:
      - Assumption validation
      - Plausible but wrong patterns
      - Context fit with existing codebase
      - Scope creep detection

  - name: ai_fix
    edit: true
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    permission_mode: acceptEdits
    rules:
      - condition: AI issues fixed
        next: review
      - condition: Cannot proceed, insufficient info
        next: plan
    instruction_template: |
      ## AI Review Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      **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

  - name: review
    edit: false
    agent: ~/.takt/agents/default/architecture-reviewer.md
    report:
      name: 04-architect-review.md
      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)
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - WebSearch
      - WebFetch
    rules:
      - condition: No issues found
        next: security_review
      - condition: Minor improvements needed
        next: improve
      - condition: Structural fix required
        next: fix
    instruction_template: |
      Focus on **architecture and design** review. Do NOT review AI-specific issues (that's the ai_review step).

      Review the changes and provide feedback.

  - name: improve
    edit: true
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    permission_mode: acceptEdits
    rules:
      - condition: Improvements complete
        next: review
      - condition: Cannot proceed, insufficient info
        next: plan
    instruction_template: |
      ## Architect Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      **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

  - name: fix
    edit: true
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    permission_mode: acceptEdits
    rules:
      - condition: Architect feedback addressed
        next: review
      - condition: Cannot proceed, insufficient info
        next: plan
    instruction_template: |
      ## Architect Feedback (This is the latest instruction - prioritize this)
      {previous_response}

      **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

  - name: security_review
    edit: false
    agent: ~/.takt/agents/default/security-reviewer.md
    report:
      name: 05-security-review.md
      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)
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - WebSearch
      - WebFetch
    rules:
      - condition: No security issues
        next: supervise
      - condition: Vulnerabilities require fix
        next: security_fix
    instruction_template: |
      Perform security review on the changes. Check for vulnerabilities including:
      - Injection attacks (SQL, Command, XSS)
      - Authentication/Authorization issues
      - Data exposure risks
      - Cryptographic weaknesses

  - name: security_fix
    edit: true
    agent: ~/.takt/agents/default/coder.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Edit
      - Write
      - Bash
      - WebSearch
      - WebFetch
    permission_mode: acceptEdits
    rules:
      - condition: Security fix complete
        next: security_review
      - condition: Cannot proceed, insufficient info
        next: plan
    instruction_template: |
      ## Security Review Feedback (This is the latest instruction - prioritize this)
      {previous_response}

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

  - name: supervise
    edit: false
    agent: ~/.takt/agents/default/supervisor.md
    report:
      - Validation: 06-supervisor-validation.md
      - Summary: summary.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - Bash
      - WebSearch
      - WebFetch
    rules:
      - condition: All checks passed
        next: COMPLETE
      - condition: Requirements unmet, tests failing, build errors
        next: plan
    instruction_template: |
      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.

      **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
      ```
      ```