# 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)
#   {git_diff}          - Current uncommitted changes (git diff)
#   {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
    agent: ~/.takt/agents/default/planner.md
    report: 00-plan.md
    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

      **Report output:** Output to the `Report File` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {step_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}
      ```

  - name: implement
    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.

      **Report output:** Output to the `Report Files` specified above.
      - If file does not exist: Create new file
      - If file exists: Append with `## Iteration {step_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}
      ```

  - name: ai_review
    agent: ~/.takt/agents/default/ai-antipattern-reviewer.md
    report: 03-ai-review.md
    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: |
      ## Git Diff
      ```diff
      {git_diff}
      ```

      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 {step_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)

  - name: ai_fix
    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
    agent: ~/.takt/agents/default/architecture-reviewer.md
    report: 04-architect-review.md
    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: |
      ## Git Diff
      ```diff
      {git_diff}
      ```

      Focus on **architecture and design** review. Do NOT review AI-specific issues (that's the ai_review 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 {step_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)

  - name: improve
    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
    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
    agent: ~/.takt/agents/default/security-reviewer.md
    report: 05-security-review.md
    allowed_tools:
      - Read
      - Glob
      - Grep
      - Write
      - WebSearch
      - WebFetch
    rules:
      - condition: No security issues
        next: supervise
      - condition: Vulnerabilities require fix
        next: security_fix
    instruction_template: |
      ## Git Diff
      ```diff
      {git_diff}
      ```

      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 {step_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)

  - name: security_fix
    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
    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: |
      ## Git Diff
      ```diff
      {git_diff}
      ```

      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 {step_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
      ```
      ```