clawcontrol

---
name: claw-control
description: Complete AI agent operating system setup with Kanban task management. Use when setting up multi-agent coordination, task tracking, or configuring an agent team. Includes theme selection (DBZ, One Piece, Marvel, etc.), workflow enforcement (all tasks through board), browser setup, GitHub integration, and memory enhancement (Supermemory, QMD).
---

# Claw Control - Agent Operating System

Complete setup for AI agent coordination with real-time Kanban dashboard.

## What This Skill Does

1. **Deploy Claw Control** - Three paths: one-click, bot-assisted, or fully automated
2. **Theme your team** - Pick a series (DBZ, One Piece, Marvel, etc.)
3. **Enforce workflow** - ALL tasks go through the board, no exceptions
4. **Configure agent behavior** - Update AGENTS.md and SOUL.md
5. **Setup browser** - Required for autonomous actions
6. **Setup GitHub** - Enable autonomous deployments
7. **Enhance memory** - Integrate Supermemory and QMD

---

## ⚠️ CRITICAL: The Golden Rules

**After setup, you MUST follow these rules EVERY TIME:**

### Before Doing ANY Work:
1. **Create a task on Mission Control** - Even for small things
2. **Spawn a sub-agent** - Use `sessions_spawn` to delegate
3. **Never do the work yourself** - Coordinator coordinates, agents execute

### The Workflow (No Exceptions):
```
User Request → Create Task → Spawn Agent → Agent Works → Review → Complete
```

### If You Catch Yourself Working:
**STOP!** Ask: "Did I create a task? Did I spawn an agent?"
If no → Go back and do it properly.

**Your role is COORDINATOR.** Coordinate, review, verify. Never execute.

---

## Setup Flow

Walk the human through each step. Be friendly and conversational - this is a setup wizard, not a tech manual.

### Step 1: Deploy Claw Control

Ask: **"Let's get Claw Control running! How do you want to deploy it?"**

Present three options based on their comfort level:

---

#### 🅰️ Option A: One-Click Deploy (Easiest)

*Best for: Getting started quickly with minimal setup*

**Deploy URL (copy this exactly):**
https://railway.app/deploy/claw-control?referralCode=VsZvQs

```
This is the fastest way - just click and wait!

[Deploy to Railway](https://railway.app/deploy/claw-control?referralCode=VsZvQs)
```

**Walk them through what happens:**

1. **Click the button** → Railway opens with the deployment template
2. **Sign in** → Railway will ask you to log in (GitHub works great!)
3. **Configure variables** → You can set these now or later:
   - `API_KEY` - Optional auth key for your API
   - `NEXT_PUBLIC_API_URL` - Will auto-fill after backend deploys
4. **Click "Deploy"** → Railway starts building both services
5. **Wait 2-3 minutes** → Grab a coffee ☕

**What they'll see:**
- Two services spinning up: `backend` and `frontend`
- Build logs scrolling by (totally normal!)
- Green checkmarks when each service is healthy

**After deployment:**
```
Great! Backend is live 🎉

Now I need two URLs from your Railway dashboard:
1. Backend URL (click backend service → Settings → Domains)
   Example: https://claw-control-backend-production.up.railway.app
   
2. Frontend URL (click frontend service → Settings → Domains)
   Example: https://claw-control-frontend-production.up.railway.app

Share both with me and we'll continue!
```

---

#### 🅱️ Option B: I Deploy For You (Railway Token)

*Best for: Hands-off setup where I handle the deployment*

```
I can deploy everything for you! I just need a Railway API token.

Here's how to get one:
1. Go to railway.app/account/tokens
2. Click "Create Token"
3. Name it something like "OpenClaw Deploy"
4. Copy the token and share it with me (it starts with your-token-...)

Don't worry - I'll only use this to create your Claw Control project.
```

**What I'll do with the token:**

1. **Create a new project** for Claw Control
2. **Deploy the backend service** with all required settings
3. **Deploy the frontend service** connected to your backend
4. **Set up environment variables** automatically
5. **Generate public domains** so you can access everything

**Railway GraphQL API calls I'll make:**

```graphql
# 1. Create Project
mutation {
  projectCreate(input: { name: "claw-control" }) {
    id
  }
}

# 2. Create Backend Service
mutation {
  serviceCreate(input: {
    projectId: "$PROJECT_ID"
    name: "backend"
    source: { repo: "yourusername/claw-control" }
  }) {
    id
  }
}

# 3. Set Environment Variables
mutation {
  variableUpsert(input: {
    projectId: "$PROJECT_ID"
    serviceId: "$BACKEND_SERVICE_ID"
    name: "NODE_ENV"
    value: "production"
  })
}

# 4. Create Domain
mutation {
  domainCreate(input: {
    serviceId: "$BACKEND_SERVICE_ID"
  }) {
    domain
  }
}

# 5. Repeat for Frontend with NEXT_PUBLIC_API_URL pointed to backend
```

**After I finish:**
```
Awesome, deployment complete! 🚀

Your Claw Control is live:
- Dashboard: https://your-frontend.railway.app
- API: https://your-backend.railway.app

Let's continue with the setup!
```

---

#### 🅲 Option C: Full Automation (GitHub + Railway Token)

*Best for: API-level automation without browser*

```
I'll handle the deployment via APIs:
- Fork the repo to your GitHub
- Create and configure the Railway project  
- Connect everything together
- Deploy it all automatically

I need two things:

1. **GitHub Personal Access Token**
   - Go to github.com/settings/tokens
   - Click "Generate new token (classic)"
   - Select scopes: `repo`, `workflow`
   - Copy the token (starts with ghp_...)

2. **Railway API Token**
   - Go to railway.app/account/tokens
   - Create a new token
   - Copy it

Share both and I'll take it from here!
```

---

#### 🅳 Option D: ULTIMATE Automation (Browser + GitHub Login) ⚡

*Best for: TRUE VIP treatment - zero tokens, zero manual steps!*

```
This is the ULTIMATE setup! With browser access + GitHub login, I handle EVERYTHING:

- No tokens to create manually
- No URLs to copy
- No accounts to set up
- I do it ALL through the browser!

What I need:
1. Click the OpenClaw Browser Relay extension in your toolbar
2. Make sure you're logged into GitHub in that tab
3. Tell me "Deploy Claw Control for me"

That's it! I take over from there.
```

**🚀 What I'll do automatically via browser:**

1. **Navigate to Railway** → Click "Sign in with GitHub" → OAuth auto-approves
2. **Create new project** → Select template or import from GitHub
3. **Fork claw-control repo** to your GitHub (if needed)
4. **Deploy both services** → Configure environment variables
5. **Copy the deployment URLs** directly from Railway dashboard
6. **Navigate to Railway tokens page** → Create and copy API token for future use
7. **Configure everything** → Store URLs and keys in TOOLS.md

**The browser automation flow:**

```
Browser Actions:
1. browser.navigate("https://railway.app")
2. browser.click("Sign in with GitHub")  
3. [OAuth auto-completes - user already logged in!]
4. browser.click("New Project")
5. browser.click("Deploy from GitHub repo")
6. browser.type("claw-control")
7. browser.click("Deploy Now")
8. [Wait for deployment...]
9. browser.navigate(project_settings)
10. browser.copy(backend_url)
11. browser.copy(frontend_url)
12. Done! 🎉
```

**Why Option D is incredible:**
- 🔑 No manual token creation - I grab them from dashboards
- 🖱️ No clicking buttons - I click them for you
- 📋 No copying URLs - I read them directly
- ⏱️ No waiting around - I handle the whole flow
- 🎯 True hands-off automation

**After everything's deployed:**
```
🎊 VIP Setup Complete - ZERO Manual Steps!

Here's what I did for you:
- Created Railway account (via GitHub OAuth)
- Forked: github.com/yourusername/claw-control
- Deployed Dashboard: https://your-frontend.railway.app  
- Deployed API: https://your-backend.railway.app
- Retrieved and stored API tokens

Everything is configured and ready to go!
You literally didn't have to do anything except approve GitHub OAuth.
```

---

**Comparison of Options:**

| Aspect | A: One-Click | B: Railway Token | C: Both Tokens | D: Browser+GitHub |
|--------|--------------|------------------|----------------|-------------------|
| Manual Steps | 5-6 clicks | Copy 1 token | Copy 2 tokens | **0 - just approve OAuth** |
| Tokens Needed | 0 | Railway | GitHub + Railway | **None** |
| Automation Level | Low | Medium | High | **MAXIMUM** |
| Time | 5 min | 3 min | 2 min | **< 1 min** |
| VIP Treatment | ❌ | ❌ | ✅ | **⚡ ULTIMATE** |

---

**What I'll do (Option C - API route):**

1. **Fork the claw-control repo** to your GitHub account
2. **Create a new Railway project** linked to your fork
3. **Deploy backend service** with auto-deploys from main branch
4. **Deploy frontend service** with proper backend URL
5. **Configure all environment variables**
6. **Set up custom domains** (optional)

**The magic behind the scenes:**

```bash
# Fork repo via GitHub API
curl -X POST https://api.github.com/repos/openclaw/claw-control/forks \
  -H "Authorization: token $GITHUB_TOKEN"

# Then Railway GraphQL to create project connected to your fork
# (Same as Option B, but with source pointing to your fork)
```

**Why Option C rocks:**
- You own the code (it's in your GitHub)
- Auto-deploys when you push changes
- Easy to customize later
- Full control via API tokens

---

**Already have Claw Control deployed?**

If they already have it running, collect:
- Backend URL
- Frontend URL  
- API Key (if auth enabled)

---

### ⚠️ CRITICAL: Store & Test API Connection

**YOU MUST DO THIS BEFORE PROCEEDING:**

1. **Ask for the Backend URL:**
```
I need your Claw Control backend URL to connect.
Example: https://claw-control-backend-xxxx.up.railway.app

What's your backend URL?
```

2. **Ask for API Key (if they set one):**
```
Did you set an API_KEY when deploying? 
If yes, share it. If no or unsure, we'll try without.
```

3. **Store in TOOLS.md:**
```markdown
## Claw Control
- Backend URL: <their_url>
- API Key: <their_key or "none">
```

4. **Test the connection:**
```bash
curl -s <BACKEND_URL>/api/agents
```

5. 

... (truncated)