ai-control-center 1.15.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI Control Center Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,584 @@
+<p align="center">
+  <br />
+  <strong>ai-control-center</strong>
+  <br />
+  Multi-AI orchestration control center for any project
+  <br />
+  <br />
+  <a href="https://www.npmjs.com/package/ai-control-center"><img src="https://img.shields.io/npm/v/ai-control-center.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/ai-control-center"><img src="https://img.shields.io/npm/dm/ai-control-center.svg" alt="npm downloads"></a>
+  <a href="https://github.com/nicholasgriffintn/ai-control-center/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/ai-control-center.svg" alt="license"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/ai-control-center.svg" alt="node version"></a>
+</p>
+
+---
+
+A terminal CLI, web dashboard, Telegram bot, Twitch bot, and OpenClaw gateway that orchestrates multiple AI agents (Claude, Copilot, Gemini, Ollama) through a structured feature pipeline with **skill-driven AI behavior** at every stage. Works with **any project type** — Salesforce, Node.js, Python, Swift, Go, and more.
+
+## Highlights
+
+- **OpenClaw skill engine** — stage-specific skills guide AI behavior for requirement capture, PM spec, architecture, implementation, and code review
+- **Terminal menu** — interactive CLI with real-time pipeline status
+- **Web dashboard** — Express + WebSocket SPA with deploy, review, AI chat, and pixel-art office visualizer
+- **Telegram & Twitch bots** — remote pipeline control + push notifications + AI chat + `/` command suggestions
+- **Multi-Agent roleplay** — PM agent autonomously orchestrates the team, posts in-chat as each agent persona, handles failures and provider switching
+- **Multi-AI routing** — Claude → Copilot → Gemini → Ollama fallback chain with circuit breakers and auto-downgrade
+- **Smart notifications** — deduplicated stage updates, task-aware progress bars for implementation, pipeline cancellation on `/reset`
+- **Fully configurable** — one `aicc.config.js` drives everything (stages, deploy, review, models, skills, roleplay)
+- **Works with any stack** — no assumptions about language, framework, or deployment target
+
+## Install
+
+```sh
+# Global
+npm install -g ai-control-center
+
+# Local dev dependency
+npm install ai-control-center --save-dev
+
+# One-shot init
+npx ai-control-center init
+```
+
+## Quick Start
+
+```sh
+aicc init          # 1. Initialize — creates aicc.config.js
+aicc               # 2. Launch interactive terminal menu
+aicc start         # 3. Start all services (web + telegram + twitch)
+aicc openclaw      # 4. Generate OpenClaw skills for all pipeline stages
+aicc doctor        # 5. Health check + auto-repair
+```
+
+## How It Works
+
+```
+  ┌─────────────────────────────────────────────────────────────────────────────┐
+  │                         USER CHANNELS                                       │
+  │                                                                             │
+  │  Telegram   WhatsApp    Slack     Discord    Web Dashboard    CLI Terminal   │
+  └──────┬──────────┬─────────┬─────────┬──────────────┬──────────────┬────────┘
+         │          │         │         │              │              │
+         └──────────┴─────────┴─────────┘              │              │
+                         │                             │              │
+                ┌────────▼────────┐                    │              │
+                │   OpenClaw      │                    │              │
+                │   Gateway       │                    │              │
+                │  :18789 (WS)    │                    │              │
+                │                 │                    │              │
+                │ • AI Skills     │                    │              │
+                │ • Multi-channel │                    │              │
+                │ • Cron jobs     │                    │              │
+                │ • Sessions      │                    │              │
+                └────────┬────────┘                    │              │
+                         │ WebSocket                   │              │
+                ┌────────▼────────┐                    │              │
+                │  AICC Bridge    │                    │              │
+                │  (bridge.js)    │                    │              │
+                │                 │                    │              │
+                │ • Event forward │                    │              │
+                │ • Command exec  │                    │              │
+                │ • Tool exposure │                    │              │
+                │ • Skill inject  │                    │              │
+                └────────┬────────┘                    │              │
+                         │                             │              │
+         ┌───────────────┴─────────────────────────────┴──────────────┘
+         │
+  ┌──────▼──────────────────────────────────────────────────────────────┐
+  │                        AICC ENGINE                                  │
+  │                                                                     │
+  │  ┌──────────────┐   ┌──────────────┐   ┌─────────────────────┐     │
+  │  │ Action Runner │   │  Event Bus   │   │   Skill Loader      │     │
+  │  │ (orchestrator)│◀─▶│ (status.json │   │ (3-source priority, │     │
+  │  │              │   │  watcher)    │   │  stage injection)   │     │
+  │  └──────┬───────┘   └──────────────┘   └─────────────────────┘     │
+  │         │                                                           │
+  │  ┌──────▼───────────────────────────────────────────────────┐      │
+  │  │                    Runner (AI Router)                     │      │
+  │  │              pipeline[] drives stage routing              │      │
+  │  └──────┬───────────┬───────────┬───────────┬──────────────┘      │
+  │         │           │           │           │                       │
+  │    ┌────▼───┐  ┌────▼───┐  ┌────▼───┐  ┌────▼───┐                 │
+  │    │Copilot │  │ Claude │  │ Gemini │  │ Ollama │                  │
+  │    │  CLI   │  │  Code  │  │  CLI   │  │ (local)│                  │
+  │    └────────┘  └────────┘  └────────┘  └────────┘                  │
+  │    PM, Arch,    Implement   Fallback    Last resort                 │
+  │    Review,                  provider    (offline)                   │
+  │    Deploy                                                           │
+  └─────────────────────────────────────────────────────────────────────┘
+
+
+  Feature Pipeline Flow (each stage guided by OpenClaw skills):
+
+  ┌──────┐    ┌────┐    ┌──────┐    ┌─────────┐    ┌──────┐    ┌──────┐    ┌────────┐
+  │ User │───▶│ PM │───▶│ Arch │───▶│Implement│───▶│Review│───▶│Approve│───▶│ Deploy │
+  │ idea │    │spec│    │design│    │  code   │    │ code │    │/reject│    │  ship  │
+  └──────┘    └────┘    └──────┘    └─────────┘    └──────┘    └──────┘    └────────┘
+       ▲      copilot   copilot      claude        copilot     human       copilot
+       │     (sonnet)  (sonnet)    (sonnet)       (sonnet)                (sonnet)
+       │        ▲          ▲           ▲              ▲
+  via OpenClaw  │          │           │              │
+  (any channel) └──────────┴───────────┴──────────────┘
+                    OpenClaw skills injected at each stage:
+                    SPEC skill → ARCH skill → IMPL skill → REVIEW skill
+
+                Each stage produces a document:
+                SPEC.md → ARCH.md → TASKS.md → REVIEW.md
+
+
+  On failure at any stage:
+    Primary ──fail──▶ Fallback 1 ──fail──▶ Fallback 2 ──fail──▶ Circuit Open
+    e.g.              e.g.                 e.g.                 (wait 5 min,
+    copilot           gemini               ollama                then retry)
+```
+
+## OpenClaw Skills
+
+OpenClaw is the AI skill engine that powers every pipeline stage. Running `aicc openclaw` generates 6 stage-specific skills that guide each AI agent's behavior:
+
+```
+  Skills — injected into AI prompts at each pipeline stage
+
+  ┌───────────┐    ┌───────────┐    ┌───────────┐    ┌───────────┐    ┌───────────┐
+  │ Requirement│    │  PM Spec  │    │ Architect │    │ Implement │    │  Review   │
+  │  Capture   │    │   Skill   │    │   Skill   │    │   Skill   │    │   Skill   │
+  │            │    │           │    │           │    │           │    │           │
+  │ Analyze    │    │ User      │    │ Design    │    │ Coding    │    │ Structured│
+  │ raw input, │    │ stories,  │    │ arch doc, │    │ standards,│    │ verdict,  │
+  │ ask missing│    │ criteria, │    │ task list,│    │ tests,    │    │ checklist,│
+  │ info,      │    │ risks,    │    │ exact     │    │ security  │    │ blockers  │
+  │ confirm    │    │ priority  │    │ file paths│    │ rules     │    │ vs warns  │
+  └──────┬─────┘    └─────┬─────┘    └─────┬─────┘    └─────┬─────┘    └─────┬─────┘
+         │                │                │                │                │
+         ▼                ▼                ▼                ▼                ▼
+      [User Input]     [PM Agent]     [Architect]      [Coder]        [Reviewer]
+      stage:capture    stage:spec     stage:arch       stage:impl     stage:review
+```
+
+**Skill loading priority** (first match wins):
+
+| Priority | Location | Description |
+|----------|----------|-------------|
+| 1 (highest) | `.ai-workflow/skills/` | Project-local overrides |
+| 2 | `~/.openclaw/skills/<project>/` | OpenClaw directory (generated by `aicc openclaw`) |
+| 3 | `~/.aicc/skills/` | Global user fallback |
+
+**Generated skill files:**
+
+| File | Stage | What it does |
+|------|-------|-------------|
+| `SKILL.md` | — | PM Agent persona, cron monitoring, session config |
+| `SKILL-requirement-capture.md` | `capture` | Analyze raw user input, ask clarifying questions, confirm before submit |
+| `SKILL-pm-spec.md` | `spec` | Write structured PM spec with user stories, acceptance criteria, risks |
+| `SKILL-architect.md` | `arch` | Design architecture doc + implementation task list with exact file paths |
+| `SKILL-implement.md` | `impl` | Code implementation following architecture, with tests and security rules |
+| `SKILL-review.md` | `review` | Structured code review with verdict, blockers vs warnings, checklist |
+
+Skills are injected via `injectSkills(prompt, 'stage')` — the system loads all matching skills and appends their content to the AI prompt before execution.
+
+**OpenClaw bridge features:**
+
+- **Event forwarding**: AICC pipeline events → OpenClaw Gateway → all channels
+- **Bidirectional commands**: Users on any channel can invoke AICC commands via OpenClaw
+- **Tool exposure**: AICC tools (status, feature, deploy, etc.) registered as OpenClaw tools
+- **Cron monitoring**: Pipeline health checks (2min active, 5min stall, 30min idle)
+- **Stage document injection**: On stage transitions, output docs are sent to OpenClaw session
+
+## Configuration
+
+The init wizard creates `aicc.config.js` at your project root:
+
+```js
+export default {
+  name: 'my-project',
+  description: 'A full-stack web application',
+  workflowDir: '.ai-workflow',
+  envPrefix: 'MYPROJ',
+
+  deploy: { command: 'npm run deploy', options: [] },
+  review: { extensions: ['.js', '.ts'], sourceDir: 'src/' },
+  web: { port: 3847 },
+
+  roleplay: {
+    enabled: true,
+    verbosity: 'normal',        // 'quiet' | 'normal' | 'verbose'
+    pmPersonality: 'professional', // 'professional' | 'casual' | 'funny'
+    agentChat: true,
+    progressUpdates: true,
+    progressInterval: 180000,     // 3 min between PM "still working" updates
+    maxReviewCycles: 3,
+    autoDeployOnApproval: false,
+    openclawBridge: true,       // enable OpenClaw WebSocket bridge
+  },
+
+  // Each line = one stage. Change provider/model to switch instantly.
+  pipeline: [
+    { stage: 'chat',      provider: 'openclaw', model: 'auto',               fallbacks: ['copilot:claude-haiku-4.5']                },
+    { stage: 'pm',        provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'architect', provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'implement', provider: 'claude',  model: 'claude-sonnet-4-6',  fallbacks: ['copilot:claude-sonnet-4.6', 'ollama']    },
+    { stage: 'review',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'deploy',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+  ],
+
+  ollama: { model: 'llama3.1', baseUrl: 'http://localhost:11434' },
+};
+```
+
+**To switch a model**, just change the `model` value for that stage. No other config needed.
+
+**Providers**: `openclaw` (OpenClaw gateway), `copilot` (GitHub Copilot CLI), `claude` (Claude Code CLI), `gemini` (Gemini CLI), `ollama` (local).
+
+**Fallback format**: `'provider:model'` or just `'provider'` (uses default model). On primary failure, tries each fallback in order.
+
+### Config Reference
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `name` | `string` | — | Project name (shown in header, dashboard, bot) |
+| `description` | `string` | — | Short project description |
+| `workflowDir` | `string` | `.ai-workflow` | Directory for pipeline state files |
+| `envPrefix` | `string` | `AICC` | Prefix for environment variables |
+| `deploy.command` | `string` | `null` | Shell command to run on deploy (if `null`, deploy marks feature as done without running anything) |
+| `deploy.options` | `array` | `[]` | Deploy option presets `{ name, value }` |
+| `review.extensions` | `string[]` | `['.js','.ts','.py','.go']` | File extensions to include in code reviews |
+| `review.sourceDir` | `string` | `src/` | Source directory for git diffs |
+| `web.port` | `number` | `3847` | Web dashboard port |
+| `roleplay.enabled` | `boolean` | `true` | Enable multi-agent chat room |
+| `roleplay.verbosity` | `string` | `normal` | `quiet`, `normal`, `verbose` |
+| `roleplay.pmPersonality` | `string` | `professional` | PM agent tone |
+| `roleplay.maxReviewCycles` | `number` | `3` | Auto-approve after N review loops |
+| `roleplay.autoDeployOnApproval` | `boolean` | `false` | Auto-deploy when review passes |
+| `roleplay.openclawBridge` | `boolean` | `true` | Enable OpenClaw WebSocket bridge |
+| `pipeline` | `array` | See above | Array of `{ stage, provider, model, fallbacks }` entries |
+| `ollama.model` | `string` | `llama3.1` | Default Ollama model |
+| `ollama.baseUrl` | `string` | `http://localhost:11434` | Ollama server endpoint |
+
+## CLI Commands
+
+```
+aicc                     Launch interactive terminal menu
+aicc init                Set up a new project (creates aicc.config.js)
+aicc start               Start all services (web + telegram + twitch + openclaw bridge)
+aicc web                 Start the web dashboard
+aicc telegram            Start the Telegram bot
+aicc twitch              Start the Twitch bot
+aicc openclaw            Generate OpenClaw skills for all pipeline stages
+aicc doctor              Health check + auto-repair (validates skills, dirs, tools)
+aicc events              Stream pipeline events as NDJSON (for scripting)
+aicc status              Show pipeline status (JSON)
+aicc health              Show health check (JSON)
+aicc feature "desc"      Create a new feature
+aicc deploy              Deploy to target
+aicc approve             Approve current feature
+aicc reject "reason"     Reject with feedback
+aicc review              Get latest review
+aicc logs                Show recent logs
+aicc cleanup             Archive workflow files
+aicc reset               Abandon current feature
+aicc --version           Show version
+aicc --help              Show this help
+```
+
+## Multi-Agent Roleplay
+
+When `roleplay.enabled = true`, the PM agent becomes an **autonomous orchestrator** that runs the entire pipeline and communicates with the team in a shared chat room — visible in Telegram, Slack, WebSocket, and the Office Visualizer.
+
+```
+CEO (you): /feature Add user notification system
+
+📝 PM is writing the feature spec...
+⏳ PM spec in progress... (2min elapsed)
+📝 Spec complete
+🏗 Architect is designing the architecture...
+🏗 Architecture + tasks complete
+⚡ Coder is implementing...
+[█████████░░░░░░░░░░░] 45%  (4/9 tasks)
+🔨 Working on: TASK-005: Add PushAdapter module
+✅ TASK-004: Create notification schema
+⚡ Implementation complete
+🔍 Reviewer is reviewing implementation... (cycle 1/3)
+🔍 Review cycle 1/3: APPROVED
+✅ Feature approved — deploying now...
+🚀 Deployment complete! Feature shipped! 🎉
+```
+
+**PM Authority** — the PM is an employee with authority, not an assistant:
+
+| PM Acts Alone | PM Informs You After | PM Asks You |
+|--------------|---------------------|-------------|
+| Switch AI providers when rate-limited | Had to switch providers mid-stage | Feature is truly ambiguous |
+| Retry failed stages (up to 5 attempts) | Used Ollama as fallback | Deploy to production |
+| Kill hung processes and restart | Review loop exceeded 3 cycles | All providers down >30 min |
+| Break review loops after 3 cycles | Stage took longer than estimated | Budget limit reached |
+| Auto-resume when providers recover | — | — |
+
+Set `roleplay.enabled = false` to disable — the system behaves as a direct pipeline with no chat messages.
+
+## Project Structure
+
+```
+your-project/
+├── aicc.config.js              # Project configuration
+├── GEMINI.md                   # Gemini role instructions
+├── .env                        # Secrets (Telegram tokens, AI mode)
+│
+├── .ai-workflow/               # Pipeline state (auto-managed)
+│   ├── status.json             # Current pipeline status
+│   ├── model-bans.json         # Rate-limit / capacity bans with TTL
+│   ├── circuit-breakers.json   # Provider health state
+│   ├── costs.jsonl             # Token usage log
+│   ├── skills/                 # Project-local skill overrides (highest priority)
+│   ├── inbox/                  # Feature requests
+│   ├── specs/                  # PM specifications (SPEC-*.md)
+│   ├── architecture/           # Architecture documents (ARCH-*.md)
+│   ├── tasks/                  # Implementation tasks (TASKS-*.md)
+│   ├── reviews/                # Code review reports (REVIEW-*.md)
+│   ├── checkpoints/            # Per-stage checkpoints (SHA-256 integrity)
+│   ├── sessions/               # AI conversation session IDs
+│   └── logs/                   # Activity logs
+│
+├── .claude/
+│   ├── skills/                 # Legacy AI skill prompt templates
+│   └── agents/                 # Claude Code agent definitions
+│
+└── .github/
+    └── copilot-instructions.md # Copilot CLI project context
+
+~/.openclaw/skills/<project>/   # OpenClaw skills (generated by `aicc openclaw`)
+    ├── SKILL.md                # PM Agent persona + cron config
+    ├── SKILL-requirement-capture.md
+    ├── SKILL-pm-spec.md
+    ├── SKILL-architect.md
+    ├── SKILL-implement.md
+    └── SKILL-review.md
+```
+
+## Telegram Bot
+
+```sh
+# Set credentials in .env
+MYPROJ_TELEGRAM_TOKEN=your_bot_token
+MYPROJ_TELEGRAM_CHAT_ID=your_chat_id
+MYPROJ_TELEGRAM_ALLOWED_IDS=user_id_1,user_id_2
+
+# Start
+aicc telegram
+```
+
+Typing `/` in Telegram shows all available commands with descriptions (auto-registered via `setMyCommands`).
+
+| Command | Description |
+|---------|-------------|
+| `/feature <desc>` | Submit a new feature |
+| `/bug <desc>` | Report and fix a bug |
+| `/status` | Pipeline status |
+| `/review` | Trigger code review |
+| `/approve` | Approve current feature |
+| `/reject <reason>` | Reject with reason |
+| `/implement` | Trigger Coder implementation |
+| `/deploy` | Deploy to environment |
+| `/health` | System health check |
+| `/logs` | View session logs |
+| `/docs` | Browse pipeline documents |
+| `/costs` | AI usage & cost summary |
+| `/leaderboard` | AI model performance |
+| `/audit` | Recent audit log |
+| `/autopilot` | Toggle auto-pilot mode |
+| `/reset` | Reset / abandon feature |
+| `/cleanup` | Clean up workspace |
+| `/retry` | Retry from checkpoint |
+| `/ask <question>` | Ask AI a question |
+| `/aimode` | View/toggle AI mode |
+| `/dryrun` | Pipeline dry run |
+| `/menu` | Show main menu buttons |
+| *(plain text)* | When roleplay is on: talks to PM agent |
+
+When OpenClaw bridge is active, the built-in Telegram bot is skipped to avoid conflicts — OpenClaw handles all channels.
+
+## Twitch Bot
+
+```sh
+MYPROJ_TWITCH_CHANNEL=your_channel
+MYPROJ_TWITCH_ACCESS_TOKEN=your_oauth_token
+MYPROJ_TWITCH_CLIENT_ID=your_client_id
+MYPROJ_TWITCH_ALLOWED_IDS=twitch_user_id_1
+
+aicc twitch
+```
+
+Commands use `!` prefix: `!status`, `!feature <desc>`, `!review`, `!deploy`, `!approve`, `!reject <reason>`, `!ai <question>`.
+
+## Web Dashboard
+
+```sh
+aicc web
+# => http://localhost:3847
+```
+
+Real-time dashboard with WebSocket updates:
+- Pipeline status with stage visualization
+- Feature creation and management
+- Code review viewer with verdict display
+- Deploy controls with live output
+- Log viewer with session history
+- AI chat for project questions
+- **AI Office Visualizer** — pixel-art RPG canvas with animated agent characters (PM, Architect, Coder, Reviewer, Deployer), A* pathfinding, day/night cycle, chat bubbles, sound effects, feature ticket handoff animations with delivery tracking, work state indicators (📝 On it!, 📐 Designing..., 🔍 Reviewing..., 🚀 Deploying!), bug battle animations, and real-time pipeline stage sync
+
+## Hub Server
+
+The hub aggregates status from multiple AICC-powered projects into a single dashboard:
+
+```sh
+aicc hub
+# => http://localhost:3850/office/
+```
+
+- **Real-time WebSocket subscriptions** to each project's `/ws` for instant status updates
+- **Health polling** as a fallback with configurable interval
+- **Office Visualizer** at `/office/` — multi-project pixel-art view with all characters and pipelines
+- **REST API** at `/api/projects` — aggregated project states, health, and summary
+
+Configure in `aicc.config.js`:
+
+```js
+hub: {
+  port: 3850,
+  projects: [
+    { name: 'MyApp',   url: 'http://localhost:3847', icon: '🎯' },
+    { name: 'Backend', url: 'http://localhost:3848', icon: '⚙️' },
+  ],
+},
+```
+
+## Environment Variables
+
+All variables use the configured prefix (default: `AICC`).
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `{PREFIX}_AI_MODE` | No | `hybrid` (default), `cloud`, `local` |
+| `{PREFIX}_TELEGRAM_TOKEN` | For Telegram | Bot token from @BotFather |
+| `{PREFIX}_TELEGRAM_CHAT_ID` | For notifications | Your chat ID |
+| `{PREFIX}_TELEGRAM_ALLOWED_IDS` | For security | Comma-separated user ID whitelist |
+| `{PREFIX}_TWITCH_CHANNEL` | For Twitch | Channel name |
+| `{PREFIX}_TWITCH_ACCESS_TOKEN` | For Twitch | OAuth token |
+| `{PREFIX}_TWITCH_CLIENT_ID` | For Twitch | Client ID |
+| `{PREFIX}_TWITCH_ALLOWED_IDS` | For security | Comma-separated user ID whitelist |
+| `{PREFIX}_WEB_PORT` | No | Override web dashboard port |
+| `GEMINI_MODEL` | No | Override Gemini model |
+| `CLAUDE_MODEL` | No | Override Claude Code model (hyphen format) |
+| `COPILOT_MODEL` | No | Override Copilot model (period format) |
+| `OLLAMA_MODEL` | No | Override Ollama model |
+| `OLLAMA_BASE_URL` | No | Ollama API endpoint |
+
+## Examples
+
+### Claude Code Max
+
+```js
+export default {
+  name: 'my-project',
+  envPrefix: 'MYPROJ',
+  roleplay: { enabled: true, verbosity: 'normal' },
+  pipeline: [
+    { stage: 'chat',      provider: 'openclaw', model: 'auto',               fallbacks: ['copilot:claude-haiku-4.5']                },
+    { stage: 'pm',        provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'architect', provider: 'copilot', model: 'claude-opus-4.6',    fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'implement', provider: 'claude',  model: 'claude-sonnet-4-6',  fallbacks: ['copilot:claude-sonnet-4.6', 'ollama']    },
+    { stage: 'review',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'deploy',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+  ],
+};
+```
+
+### Salesforce
+
+```js
+export default {
+  name: 'xConnector',
+  envPrefix: 'XCONN',
+  deploy: {
+    command: 'sf project deploy start',
+    options: [
+      { name: 'Run Tests', value: '--test-level RunLocalTests' },
+      { name: 'No Tests', value: '--test-level NoTestRun' },
+    ],
+  },
+  review: { extensions: ['.cls', '.js', '.html', '.xml', '.css'], sourceDir: 'force-app/' },
+};
+```
+
+### Node.js API
+
+```js
+export default {
+  name: 'my-api',
+  envPrefix: 'MYAPI',
+  deploy: { command: 'npm run deploy' },
+  review: { extensions: ['.ts', '.tsx', '.js', '.jsx'], sourceDir: 'src/' },
+};
+```
+
+## Programmatic API
+
+```js
+import { loadConfig, getConfig } from 'ai-control-center/config';
+import { getStatusData, runNewFeature, runDeploy } from 'ai-control-center/actions';
+import { getStatus, updateStatus } from 'ai-control-center/pipeline';
+
+await loadConfig();
+const status = getStatusData();
+console.log(`Stage: ${status.stage}`);
+```
+
+## Prerequisites
+
+**Required:** Node.js >= 18, Git
+
+**Optional (at least one AI CLI recommended):**
+- [Claude Code](https://claude.ai/code) — primary for `implement` stage
+- [GitHub Copilot CLI](https://docs.github.com/en/copilot) — PM, architecture, review
+- [Gemini CLI](https://ai.google.dev/gemini-api/docs/cli) — fallback for all stages
+- [Ollama](https://ollama.com) — local AI fallback
+- [OpenClaw](https://openclaw.dev) — AI skill engine + multi-channel gateway (optional)
+
+## FAQ
+
+<details>
+<summary><strong>Do I need all the AI CLIs installed?</strong></summary>
+
+No. The control center works with whichever tools you have. You need at least one AI CLI for the pipeline to work; Ollama can serve as a fully local fallback.
+</details>
+
+<details>
+<summary><strong>What is OpenClaw?</strong></summary>
+
+[OpenClaw](https://openclaw.dev) is a self-hosted AI gateway. AICC leverages OpenClaw's **skill system** as its primary feature — `aicc openclaw` generates 6 stage-specific skills that guide each AI agent's behavior throughout the pipeline. Skills are loaded from `~/.openclaw/skills/<project>/` and injected into AI prompts at each stage. OpenClaw also bridges messaging channels (Telegram, WhatsApp, Slack, Discord) to the pipeline.
+</details>
+
+<details>
+<summary><strong>How does provider failover work?</strong></summary>
+
+Each `pipeline[]` entry has a primary `provider:model` and optional `fallbacks`. On rate limits, the system waits and retries. On capacity exhaustion, it moves to the next fallback. Circuit breakers prevent hammering a broken provider.
+</details>
+
+<details>
+<summary><strong>Can I customize AI behavior per stage?</strong></summary>
+
+Yes. Edit skill files in `.ai-workflow/skills/` (project-local, highest priority) or `~/.openclaw/skills/<project>/` (generated by `aicc openclaw`). Skills are markdown files with YAML frontmatter that define how each AI agent should behave — what to analyze, what format to output, what rules to follow.
+</details>
+
+<details>
+<summary><strong>Can I use this with a monorepo?</strong></summary>
+
+Yes. Place `aicc.config.js` at your monorepo root. Set `review.sourceDir` to the relevant subdirectory.
+</details>
+
+## Contributing
+
+Contributions are welcome. Please open an issue first to discuss what you'd like to change.
+
+## License
+
+[MIT](LICENSE)