ai-dev-team

1. Prerequisites

• Python 3.11+
• A GitHub classic PAT (not fine-grained) with scopes: repo + read:org (for GitHub Models access)
• Docker (optional — for deployment smoke tests)

From a requirement file

python main.py --file requirements/my-app.txt --repo owner/target-repo

⚡ MVP Setup (Get Running in 5 Minutes)

The minimal setup to run the core pipeline — no Docker, no GitHub Actions, no reviewers. Just PM → Architect → Engineers → Code Reviewer → QA Engineer pushing code to a GitHub repo.

Step 1 — Clone & install

git clone https://github.com/your-username/ai-software-house
cd ai-software-house
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

🚀 Full Setup

2. Install

git clone https://github.com/your-username/ai-software-house
cd ai-software-house
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

GUI Config Builder

Instead of editing YAML by hand, launch the browser-based GUI:

python main.py --config-builder

This opens a local web server (URL printed to console) with a drag-and-drop palette:

• Palette — lists every available stage, colour-coded by category
• Pipeline canvas — drag stages from the palette to build your sequence; drag to reorder
• Loop blocks — drag the "Loop" stage into the canvas and configure max / until / inner stages
• Save — writes pipeline.yaml next to your config.yaml

No GitHub token needed — --config-builder exits before any network calls.

Deploy to a target repo

To add a Memory Bank to any project, use the templates from copilot-agent-setting:

cd /path/to/copilot-agent-setting
./deploy-memory-bank.sh /path/to/your-project

Then fill in memory-bank/projectbrief.md and memory-bank/productContext.md. The pipeline will keep the other files up to date automatically.

`orchestrator.py` — Full Feature Build

from orchestrator import Orchestrator

orch = Orchestrator(
    model="gpt-4.1",
    github_token="ghp_...",
    target_repo="owner/my-app",
    num_engineers=3,
)

result = orch.run("Build a REST API for patient questionnaires")

print(result.prd)               # PRD markdown
print(result.prd_verdict)       # PRD APPROVED / NEEDS REVISION
print(result.design)            # System design markdown
print(result.design_verdict)    # DESIGN APPROVED / NEEDS REVISION
print(result.qa_plan)           # Full test plan from QA Planner
print(result.qa_acceptance_criteria)  # ['AC-01', 'AC-02', ...]
print(result.pr_url)            # GitHub PR URL
print(result.tests_passed)      # True / False / None
print(result.run_id)            # UUID for this pipeline run
print(result.total_cost_usd)    # estimated USD cost (requires cost_tracking.enabled)
print(result.token_usage)       # dict with by_stage and by_model breakdowns

Install cron job (runs every hour at :00)

chmod +x setup_cron.sh
./setup_cron.sh

Or manually: ```bash crontab -e

One-Time Setup

```bash

3. (Optional) Set target repo for cross-repo builds

Triggering a Feature Build

Create a GitHub Issue, then add the ai-feature label:

```markdown Title: Patient questionnaire mobile app

🎨 Defining Agent Skills & Guides

Every agent's behaviour is controlled entirely by its role file (roles/<agent>.md). This file becomes the LLM's system prompt — change the markdown, change the agent.

Step 4 — Minimal config

Edit config.yaml — change just one line:

github:
  repo: "your-username/my-first-agent-app"   # ← your new repo

Disable the optional agents to keep it fast:

team:
  num_engineers: 1        # start with 1 engineer
  agents:
    product_manager: true
    pm_reviewer: false    # skip for MVP
    architect: true
    engineer: true
    code_reviewer: true
    qa_planner: false     # skip for MVP
    qa_engineer: true
    deployment_tester: false  # skip — needs Docker

3. Configure

cp config.yaml config.local.yaml   # optional — edit as needed
export GITHUB_TOKEN=ghp_your_classic_pat

Using Anthropic Claude models? Add your Anthropic key alongside GITHUB_TOKEN:

> # For Anthropic Claude models (claude-sonnet-4.6, claude-opus-4.5, etc.)
> export ANTHROPIC_API_KEY=sk-ant-your-key-here
> 

Model names starting with claude- are automatically routed to the Anthropic API. GITHUB_TOKEN is still required for all GitHub operations.

Using OpenCode Zen or Go models? Export the OpenCode API key:

> export OPENCODE_ZEN_API_KEY=your-opencode-api-key
> 

Both opencode-zen/ and opencode-go/ model prefixes share this key. Get one at <https://opencode.ai/auth>.

Using OpenAI API (BusinessChatGPT)? Export your OpenAI API key:

> export OPENAI_API_KEY=sk-your-key-here
> 

Use the openai/ prefix: openai/gpt-4o, openai/gpt-4.1-mini, etc.

Using NVIDIA NIM? Export your NVIDIA API key:

> export NVIDIA_API_KEY=nvapi-your-key-here
> 

Use the nvidia-nim/ prefix: nvidia-nim/meta/llama-3.1-70b-instruct, etc.

Using Alibaba DashScope / Qwen? Export your DashScope API key:

> export DASHSCOPE_API_KEY=sk-your-key-here
> 

Use the dashscope/ prefix: dashscope/qwen3-plus, dashscope/qwen3-turbo, etc.

Edit config.yaml:

github:
  repo: "your-username/your-repo"   # where code will be pushed

Using Ollama (Local LLM)

To use a local Ollama server instead of GitHub Models or Anthropic:

1. Set any agent's model to an ollama/ prefixed name in config.yaml:

   llm:
     model: "ollama/llama3.2"
     overrides:
       engineer: "ollama/qwen2.5-coder"
   

2. Create config.local.yaml alongside config.yaml to set your Ollama server URL (this file is gitignored — never committed):

   llm:
     ollama_url: "http://your-ollama-host:11434"
   

3. Pull the required model on your Ollama server:

   ollama pull llama3.2
   

Using OpenCode CLI

Run models through the OpenCode CLI instead of a direct API:

1. Install and authenticate OpenCode:

   npm install -g opencode-ai   # or follow opencode.ai instructions
   opencode auth login
   

2. Set model names with the opencode/<provider>/<model> prefix:

   llm:
     model: "opencode/anthropic/claude-sonnet-4-5"
     overrides:
       engineer: "opencode/openai/gpt-4o"
   

OpenCode resolves the provider from its own auth config. Override the binary path with OPENCODE_BIN if needed.

⚠️ OpenCode CLI does not support tool-calling. The Code Reviewer agent will fail if assigned an opencode/ model. Use opencode-go/ or opencode-zen/ for tool-calling agents.

Using OpenCode Zen API

Direct HTTP access to OpenCode Zen (Claude, GPT, Gemini, and more):

1. Get an API key at <https://opencode.ai/auth> and export it:

   export OPENCODE_ZEN_API_KEY=your-key-here
   

2. Use the opencode-zen/<model-id> prefix:

   llm:
     model: "opencode-zen/claude-sonnet-4-6"
     overrides:
       engineer: "opencode-zen/gpt-5.3-codex"
   

Claude models route to the Anthropic Messages endpoint; all others use the OpenAI-compatible endpoint and support tool-calling.

Using OpenCode Go API

Access the OpenCode Go plan models (Kimi, Qwen, GLM, MiMo, MiniMax):

1. Same API key as Zen — OPENCODE_ZEN_API_KEY.

2. Use the opencode-go/<model-id> prefix:

   llm:
     model: "opencode-go/kimi-k2.5"
     overrides:
       engineer: "opencode-go/qwen3.6-plus"
   

| Model ID | Endpoint | Tool-calling | |---|---|---| | kimi-k2.5, qwen3.6-plus, qwen3.5-plus, glm-5.1, glm-5, mimo-v2-pro, mimo-v2-omni | /chat/completions | ✅ | | minimax-m2.7, minimax-m2.5 | Anthropic /messages | ❌ |

Override the base URL with OPENCODE_GO_BASE_URL if needed.

Using Grok CLI

Run xAI Grok models via the Grok CLI subprocess:

1. Install the Grok CLI and ensure it is authenticated.

2. Set model names with the grok/<model> prefix:

   llm:
     model: "grok/grok-3"
     overrides:
       engineer: "grok/grok-3-mini"
   

Override the binary path with GROK_BIN if needed.

⚠️ Grok CLI does not support tool-calling. The Code Reviewer agent will fail if assigned a grok/ model.

Using Grok OAuth (xAI API)

Direct HTTP access to the xAI API using the OAuth browser flow:

1. Use the grok-oauth/<model> prefix — the first call opens a browser for xAI OAuth login:

   llm:
     model: "grok-oauth/grok-3"
     overrides:
       engineer: "grok-oauth/grok-3-mini"
   

Token is refreshed automatically. Override client ID with XAI_OAUTH_CLIENT_ID if needed.

Supports tool-calling (OpenAI-compatible endpoint).

Using NVIDIA NIM

Access NVIDIA-hosted models (Llama, Mistral, Nemotron, etc.) via the NIM inference API:

1. Get an API key from build.nvidia.com and export it:

   export NVIDIA_API_KEY=nvapi-your-key-here
   

2. Use the nvidia-nim/<model> prefix:

   llm:
     model: "nvidia-nim/meta/llama-3.1-70b-instruct"
     overrides:
       engineer: "nvidia-nim/mistralai/mistral-7b-instruct-v0.3"
   

Override the endpoint with NVIDIA_NIM_BASE_URL (default: https://integrate.api.nvidia.com/v1).

Supports tool-calling.

Using Alibaba DashScope (Qwen models)

Access Alibaba Cloud Qwen and other DashScope models:

1. Get an API key from dashscope.aliyuncs.com and export it:

   export DASHSCOPE_API_KEY=sk-your-key-here
   

2. Use the dashscope/<model> prefix:

   llm:
     model: "dashscope/qwen3-plus"
     overrides:
       engineer: "dashscope/qwen3-turbo"
   

Default endpoint: https://dashscope-intl.aliyuncs.com/compatible-mode/v1. Override with dashscope_url in config.

Supports tool-calling.

Using GitHub Copilot

Use GitHub Copilot's internal inference API — requires an active Copilot subscription:

1. Auth is auto-discovered from ~/.copilot/config.json (set by the Copilot CLI). Or export the token directly:

   export COPILOT_OAUTH_TOKEN=gho_your-copilot-token
   

2. Use the copilot/<model> prefix:

   llm:
     model: "copilot/gpt-4o"
     overrides:
       engineer: "copilot/gpt-4.1-mini"
   

Supports tool-calling.

Using OpenAI API (BusinessChatGPT)

Direct access to the OpenAI API (api.openai.com) — for ChatGPT Plus/Team/Enterprise subscribers using a standard API key:

1. Export your OpenAI API key:

   export OPENAI_API_KEY=sk-your-key-here
   

2. Use the openai/<model> prefix:

   llm:
     model: "openai/gpt-4o"
     overrides:
       engineer: "openai/gpt-4.1-mini"
   

Supports tool-calling. Fallbacks work as normal across all agents.

Using OpenAI Codex CLI

Run the OpenAI Codex CLI agent (codex exec) as a subprocess — requires a ChatGPT Plus/Pro account:

1. Install and sign in:

   curl -fsSL https://chatgpt.com/codex/install.sh | sh
   # or: npm install -g @openai/codex
   codex   # sign in with your ChatGPT account on first run
   

2. Use the codex/<model> prefix:

   llm:
     model: "codex/codex-mini-latest"
     overrides:
       engineer: "codex/o4-mini"
   

Override the binary path with CODEX_BIN if needed.

⚠️ Codex CLI does not support tool-calling. The Code Reviewer agent will fail if assigned a codex/ model.

📋 All CLI Options (`main.py`)

python main.py [options]

Input (one required):
  --file PATH            Path to a .txt file containing the requirement
  --requirement TEXT     Requirement as a command-line string

Routing:
  --repo OWNER/REPO      Target repository for code (overrides config.yaml)

Model:
  --model MODEL          Override model for ALL agents
  --model-override AGENT=MODEL   Override model for one agent (repeatable)
                         Agent names: product_manager, pm_reviewer, architect,
                         architect_reviewer, engineer, code_reviewer,
                         qa_planner, qa_engineer, deployment_tester

Team:
  --engineers N          Number of parallel Engineer agents (default: 2)

Pipeline:
  --no-resume            Ignore checkpoint and start from scratch
  --stop-on-review       Halt pipeline if Code Reviewer requests changes
  --refactor             Dream mode: analyse workspace code and open a cleanup PR
  --mode {build,revise}  'build' (default) runs full pipeline; 'revise' processes PR feedback
  --pr PR_NUMBER         PR number to revise — required when --mode=revise
  --config-builder       Launch browser-based GUI to build/edit pipeline.yaml, then exit
  --pipeline NAME        Run a named pipeline (matches pipelines/<name>.yaml or built-ins: ai-feature, ai-fix, ai-docs)
  --list-pipelines       Print all available pipeline names (project + built-in) and exit

watcher.py options:

  --once                 Process all pending issues once, then exit (used by GitHub Actions)
  --dry-run              Show what would run; make no GitHub changes
  --config PATH          Use a different repos.yaml file (default: repos.yaml)

---

⚙️ Configuration Reference (`config.yaml`)

llm:
  # Default model for all agents
  # ── GitHub Models (default) ─────────────────────────────────────────────
  #   gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, gpt-4o, gpt-4o-mini, o4-mini, o3
  #   claude-3.5-sonnet, claude-3.7-sonnet, claude-3-haiku
  #   meta-llama-3.3-70b-instruct, mistral-large-2411
  #   deepseek-r1, deepseek-v3, cohere-command-r-plus
  #
  # ── Anthropic Claude API (ANTHROPIC_API_KEY required) ──────────────────
  #   claude-sonnet-4-6, claude-opus-4-5, claude-3-5-sonnet-20241022, ...
  #   Any model starting with "claude-" is auto-routed to Anthropic.
  #   ⚠️  Does NOT support tool-calling (Code Reviewer will fail).
  #
  # ── Ollama (local, ollama_url below) ───────────────────────────────────
  #   ollama/llama3.2, ollama/qwen2.5-coder, ollama/mistral, ...
  #   Tool-calling ✅
  #
  # ── OpenCode CLI (opencode must be installed + authenticated) ───────────
  #   opencode/<provider>/<model>
  #     e.g. opencode/anthropic/claude-sonnet-4-5
  #          opencode/openai/gpt-4o
  #   ⚠️  Does NOT support tool-calling (Code Reviewer will fail).
  #
  # ── OpenCode Zen API (OPENCODE_ZEN_API_KEY required) ───────────────────
  #   opencode-zen/<model-id>
  #     e.g. opencode-zen/claude-sonnet-4-6   → Anthropic endpoint
  #          opencode-zen/gpt-5.3-codex        → OpenAI endpoint (tool-calling ✅)
  #
  # ── OpenCode Go API (OPENCODE_ZEN_API_KEY required) ────────────────────
  #   opencode-go/<model-id>
  #     e.g. opencode-go/kimi-k2.5, opencode-go/qwen3.6-plus (tool-calling ✅)
  #          opencode-go/minimax-m2.7           → Anthropic endpoint (no tool-calling)
  #
  # ── Grok CLI (grok must be installed + authenticated) ──────────────────
  #   grok/<model-id>
  #     e.g. grok/grok-3, grok/grok-3-mini
  #   ⚠️  Does NOT support tool-calling (Code Reviewer will fail).
  #   Override binary path: GROK_BIN env var.
  #
  # ── Grok OAuth / xAI API (browser OAuth on first use) ──────────────────
  #   grok-oauth/<model-id>
  #     e.g. grok-oauth/grok-3, grok-oauth/grok-3-mini
  #   Tool-calling ✅  Override client ID: XAI_OAUTH_CLIENT_ID env var.
  #
  # ── NVIDIA NIM (NVIDIA_API_KEY required) ────────────────────────────────
  #   nvidia-nim/<model-id>
  #     e.g. nvidia-nim/meta/llama-3.1-70b-instruct
  #          nvidia-nim/mistralai/mistral-7b-instruct-v0.3
  #   Tool-calling ✅  Override endpoint: NVIDIA_NIM_BASE_URL env var.
  #
  # ── Alibaba DashScope / Qwen (DASHSCOPE_API_KEY required) ───────────────
  #   dashscope/<model-id>
  #     e.g. dashscope/qwen3-plus, dashscope/qwen3-turbo
  #   Tool-calling ✅  Override endpoint: dashscope_url in config.
  #
  # ── GitHub Copilot (COPILOT_OAUTH_TOKEN or ~/.copilot/config.json) ──────
  #   copilot/<model-id>
  #     e.g. copilot/gpt-4o, copilot/gpt-4.1-mini
  #   Tool-calling ✅  Requires active GitHub Copilot subscription.
  #
  # ── OpenAI API / BusinessChatGPT (OPENAI_API_KEY required) ─────────────
  #   openai/<model-id>
  #     e.g. openai/gpt-4o, openai/gpt-4.1-mini
  #   Tool-calling ✅
  #
  # ── OpenAI Codex CLI (ChatGPT Plus/Pro account required) ────────────────
  #   codex/<model-id>
  #     e.g. codex/codex-mini-latest, codex/o4-mini
  #   Install: curl -fsSL https://chatgpt.com/codex/install.sh | sh
  #   ⚠️  Does NOT support tool-calling (Code Reviewer will fail).
  #   Override binary path: CODEX_BIN env var.
  model: "gpt-4.1"

  # Per-agent model overrides
  overrides:
    product_manager: "gpt-4.1"       # reasoning-heavy
    pm_reviewer: "gpt-4.1"
    architect: "gpt-4.1"
    architect_reviewer: "gpt-4.1"
    engineer: "gpt-4.1-mini"         # runs many times — use cheaper model
    code_reviewer: "gpt-4.1"
    qa_planner: "gpt-4.1"            # test planning needs strong reasoning
    qa_engineer: "gpt-4.1-mini"      # repetitive test writing — cheaper
    deployment_tester: "gpt-4.1-mini"

github:
  repo: "owner/repo"                 # default target repo
  branch_prefix: "feature/agent"

team:
  num_engineers: 2
  agents:                            # enable / disable individual agents
    product_manager: true
    pm_reviewer: true
    architect: true
    engineer: true
    code_reviewer: true
    qa_planner: true
    qa_engineer: true
    deployment_tester: true

pipeline:
  workspace_dir: "./workspace"
  stop_on_review_issues: false
  max_retries: 2
  max_revisions: 3        # max automated PR revision rounds (0 = disabled)
  mode: "standard"        # "standard" | "tdd" | "blocky"
  tdd_commit_tests: false # (TDD mode) commit test files to branch before implementation
  # Note: if pipeline.yaml exists in the project root, it overrides pipeline.mode.

skills:
  always_load: []          # e.g. [security-audit] to always apply
  marketplace_repo: ""     # e.g. "myorg/ai-software-house-skills"
  cache_dir: ""            # defaults to ~/.ai-software-house/skills/
  fetch_timeout: 5

mcp:
  servers: []              # see "Using MCP Servers" section below

cost_tracking:
  enabled: false                  # set true to enable tracking
  db_path: "./token_usage.db"     # SQLite file path (relative to project root)
  post_to_github: false           # post usage summary comment to the GitHub issue

  # Pricing per 1M tokens: [input_price_usd, output_price_usd]
  # Set to [0.00, 0.00] for local/free models (Ollama, etc.)
  # Unlisted models fall back to "default".
  pricing:
    gpt-4.1:           [2.00, 8.00]
    gpt-4.1-mini:      [0.40, 1.60]
    gpt-4o:            [2.50, 10.00]
    qwen3.6-plus:      [0.50, 1.50]
    qwen3.5-plus:      [0.30, 1.20]
    thinker:           [0.00, 0.00]
    thinker-best:      [0.00, 0.00]
    coder:             [0.00, 0.00]
    fast:              [0.00, 0.00]
    chat:              [0.00, 0.00]
    default:           [2.00, 8.00]   # fallback for any unlisted model

---

Configure repos.yaml

watchers:
  - tracker_repo: wanleung/ai-software-house   # where issues are filed
    default_target: wanleung/my-app            # default target repo for code
    parallel_issues: 2                         # max simultaneous issues for this repo
    labels:
      ai-feature: ai-feature      # label → pipeline name (matches pipelines/ai-feature.yaml)
      ai-fix:     ai-fix
      ai-docs:    ai-docs
    enabled: true

  - tracker_repo: wanleung/another-project     # watch a second repo
    default_target: ~                          # null = same repo as tracker
    enabled: true

settings:
  max_parallel: 3       # global cap across all repos
  num_engineers: 2
  model: "gpt-4.1"
  log_dir: ./logs/watcher

Legacy feature_label / bug_label / doc_label fields are still supported — they are automatically mapped to ai-feature, ai-fix, and ai-docs pipelines respectively.

Use **Target repo:** owner/repo in the issue body to route code to a different repo than default_target.

🧠 Per-Repo LLM Config

Each repo entry can declare its own llm: block that deep-merges on top of the global config.yaml LLM config. This lets different projects use different models, fallbacks, or concurrency limits — with no change to the global config.

Minimal example — override the default model for one repo

```yaml

Add this line (use the venv python directly — 'source activate' breaks in cron's /bin/sh):

0 cd /home/you/ai-software-house && venv/bin/python watcher.py >> logs/watcher/cron.log 2>&1 ```

Use a different config file

python watcher.py --config my-other-repos.yaml ```

Go to: Settings → Secrets → Actions → New repository secret

Python API

```python from orchestrator import Orchestrator

orch = Orchestrator(model="gpt-4.1", github_token="ghp_...", target_repo="owner/repo")

🎛️ Using the Orchestrators Directly (Python API)

🤖 Pipeline Stages

1.  📋 Product Manager    — requirement → PRD + GitHub Issue
2.  📝 PM Reviewer        — reviews PRD; optionally revises before architecture
3.  🏗️  Architect          — PRD → system design + module list
4.  🔎 Arch Reviewer      — reviews design; optionally revises before engineering
5.  🗺️ Repo Indexer       — injects repo tree into prompts (small repos) or auto-indexes codebase into RAG (large repos)
6.  💻 Engineers ×N       — parallel code generation → feature branch + PR
7.  🔍 Code Reviewer      — reviews code → PR comment with verdict
8.  📋 QA Planner         — PRD + design + code → structured test plan + acceptance criteria
9.  🧪 QA Engineer        — implements tests guided by QA Planner's test plan → PR
10. 🏃 Test Runner        — runs pytest locally → PR comment with results
11. 🚀 Deployment Tester  — generates docker-compose.test.yml + smoke tests → PR
12. 🐳 Deploy Test Runner — runs deploy smoke tests via the repo's configured backend (docker / libvirt / none) → PR comment
13. 🧠 Summariser         — writes compact memory entry (what was built, decisions, feedback, tech debt)

**Bug-fix stages** (used in `ai-fix` pipeline):
14. 🔬 Diagnose           — reads issue + codebase, pinpoints root cause
15. 🐛 Bug Fix            — applies targeted fix → branch + PR

**Documentation stages** (used in `ai-docs` pipeline):
16. 📝 Doc Generate       — reads existing docs + source, writes/updates documentation files
17. 📤 Doc Commit/PR      — commits doc files to a branch and opens a PR

---

🧩 Custom Pipeline (`pipeline.yaml`)

By default the pipeline runs all stages in the order shown above. You can replace this with any custom stage sequence by creating a pipeline.yaml in the project root.

🏷️ Label → Pipeline Mapping

Each GitHub label can trigger its own pipeline. The watcher picks the pipeline file based on the label name.

Built-in pipelines:

Custom pipelines: Create pipelines/<your-label>.yaml with a stages: list and add the label to your repo entry in repos.yaml. See Custom Pipeline (pipeline.yaml) for the full format.

Per-project override: A pipeline.yaml at the project's root takes precedence over the built-in pipelines/<label>.yaml.

🔁 Pipeline Self-Chaining

When a run completes with issues (failing tests, reviewer changes requested), the watcher automatically swaps the completion label for a follow-up trigger label — no human needed to re-queue.

Issue #42 (ai-feature)
  → tests fail
  → watcher adds ai-fix instead of agent-complete
  → posts comment explaining the chain
  → next watcher cycle picks up ai-fix → runs fix pipeline
  → tests pass → adds agent-complete ← done

Configure in config.yaml:

pipeline:
  chaining:
    on_test_failure: "ai-fix"      # label to apply when tests fail
    on_review_issues: "ai-fix"     # label to apply when reviewer requests changes
    # set to ~ (null) to disable a rule

📖 See docs/operations-guide.md § 6 for full details, priority rules, and how to set next_label from a custom stage.

`ai-docs` pipeline — Documentation-only

Label an issue ai-docs to trigger a lightweight doc-update pipeline — no PM, Architect, or Engineers involved.

The built-in pipeline is defined in pipelines/ai-docs.yaml and runs two stages: 1. doc_generate — reads existing docs + source from the target repo, writes/updates documentation files 2. doc_commit_pr — commits the files to a branch doc/<issue-number>-<slug> and opens a PR referencing and closing the issue

Issue body format:

Update the README installation section and add a troubleshooting guide.

**Docs:** README.md, docs/troubleshooting.md
**Target repo:** owner/my-app

• **Docs:** is optional — if omitted, the agent auto-discovers .md files in the repo (up to 5)
• **Target repo:** is optional — if omitted, the watcher's repo is used

---

📣 `pr-campaign` pipeline — PR & Marketing Campaign

Label an issue pr-campaign to run a 3-stage content creation pipeline that produces a fully formatted campaign proposal and opens a GitHub PR for human review.

Built-in pipeline: pipelines/pr-campaign.yaml

Trigger via GitHub issue (recommended)

The watcher monitors wanleung/pr-campaigns for issues labelled pr-campaign. Create an issue there with your campaign brief and apply the label:

```markdown

MVP vs Full Pipeline

Once the MVP works, turn agents back on one by one in config.yaml.

---