Configuration

# Interactive setup wizard — creates config.yaml
pilot setup
 
# Validate config and dependencies
pilot doctor

adapters:
  github:
    enabled: true
    token: ${GITHUB_TOKEN}
    repo: "owner/repo"                    # owner/repo format
    project_path: "/path/to/local/repo"   # must match repo
    webhook_secret: ""                     # for HMAC verification (webhooks mode)
    pilot_label: "pilot"                   # label that triggers Pilot
 
    polling:
      enabled: true                       # poll for issues (vs webhooks)
      interval: 30s
      label: "pilot"
 
    stale_label_cleanup:
      enabled: true                       # auto-remove stale pilot-in-progress labels
      interval: 30m
      threshold: 1h                       # label age before cleanup

adapters:
  github:
    project_board:
      enabled: true
      project_number: 3                    # project number from the URL
      status_field: "Status"               # single-select field name
      statuses:
        in_progress: "In Dev"
        review: "Ready for Review"
        done: "Done"
        failed: "Blocked"

adapters:
  telegram:
    enabled: true
    bot_token: ${TELEGRAM_BOT_TOKEN}
    chat_id: "123456789"
    allowed_ids:
      - 123456789                         # your Telegram user/chat ID
    project_path: "/path/to/default/repo"
    polling: true                          # enable inbound message polling
    plain_text_mode: true                  # plain text instead of Markdown
 
    transcription:
      backend: "auto"                     # "whisper-api" or "auto"
      openai_api_key: ${OPENAI_API_KEY}
 
    rate_limit:
      enabled: true
      messages_per_minute: 20
      tasks_per_hour: 10
      burst_size: 5
 
    llm_classifier:
      enabled: false
      api_key: ${ANTHROPIC_API_KEY}       # falls back to env var
      timeout_seconds: 2
      history_size: 10
      history_ttl: 30m

executor:
  type: "claude-code"                     # "claude-code", "qwen-code", or "opencode"
  auto_create_pr: true
  direct_commit: false                    # commit directly to branch without PR
  detect_ephemeral: true                  # detect and skip ephemeral changes
  skip_self_review: false                 # skip self-review step
  use_worktree: false                     # execute tasks in isolated git worktrees
 
  claude_code:
    command: "claude"                     # path to claude CLI
    extra_args: []                        # additional CLI arguments
    planning_timeout: 2m                  # max time for epic planning before fallback to direct mode
 
  model_routing:
    enabled: false
    trivial: "claude-haiku"
    simple: "claude-sonnet-4-6"
    medium: "claude-sonnet-4-6"
    complex: "claude-opus-4-6"
 
  effort_routing:
    enabled: false
    trivial: "low"
    simple: "medium"
    medium: "high"
    complex: "max"
 
  timeout:
    default: "30m"
    trivial: "5m"
    simple: "10m"
    medium: "30m"
    complex: "60m"
 
  decompose:
    enabled: false
    min_complexity: "complex"             # only decompose complex tasks
    max_subtasks: 5                       # 2-10 range
    min_description_words: 50             # skip short descriptions

executor:
  hooks:
    enabled: false             # Enable Claude Code hooks
    run_tests_on_stop: true    # Stop gate: run tests before completion
    block_destructive: true    # PreToolUse: block destructive Bash commands
    lint_on_save: false        # PostToolUse: run linter after file edits

executor:
  stagnation:
    enabled: false
    warn_timeout: 10m
    pause_timeout: 20m
    abort_timeout: 30m
    warn_at_iteration: 8
    pause_at_iteration: 12
    abort_at_iteration: 15
    state_history_size: 5
    identical_states_threshold: 3
    grace_period: 30s
    commit_partial_work: true

executor:
  claude_code:
    use_session_resume: false    # Reuse session for self-review
    use_from_pr: false           # Resume PR context for CI fixes
    use_structured_output: false # Machine-readable classifier output

executor:
  navigator:
    auto_init: true
    templates_path: ""          # Optional custom templates path

executor:
  use_worktree: true

orchestrator:
  autopilot:
    enabled: false
    environment: "stage"                  # dev, stage, prod
    approval_source: "telegram"           # telegram, slack, github-review
 
    auto_review: true                     # self-review before PR
    auto_merge: true                      # merge after CI passes
    merge_method: "squash"                # squash, merge, rebase
 
    ci_wait_timeout: 30m
    dev_ci_timeout: 5m                    # shorter timeout for dev env
    ci_poll_interval: 30s
    required_checks:
      - test
      - lint
 
    auto_create_issues: true              # create fix issues on CI failure
    issue_labels:
      - pilot
      - autopilot-fix
    notify_on_failure: true
    max_failures: 3                       # max fix attempts before giving up
    max_merges_per_hour: 10               # rate limit merges
    approval_timeout: 1h
    merged_pr_scan_window: 30m            # scan for recently merged PRs
 
    github_review:
      poll_interval: 30s                  # poll for GitHub review decisions
 
    release:
      enabled: false
      trigger: "on_merge"
      version_strategy: "conventional_commits"
      tag_prefix: "v"
      generate_changelog: true
      notify_on_release: true
      require_ci: true

Implementation complete
  → Run gates in order: build → test → lint → coverage → ...
  → All required gates pass? → Create PR
  → Required gate fails?
      → retry (default): feed error to LLM, re-implement, re-run gates
      → fail: stop immediately, mark task as failed
      → warn: log warning, create PR anyway

    - name: coverage
      type: coverage
      command: "go test ./... -coverprofile=c.out && go tool cover -func=c.out"
      threshold: 80.0          # fail if coverage drops below 80%
      required: true           # block PR creation
      timeout: 10m

quality:
  on_failure:
    action: "retry"          # retry | fail | warn
    max_retries: 3           # global retry limit across all gates
    notify_on:
      - failed               # send notification on these statuses

    - name: lint
      type: lint
      command: "golangci-lint run ./..."
      failure_hint: "Fix linting errors. Common issues: unused imports, missing error checks, formatting."

┌─────────────┐     ┌──────────────┐     ┌───────────────┐     ┌──────────┐
│ New task     │────▶│ Check budget │────▶│ Within limits? │────▶│ Execute  │
│ arrives      │     │ (enforcer)   │     │                │     │ task     │
└─────────────┘     └──────────────┘     └───────┬────────┘     └────┬─────┘
                                                 │ No                │
                                          ┌──────▼──────┐     ┌─────▼──────┐
                                          │ Apply action │     │ Track cost │
                                          │ warn/pause/  │     │ per event  │
                                          │ stop         │     └────────────┘
                                          └─────────────┘

budget:
  enabled: true
  daily_limit: 50.00
  monthly_limit: 500.00

budget:
  enabled: true
  daily_limit: 50.00                      # USD per day
  monthly_limit: 500.00                   # USD per month
 
  per_task:
    max_tokens: 100000                    # hard cap per task execution
    max_duration: 30m                     # context timeout per task
 
  on_exceed:
    daily: "pause"                        # pause new tasks, finish current
    monthly: "stop"                       # terminate immediately
    per_task: "stop"                      # kill task that exceeds
 
  thresholds:
    warn_percent: 80                      # alert at 80% of any limit

budget:
  daily_limit: 25.00          # $25/day
  monthly_limit: 200.00       # $200/month — ~8 working days

thresholds:
  warn_percent: 80            # alert at 80% of daily or monthly limit

# View current spend vs limits with progress bars
pilot budget status
 
# View budget configuration and YAML template
pilot budget config
 
# Reset blocked tasks counter and resume daily-paused execution
pilot budget reset --confirm

orchestrator:
  model: "claude-sonnet-4-6"              # default model for planning
  max_concurrent: 2                       # max parallel tasks
 
  execution:
    mode: "sequential"                    # sequential | parallel | auto
    wait_for_merge: true                  # wait for PR merge before next task
    poll_interval: 30s
    pr_timeout: 1h                        # max wait for PR merge
 
  daily_brief:
    enabled: false
    schedule: "0 9 * * 1-5"              # cron: 9 AM weekdays
    timezone: "America/New_York"
    channels:
      - type: slack
        channel: "#dev-updates"
    content:
      include_metrics: true
      include_errors: true
      max_items_per_section: 10
    filters:
      projects: []                        # empty = all projects

alerts:
  enabled: true
  defaults:
    cooldown: 5m
    default_severity: "warning"
    suppress_duplicates: true
 
  channels:
    - name: slack-ops
      type: slack
      enabled: true
      severities: [warning, critical]
      slack:
        channel: "#pilot-alerts"
 
    - name: telegram-admin
      type: telegram
      enabled: true
      severities: [critical]
      telegram:
        chat_id: 123456789
 
    - name: pagerduty
      type: pagerduty
      enabled: false
      severities: [critical]
      pagerduty:
        routing_key: "${PAGERDUTY_KEY}"
 
  rules:
    - name: task_stuck
      type: task_stuck
      enabled: true
      severity: warning
      channels: [slack-ops]
      condition:
        progress_unchanged_for: 10m
 
    - name: consecutive_failures
      type: consecutive_failures
      enabled: true
      severity: critical
      channels: [slack-ops, telegram-admin]
      cooldown: 30m
      condition:
        consecutive_failures: 3
 
    - name: daily_spend
      type: daily_spend_exceeded
      enabled: false
      severity: warning
      channels: [slack-ops]
      condition:
        daily_spend_threshold: 50.0

approval:
  enabled: false
  default_timeout: 1h
  default_action: "rejected"              # action on timeout
 
  pre_execution:
    enabled: false
    approvers: ["@admin"]
    timeout: 1h
    default_action: "rejected"
    require_all: false                    # any one approver suffices
 
  pre_merge:
    enabled: false
    approvers: ["@lead"]
    timeout: 24h
    default_action: "rejected"
    require_all: false
 
  post_failure:
    enabled: false
    approvers: ["@admin"]
    timeout: 1h
    default_action: "rejected"

logging:
  level: "info"                           # debug, info, warn, error
  format: "text"                          # text, json
  output: "stdout"                        # stdout, stderr, or file path
 
  rotation:
    max_size: "100MB"
    max_age: "7d"
    max_backups: 5

tunnel:
  enabled: false
  provider: "cloudflare"                  # cloudflare, ngrok, manual
  domain: ""                              # custom domain (optional)
  port: 9090                              # local port to tunnel

webhooks:
  enabled: true
  defaults:
    timeout: 30s
    retry:
      max_attempts: 3
      initial_delay: 1s
      max_delay: 60s
      multiplier: 2.0
 
  endpoints:
    - name: "ci-notify"
      url: "https://example.com/webhook"
      secret: "${WEBHOOK_SECRET}"         # HMAC-SHA256 signing
      enabled: true
      timeout: 30s
      events:
        - task.completed
        - task.failed
        - pr.created
      headers:
        X-Custom-Header: "value"
      retry:
        max_attempts: 3

gateway:
  host: "127.0.0.1"
  port: 9090
 
auth:
  type: "claude-code"                     # claude-code or api-token
  token: ""                               # required if type is api-token

# docker-compose.yml
volumes:
  - ./config.yaml:/home/pilot/.pilot/config.yaml:ro

# Kubernetes ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: pilot-config
data:
  config.yaml: |
    version: "1.0"
    gateway:
      host: "0.0.0.0"
      port: 9090
    adapters:
      github:
        enabled: true
        token: "${GITHUB_TOKEN}"
        repo: "your-org/your-repo"

adapters:
  linear:
    enabled: false
    api_key: ${LINEAR_API_KEY}
    team_id: "TEAM_ID"
    pilot_label: "pilot"
    auto_assign: true
    polling:
      enabled: true
      interval: 30s
    # Multi-workspace support
    workspaces:
      - name: "main"
        api_key: ${LINEAR_API_KEY}
        team_id: "TEAM_ID"
        pilot_label: "pilot"
        projects: ["my-project"]

adapters:
  gitlab:
    enabled: false
    token: ${GITLAB_TOKEN}
    base_url: "https://gitlab.com"        # self-hosted URL
    project: "namespace/project"
    webhook_secret: ""
    pilot_label: "pilot"
    polling:
      enabled: false
      interval: 30s
    stale_label_cleanup:
      enabled: true
      interval: 30m
      threshold: 1h

adapters:
  slack:
    enabled: false
    bot_token: ${SLACK_BOT_TOKEN}
    channel: "#pilot-updates"
    signing_secret: ""

adapters:
  discord:
    enabled: true
    bot_token: ${DISCORD_BOT_TOKEN}
    allowed_guilds:
      - "123456789012345678"               # guild (server) IDs allowed to send tasks
    allowed_channels:
      - "987654321098765432"               # channel IDs allowed to send tasks
    command_prefix: "!pilot"
    rate_limit:
      messages_per_second: 5
      tasks_per_minute: 10

adapters:
  plane:
    enabled: true
    base_url: "https://api.plane.so"       # or self-hosted URL
    api_key: ${PLANE_API_KEY}
    workspace_slug: "my-workspace"
    project_ids:
      - "project-uuid-1"
    pilot_label: "pilot"
    webhook_secret: ""
    polling:
      enabled: true
      interval: 30s

adapters:
  jira:
    enabled: false
    platform: "cloud"                     # cloud or server
    base_url: "https://myorg.atlassian.net"
    username: "bot@example.com"
    api_token: ${JIRA_API_TOKEN}
    webhook_secret: ""
    pilot_label: "pilot"
    transitions:
      in_progress: "In Progress"
      done: "Done"

adapters:
  asana:
    enabled: false
    access_token: ${ASANA_ACCESS_TOKEN}
    workspace_id: "1234567890"
    webhook_secret: ""
    pilot_tag: "pilot"

adapters:
  azure_devops:
    enabled: false
    pat: ${AZURE_DEVOPS_PAT}
    organization: "myorg"
    project: "MyProject"
    repository: "myrepo"
    base_url: "https://dev.azure.com"
    pilot_tag: "pilot"
    work_item_types:
      - "User Story"
      - "Bug"
    polling:
      enabled: true
      interval: 30s
    stale_label_cleanup:
      enabled: true
      interval: 30m
      threshold: 1h

team:
  enabled: true
  team_id: "engineering"
  member_email: "dev@example.com"

PILOT_TEAM_ID="engineering"
PILOT_MEMBER_EMAIL="dev@example.com"

projects:
  - name: "backend"
    path: "/path/to/backend"
    default_branch: "main"
    navigator: true
    github:
      owner: "myorg"
      repo: "backend"
 
  - name: "frontend"
    path: "/path/to/frontend"
    default_branch: "main"
 
default_project: "backend"
 
memory:
  path: "~/.pilot/data"
  cross_project: true                     # share memory across projects

version: "1.0"
 
adapters:
  github:
    enabled: true
    token: ${GITHUB_TOKEN}
    repo: "myorg/myapp"
    project_path: "~/Projects/myapp"
    pilot_label: "pilot"
    polling:
      enabled: true
      interval: 30s
 
  telegram:
    bot_token: ${TELEGRAM_BOT_TOKEN}
    allowed_ids: [123456789]
    project_path: "~/Projects/myapp"
 
executor:
  type: "claude-code"
  model_routing:
    enabled: true
    trivial: "claude-haiku"
    simple: "claude-sonnet-4-6"
    medium: "claude-sonnet-4-6"
    complex: "claude-opus-4-6"
  timeout:
    default: "30m"
    complex: "60m"
 
orchestrator:
  max_concurrent: 2
  execution:
    mode: "sequential"
    wait_for_merge: true
  autopilot:
    enabled: true
    environment: "dev"
    auto_merge: false
    max_failures: 3
 
quality:
  enabled: true
  gates:
    - name: build
      type: build
      command: "make build"
      required: true
      timeout: 5m
    - name: test
      type: test
      command: "make test"
      required: true
      timeout: 10m
 
budget:
  enabled: true
  daily_limit: 50.00
  monthly_limit: 500.00
  thresholds:
    warn_percent: 80
 
logging:
  level: "info"
  format: "text"