apiVersion: 100monkeys.ai/v1      # required; must be exactly this value
kind: Workflow                     # required; must be exactly "Workflow"

metadata:
  name: dev-pipeline               # required; unique DNS-label name (lowercase, alphanumeric, hyphens)
  version: "1.0.0"                 # required; semantic version. (name + version) must be unique.
                                   # Overwriting an existing version requires the `force` parameter in management tools.
  description: "Iterative code generation with multi-judge validation."  # optional
  labels:                          # optional; key-value pairs for filtering and discovery
    category: development
    pattern: iterative-refinement
  annotations:                     # optional; non-identifying metadata
    docs: "https://docs.example.com/workflows/dev-pipeline"

spec:
  initial_state: GENERATE          # required; name of the first state to enter

  # Optional: global constants available to all states via {{workflow.context.KEY}}
  context:
    max_iterations: 10
    validation_threshold: 0.95

  # Optional: workflow-level shared storage (volumes accessible by any state)
  storage:
    workspace:                     # default shared workspace; auto-created at workflow start
      storage_class: ephemeral     # ephemeral | persistent
      ttl_hours: 1
      size_limit_mb: 1000
    shared_volumes:
      - name: code-artifacts
        storage_class: ephemeral
        ttl_hours: 24
        size_limit_mb: 500

  # Required: state machine definition (map of state name → state definition)
  states:

    GENERATE:
      kind: Agent                  # StateKind: Agent | System | Human | ParallelAgents | ContainerRun | ParallelContainerRun | Subworkflow
      agent: coder-v1              # required for Agent kind; deployed agent name or UUID
      input: |                     # Handlebars template rendered as the agent's task input
        {{#if blackboard.iteration_number}}
        Iteration {{blackboard.iteration_number}} failed.
        Error: {{state.feedback}}
        Fix the code.
        {{else}}
        {{intent}}
        {{/if}}
      volumes:                     # optional volume mounts for this state
        - volume: "{{workflow.storage.workspace}}"
          mount_path: /workspace
          access_mode: read-write
      transitions:
        - condition: always        # unconditional; first matching transition wins
          target: EXECUTE

    EXECUTE:
      kind: System
      command: python main.py      # required for System kind; shell command (Handlebars supported)
      env:
        CODE: "{{GENERATE.output}}"
        PYTHONPATH: /workspace
      transitions:
        - condition: exit_code_zero
          target: VALIDATE
        - condition: exit_code_non_zero
          target: REFINE
          feedback: "Execution failed: {{EXECUTE.output.stderr}}"

    VALIDATE:
      kind: Agent
      agent: judge-v1
      input: |
        Task: {{intent}}
        Output: {{EXECUTE.output.stdout}}
        Evaluate correctness and return JSON with score, confidence and reasoning.
      transitions:
        - condition: score_above
          threshold: 0.95
          target: COMPLETE
        - condition: score_below
          threshold: 0.95
          target: REFINE
          feedback: "{{VALIDATE.output.reasoning}}"

    AWAIT_APPROVAL:
      kind: Human
      prompt: |                    # required for Human kind; message shown to operator
        Review the generated output and approve or reject.
        Output: {{EXECUTE.output.stdout}}
      timeout: 3600s               # optional; omit to wait indefinitely
      default_response: reject     # optional; value taken if timeout elapses without signal
      transitions:
        - condition: input_equals_yes
          target: COMPLETE
        - condition: input_equals_no
          target: REFINE
          feedback: "{{human.feedback}}"

    AUDIT:
      kind: ParallelAgents
      agents:
        - agent: reviewer-v1
          input: "Review code quality: {{GENERATE.output}}"
          weight: 1.0              # optional; weight for consensus calculation (default 1.0)
          timeout_seconds: 120     # optional; per-agent timeout (default 60)
          poll_interval_ms: 500    # optional; polling interval (default 500)
        - agent: security-v1
          input: "Security audit: {{GENERATE.output}}"
          weight: 2.0              # security weighted higher
          timeout_seconds: 180
      consensus:
        strategy: weighted_average # weighted_average | majority | unanimous | best_of_n
        threshold: 0.85
        min_agreement_confidence: 0.75
        min_judges_required: 2     # optional; minimum judges that must complete (default 1)
        confidence_weighting:
          agreement_factor: 0.7    # weight for inter-judge agreement; sums to 1.0 with self_confidence_factor
          self_confidence_factor: 0.3
      transitions:
        - condition: consensus
          threshold: 0.85
          agreement: 0.75
          target: COMPLETE
        - condition: score_below
          threshold: 0.85
          target: REFINE
          feedback: "Audit failed (score: {{AUDIT.consensus.score}}): {{AUDIT.agents.0.output}}"

    REFINE:
      kind: System
      command: update_context
      env:
        ITERATION: "{{blackboard.iteration_number + 1}}"
        ERRORS: "{{state.feedback}}"
      transitions:
        - condition: custom
          expression: "{{blackboard.iteration_number < workflow.context.max_iterations}}"
          target: GENERATE
        - condition: custom
          expression: "{{blackboard.iteration_number >= workflow.context.max_iterations}}"
          target: FAILED

    COMPLETE:
      kind: System
      command: finalize
      transitions: []              # empty transitions list = terminal state

    FAILED:
      kind: System
      command: "echo 'Max iterations reached'"
      transitions: []              # terminal state

metadata:
  name: data-pipeline
  version: "1.0.0"
  input_schema:
    type: object
    properties:
      dataset_path:
        type: string
        description: Path to the input dataset
      environment:
        type: string
        enum: [staging, production]
    required:
      - dataset_path
      - environment

metadata:
  name: invoice-pipeline
  description: "Processes and validates invoice documents."
  input_schema:
    type: object
    required:
      - document_text
      - vendor_id
    properties:
      document_text:
        type: string
        description: "Raw invoice text to process."
      vendor_id:
        type: string
        description: "Vendor identifier for routing."
      currency:
        type: string
        enum: ["USD", "EUR", "GBP"]
        description: "Currency for amount normalization. Default: USD."
      strict_validation:
        type: boolean
        description: "Whether to apply strict validation rules. Default: false."

aegis workflow run invoice-pipeline \
  --input '{"document_text": "Invoice #1234...", "vendor_id": "acme-corp", "currency": "USD"}'

{
  "status": "success|failed",
  "output": "<agent final text output>",
  "score": 0.91,
  "iterations": 2
}

POST /v1/workflows/executions/{execution_id}/signal
Content-Type: application/json

{ "response": "approved" }

{
  "consensus": {
    "score": 0.92,
    "confidence": 0.85,
    "strategy": "weighted_average",
    "metadata": {}
  },
  "individual_results": [
    { "agent_id": "reviewer-v1", "score": 0.9, "confidence": 0.88, "reasoning": "..." }
  ],
  "agents": [
    { "agent_id": "reviewer-v1", "output": "{\"score\": 0.9, ...}", "weight": 1.0 }
  ]
}

{
  "exit_code": 0,
  "stdout": "<captured stdout, up to 1 MB>",
  "stderr": "<captured stderr, up to 1 MB>",
  "duration_ms": 4321
}

{
  "unit-tests": { "exit_code": 0, "stdout": "...", "stderr": "", "duration_ms": 12300 },
  "lint":       { "exit_code": 1, "stdout": "", "stderr": "error[E0...]", "duration_ms": 870 },
  "format-check": { "exit_code": 0, "stdout": "", "stderr": "", "duration_ms": 410 }
}

RUN_PIPELINE:
  kind: Subworkflow
  workflow_id: data-pipeline-v2
  mode: blocking
  result_key: pipeline_output
  input: "{{workflow.context.task}}"
  timeout: 1800s
  transitions:
    - condition: on_success
      target: PROCESS_RESULT
    - condition: on_failure
      target: HANDLE_ERROR
      feedback: "Child workflow failed: {{RUN_PIPELINE.result}}"

START_BACKGROUND_JOB:
  kind: Subworkflow
  workflow_id: nightly-cleanup
  mode: fire_and_forget
  input: |
    {"environment": "{{blackboard.deploy_env}}"}
  transitions:
    - condition: on_success
      target: CONTINUE_MAIN_FLOW

{
  "status": "success",
  "result": "<child workflow's final output>",
  "child_execution_id": "wfx-child-a1b2c3d4-..."
}

{
  "status": "success",
  "child_execution_id": "wfx-child-a1b2c3d4-..."
}

spec:
  context:
    base_currency: "USD"
  states:
    extract:
      kind: agent
      agent: invoice-extractor
      input_template: '{"text": "{{input.document_text}}", "currency": "{{workflow.context.base_currency}}"}'
      transitions:
        - on: success
          next: validate
    validate:
      kind: agent
      agent: quality-gate
      input_template: '{"artifact": "{{blackboard.extract}}", "criteria": ["amounts-balance", "vendor-exists"]}'
      transitions:
        - on: success
          next: complete
    complete:
      kind: system
      command: "echo done"

input: |
  {{#if blackboard.iteration_number}}
  Attempt {{blackboard.iteration_number}} failed: {{state.feedback}}
  {{else}}
  {{intent}}
  {{/if}}

{{{{ ERROR: missing key 'GENERATE.output' — state GENERATE has not yet completed }}}}

{
  "score": 0.85,
  "confidence": 0.92,
  "reasoning": "The code meets requirements with minor style issues.",
  "suggestions": ["Add type hints", "Improve error handling"],
  "verdict": "pass"
}

apiVersion: 100monkeys.ai/v1
kind: Workflow

metadata:
  name: 100monkeys-classic
  version: "1.0.0"
  description: "Classic iterative refinement loop"
  labels:
    category: iterative
    pattern: generate-execute-validate-refine

spec:
  context:
    max_iterations: 10
    validation_threshold: 0.95

  initial_state: GENERATE

  states:
    GENERATE:
      kind: Agent
      agent: "{{input.agent_id}}"
      input: |
        {{#if blackboard.iteration_number}}
        Iteration {{blackboard.iteration_number}} — previous attempt failed.

        --- PREVIOUS CODE ---
        {{blackboard.previous_code}}

        --- ERRORS ---
        {{blackboard.validation_errors}}

        Fix the code.
        {{else}}
        {{intent}}
        {{/if}}
      transitions:
        - condition: always
          target: EXECUTE

    EXECUTE:
      kind: System
      command: "{{input.command}}"
      env:
        CODE: "{{GENERATE.output}}"
      transitions:
        - condition: exit_code_zero
          target: VALIDATE
        - condition: exit_code_non_zero
          target: REFINE
          feedback: "Execution failed: {{EXECUTE.output.stderr}}"

    VALIDATE:
      kind: Agent
      agent: "{{input.judge_id}}"
      input: |
        Task: {{intent}}
        Output: {{EXECUTE.output.stdout}}

        Validate and respond with JSON:
        {"valid": bool, "score": 0.0-1.0, "reasoning": "..."}
      transitions:
        - condition: score_above
          threshold: 0.95
          target: COMPLETE
        - condition: score_below
          threshold: 0.95
          target: REFINE
          feedback: "{{VALIDATE.output.reasoning}}"

    REFINE:
      kind: System
      command: update_blackboard
      env:
        ITERATION: "{{blackboard.iteration_number + 1}}"
        CODE: "{{GENERATE.output}}"
        ERRORS: "{{state.feedback}}"
      transitions:
        - condition: custom
          expression: "{{blackboard.iteration_number < workflow.context.max_iterations}}"
          target: GENERATE
        - condition: custom
          expression: "{{blackboard.iteration_number >= workflow.context.max_iterations}}"
          target: FAILED

    COMPLETE:
      kind: System
      command: echo
      env:
        RESULT: "{{EXECUTE.output.stdout}}"
      transitions: []

    FAILED:
      kind: System
      command: echo
      env:
        REASON: "Max iterations ({{workflow.context.max_iterations}}) reached"
      transitions: []

apiVersion: 100monkeys.ai/v1
kind: Workflow

metadata:
  name: the-forge
  version: "1.0.0"
  description: "Constitutional Development Lifecycle with adversarial testing"
  labels:
    category: development
    pattern: constitutional-lifecycle

spec:
  context:
    max_code_iterations: 5
    constitution_path: constitution.md

  initial_state: ANALYZE

  states:
    ANALYZE:
      kind: Agent
      agent: requirements-ai-v1
      input: |
        User request: {{input.user_request}}
        Codebase: {{input.codebase}}
        Generate requirements (functional, non-functional, acceptance criteria).
      transitions:
        - condition: always
          target: AWAIT_REQUIREMENTS_APPROVAL

    AWAIT_REQUIREMENTS_APPROVAL:
      kind: Human
      prompt: |
        Requirements:
        {{ANALYZE.output}}

        Approve? (yes/no)
      timeout: 3600s
      transitions:
        - condition: input_equals_yes
          target: ARCHITECT
        - condition: input_equals_no
          target: ANALYZE
          feedback: "{{human.feedback}}"

    ARCHITECT:
      kind: Agent
      agent: architect-ai-v1
      input: |
        Requirements: {{ANALYZE.output}}
        Constitution: {{workflow.context.constitution_path}}
        Design system architecture.
      transitions:
        - condition: always
          target: AWAIT_ARCH_APPROVAL

    AWAIT_ARCH_APPROVAL:
      kind: Human
      prompt: |
        Architecture:
        {{ARCHITECT.output}}

        Approve? (yes/no)
      timeout: 3600s
      transitions:
        - condition: input_equals_yes
          target: TEST
        - condition: input_equals_no
          target: ARCHITECT
          feedback: "{{human.feedback}}"

    TEST:
      kind: Agent
      agent: tester-ai-v1
      input: |
        Requirements: {{ANALYZE.output}}
        Architecture: {{ARCHITECT.output}}
        Write TDD tests (pytest).
      transitions:
        - condition: always
          target: CODE

    CODE:
      kind: Agent
      agent: coder-ai-v1
      input: |
        Tests: {{TEST.output}}
        Architecture: {{ARCHITECT.output}}
        Constitution: {{workflow.context.constitution_path}}
        Implement code to pass tests.
      transitions:
        - condition: always
          target: EXECUTE_TESTS

    EXECUTE_TESTS:
      kind: System
      command: pytest tests/ -v
      env:
        PYTHONPATH: /workspace
      transitions:
        - condition: exit_code_zero
          target: AUDIT
        - condition: exit_code_non_zero
          target: CODE
          feedback: "Tests failed: {{EXECUTE_TESTS.output.stderr}}"

    AUDIT:
      kind: ParallelAgents
      agents:
        - agent: reviewer-ai-v1
          input: "Review code quality: {{CODE.output}}"
          weight: 1.0
          timeout_seconds: 120
        - agent: critic-ai-v1
          input: "Adversarial review — try to break this code: {{CODE.output}}"
          weight: 1.5
          timeout_seconds: 90
        - agent: security-ai-v1
          input: "Security audit: {{CODE.output}}"
          weight: 2.0
          timeout_seconds: 180
      consensus:
        strategy: weighted_average
        threshold: 0.95
        min_agreement_confidence: 0.8
        min_judges_required: 2
        confidence_weighting:
          agreement_factor: 0.8
          self_confidence_factor: 0.2
      transitions:
        - condition: consensus
          threshold: 0.95
          agreement: 0.8
          target: COMPLETE
        - condition: score_below
          threshold: 0.95
          target: CODE
          feedback: |
            Audit failed (score: {{AUDIT.consensus.score}}, confidence: {{AUDIT.consensus.confidence}}):
            Reviewer: {{AUDIT.agents.0.output}}
            Critic:   {{AUDIT.agents.1.output}}
            Security: {{AUDIT.agents.2.output}}

    COMPLETE:
      kind: System
      command: finalize
      env:
        CODE: "{{CODE.output}}"
        TESTS: "{{TEST.output}}"
        AUDIT_SCORE: "{{AUDIT.consensus.score}}"
      transitions: []

apiVersion: 100monkeys.ai/v1
kind: Workflow

metadata:
  name: agent-cicd-pipeline
  version: "1.0.0"
  description: "AI-augmented delivery pipeline"
  labels:
    pattern: cicd

spec:
  initial_state: GENERATE

  storage:
    shared_volumes:
      - name: workspace
        persistent: true

  states:
    GENERATE:
      kind: Agent
      agent: coder-v2
      input: |
        {{intent}}
      volumes:
        - name: workspace
          mount_path: /workspace
      transitions:
        - condition: on_success
          target: BUILD
        - condition: on_failure
          target: FAILED

    BUILD:
      kind: ContainerRun
      name: "Compile"
      image: "rust:1.75-alpine"
      command: ["cargo", "build", "--release"]
      workdir: "/workspace"
      volumes:
        - name: workspace
          mount_path: /workspace
      resources:
        cpu: 2000
        memory: "4Gi"
        timeout: "10m"
      transitions:
        - condition: exit_code_zero
          target: TEST
        - condition: exit_code_non_zero
          target: FIX_BUILD
          feedback: "{{BUILD.output.stderr}}"

    FIX_BUILD:
      kind: Agent
      agent: coder-v2
      input: |
        Build failed — fix the errors:
        {{state.feedback}}
      volumes:
        - name: workspace
          mount_path: /workspace
      transitions:
        - condition: on_success
          target: BUILD
        - condition: on_failure
          target: FAILED

    TEST:
      kind: ParallelContainerRun
      steps:
        - name: unit-tests
          image: "rust:1.75-alpine"
          command: ["cargo", "test", "--workspace"]
          workdir: "/workspace"
          volumes:
            - name: workspace
              mount_path: /workspace
          resources:
            timeout: "5m"
        - name: lint
          image: "rust:1.75-alpine"
          command: ["cargo", "clippy", "--all-targets", "--", "-D", "warnings"]
          workdir: "/workspace"
          volumes:
            - name: workspace
              mount_path: /workspace
        - name: format-check
          image: "rust:1.75-alpine"
          command: ["cargo", "fmt", "--check"]
          workdir: "/workspace"
          volumes:
            - name: workspace
              mount_path: /workspace
      completion: all_succeed
      transitions:
        - condition: on_success
          target: REVIEW
        - condition: on_failure
          target: FIX_TESTS

    FIX_TESTS:
      kind: Agent
      agent: coder-v2
      input: |
        Tests/lint failed:
        Unit: {{TEST.output.unit-tests.stderr}}
        Lint: {{TEST.output.lint.stderr}}
        Format: {{TEST.output.format-check.stderr}}
      volumes:
        - name: workspace
          mount_path: /workspace
      transitions:
        - condition: on_success
          target: BUILD
        - condition: on_failure
          target: FAILED

    REVIEW:
      kind: ParallelAgents
      agents:
        - agent: security-auditor
          input: "Security audit: /workspace"
          weight: 1.5
          timeout_seconds: 300
        - agent: architecture-reviewer
          input: "Architecture review: /workspace"
          weight: 1.0
          timeout_seconds: 180
      consensus:
        strategy: weighted_average
        threshold: 0.8
        min_judges_required: 2
      transitions:
        - condition: consensus
          threshold: 0.8
          agreement: 0.75
          target: DEPLOY
        - condition: score_below
          threshold: 0.8
          target: FIX_REVIEW
          feedback: "{{REVIEW.consensus.score}} — {{REVIEW.agents.0.output}}"

    FIX_REVIEW:
      kind: Agent
      agent: coder-v2
      input: |
        Review feedback:
        {{state.feedback}}
      volumes:
        - name: workspace
          mount_path: /workspace
      transitions:
        - condition: on_success
          target: BUILD
        - condition: on_failure
          target: FAILED

    DEPLOY:
      kind: ContainerRun
      name: "Push to Registry"
      image: "docker:24-cli"
      command:
        - sh
        - -c
        - |
          docker build -t {{blackboard.registry}}/{{blackboard.app}}:{{blackboard.version}} /workspace
          docker push {{blackboard.registry}}/{{blackboard.app}}:{{blackboard.version}}
      shell: true
      registry_credentials: "secret:cicd/docker-registry"
      volumes:
        - name: workspace
          mount_path: /workspace
      resources:
        timeout: "15m"
      transitions:
        - condition: exit_code_zero
          target: DONE
        - condition: exit_code_non_zero
          target: FAILED

    DONE:
      kind: System
      command: "echo done"
      transitions: []

    FAILED:
      kind: System
      command: "echo failed"
      transitions: []

SECURITY_GATE:
  kind: ParallelAgents
  agents:
    - agent: static-analyzer
      input: "{{CODE.output}}"
      timeout_seconds: 300
    - agent: penetration-tester
      input: "{{CODE.output}}"
      timeout_seconds: 600
    - agent: security-expert
      input: "{{CODE.output}}"
      timeout_seconds: 180
  consensus:
    strategy: unanimous
    threshold: 0.95
    min_judges_required: 3
  transitions:
    - condition: score_above
      threshold: 0.94
      target: PRODUCTION
    - condition: always
      target: SECURITY_FAILED
      feedback: "Security gate failed — not all judges approved at 95%"