☭ CCP — Coding Control Plane

Seize the means of code production.

CCP is an open-source control plane that turns coding agents (Claude Code, Codex, etc.) into a continuous delivery pipeline. It handles the orchestration that nobody else does: ticket intake → job dispatch → coding → PR creation → review → auto-merge → error detection → remediation.

Linear Ticket → CCP → Coding Agent → PR → CI → Auto-Merge → Deploy
       ↑                                                        |
       └──── Sentry Error / Vercel Failure / CI Failure ────────┘

What It Does

• Job Pipeline — Queue, dispatch, and monitor coding jobs with full lifecycle tracking
• Linear Integration — Auto-dispatch from Linear tickets, sync state back, create tickets from errors
• PR Review & Auto-Merge — Per-repo auto-merge config, CI check monitoring, disposition analysis
• Remediation Loop — CI failures auto-spawn fix jobs; errors → tickets → fixes → deploy
• Webhook Intake — Sentry errors, Vercel deploy failures, GitHub CI failures all create tickets
• Discord Notifications — Compact one-liners for runs, threads for non-clean outcomes
• Dashboard — Dark-themed web UI to monitor jobs, configure repos, track PR reviews
• Nightly Runs — Scheduled coding runs for maintenance, tech debt, compound tasks

Architecture

┌──────────────────────────────────────────────────────────┐
│                     Intake Layer                          │
│  Sentry webhook ──┐                                      │
│  Vercel webhook ──┼── intake-server.ts ── normalize ──┐  │
│  GitHub webhook ──┘                                   │  │
│  Linear webhook ──── linear-dispatch.ts ──────────────┤  │
│  Discord message ── intake-text.ts ───────────────────┤  │
│                                                       ▼  │
│                     Job System (jobs.ts)                  │
│                     ┌────────────────┐                    │
│                     │ queued         │                    │
│                     │ → preflight    │                    │
│                     │ → running      │ ◄── tmux + claude  │
│                     │ → coded        │                    │
│                     │ → verified     │                    │
│                     └────────────────┘                    │
│                           │                              │
│              ┌────────────┼────────────┐                 │
│              ▼            ▼            ▼                 │
│         PR Review    Linear Sync   Notifications         │
│         (pr-review)  (linear.ts)   (Discord)             │
│              │                                           │
│              ▼                                           │
│         PR Watcher ── auto-merge / remediation           │
│         (every 15s)                                      │
└──────────────────────────────────────────────────────────┘

Quick Start

Prerequisites

• Node.js 20+
• Claude Code (npm i -g @anthropic-ai/claude-code) or another coding agent
• GitHub CLI (gh) authenticated
• Linear account with API key

Install

git clone https://github.com/kyan12/ccp.git
cd ccp
npm install

# Configure
cp .env.example .env
cp configs/repos.json.example configs/repos.json
cp configs/linear.json.example configs/linear.json

# Edit .env with your API keys
# Edit configs/repos.json with your repositories
# Edit configs/linear.json with your Linear team/project IDs

Run

# Start the supervisor (monitors and runs jobs)
node src/bin/supervisor.ts --interval=15000 --max-concurrent=1

# Start the intake server (receives webhooks, serves dashboard)
node src/bin/intake-server.ts

# Dashboard at http://localhost:4318/dashboard

Create a Job Manually

node src/bin/intake-text.ts \
  --title "Fix login page timeout" \
  --repo my-app \
  --dispatch

Run on macOS with launchd

# Generate and install launchd plists
node src/bin/install-launchd.ts

Configuration

configs/repos.json — Repository mappings

{
  "mappings": [
    {
      "key": "my-app",
      "ownerRepo": "myorg/my-app",
      "localPath": "/home/user/repos/my-app",
      "aliases": ["app", "frontend"],
      "autoMerge": true,
      "mergeMethod": "squash"
    }
  ]
}

configs/linear.json — Linear integration

{
  "apiKeyEnv": "LINEAR_API_KEY",
  "teamId": "your-team-uuid",
  "teamKey": "ENG",
  "projectIds": {
    "product": "uuid-for-product-project",
    "reliability": "uuid-for-reliability-project"
  }
}

Per-Repo Auto-Merge

Set "autoMerge": true in your repo config. CCP will:

1. Wait for all CI checks to pass
2. Attempt GitHub approval (skips if self-authored)
3. Squash merge (or rebase/merge per mergeMethod)

Webhook Setup

Expose your intake server via Tailscale Funnel, ngrok, or a public URL.

Dashboard

Access at http://localhost:4318/dashboard when the intake server is running.

Job Lifecycle

queued → preflight → running → coded → verified → done
                        │
                        ├── blocked (missing deps, can't resolve repo)
                        ├── failed (agent error, timeout)
                        └── coded → PR created
                                      │
                                      ├── checks pass + autoMerge → merged ✅
                                      ├── checks fail → remediation job spawned 🔄
                                      └── needs review → thread created 💬

The Error→Fix Loop

CCP's killer feature is the closed remediation loop:

1. Runtime error → Sentry captures → webhook → Linear ticket created
2. Ticket dispatched → coding agent fixes the bug → PR created
3. CI passes → auto-merge → deploy
4. CI fails → GitHub webhook → remediation job spawned with failure logs
5. Deploy fails → Vercel webhook → incident ticket created
6. Repeat until green ✅

CLI Tools

Environment Variables

How It Compares

License

MIT — Seize it. Fork it. Ship it.

Credits

Built by Kevin Yan and Crab 🦀 — an AI coding orchestrator running on OpenClaw.