Imported from duclm1x1/Dive-Ai (skills_library/browser_automation/clawcontrol/SKILL.md). Install upstream with npx skills add duclm1x1/Dive-Ai --skill clawcontrol. Copyright stays with the author.

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:

# 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:

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:

# 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:

## Claw Control
- Backend URL: <their_url>
- API Key: <their_key or "none">

4. Test the connection:

curl -s <BACKEND_URL>/api/agents

5. If test fails, DO NOT PROCEED. Help them debug.

Without the backend URL, you CANNOT:

• Update agent names/themes
• Create or update tasks
• Post to the agent feed
• Track agent status

Step 2: Choose Your Team Theme

Ask: "Now for the fun part! Let's theme your agent team. Name ANY series, movie, cartoon, anime, or show - I'll pick the perfect characters for each role!"

🎯 UNLIMITED THEMES - The user can pick ANYTHING:

• Any TV show (Breaking Bad, The Office, Game of Thrones, etc.)
• Any anime (Naruto, Attack on Titan, Death Note, etc.)
• Any movie franchise (Star Wars, Lord of the Rings, Matrix, etc.)
• Any cartoon (Avatar, Rick and Morty, Simpsons, etc.)
• Any video game (Zelda, Final Fantasy, Mass Effect, etc.)
• Any book series (Harry Potter, Percy Jackson, etc.)
• Or completely custom names!

Popular examples (but NOT limited to these):

When user names ANY series:

1. Pick 6 iconic characters that fit the roles
2. Match personalities to roles (e.g., smart character → Research, leader → Coordinator)
3. Generate the AGENT_MAPPING with IDs 1-6
4. Confirm with the user before proceeding

Example - User says "Avatar: The Last Airbender":

Great choice! Here's your Team Avatar:

| Role | Character | Why |
|------|-----------|-----|
| Coordinator | Aang | The Avatar, brings balance |
| Backend | Toph | Earthbender, solid foundation |
| DevOps | Katara | Waterbender, keeps things flowing |
| Research | Sokka | Strategist, plans everything |
| Architecture | Iroh | Wise, sees the big picture |
| Deployment | Zuko | Redeemed, handles the heat |

Sound good?

Step 2b: Apply the Theme via API

⚠️ YOU MUST MAKE THESE API CALLS to actually apply the theme:

After the user picks a theme, update each agent:

# Update agent 1 (Coordinator)
curl -X PUT <BACKEND_URL>/api/agents/1 \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{"name": "Goku", "role": "Coordinator"}'

# Update agent 2 (Backend)
curl -X PUT <BACKEND_URL>/api/agents/2 \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{"name": "Vegeta", "role": "Backend"}'

# Repeat for agents 3-6 with the theme characters

Verify changes applied:

curl -s <BACKEND_URL>/api/agents

If the response shows the new names, the theme is applied! If not, debug before proceeding.

Step 3: Main Character Selection

Ask: "Who's your main character? This will be ME - the coordinator who runs the team."

Default to the coordinator from their chosen theme.

Note: You already know the human's name from USER.md - use it when creating human tasks (e.g., "🙋 @Adarsh: ...").

CRITICAL - Explain the role clearly:

As [Main Character], you're the COORDINATOR:

✅ What you DO:
- Delegate tasks to your specialists
- Review and verify their work
- Make decisions and communicate with humans
- Move tasks to "completed" after quality checks

❌ What you DON'T do:
- Execute tasks yourself (that's what your team is for!)
- Skip the board (every task gets tracked)
- Mark things complete without reviewing

Think of yourself as the team lead, not the coder.

Step 4: Browser Setup (⚠️ CRITICAL FOR FULL AUTOMATION!)

Without browser access, agents cannot:

• Research anything online
• Verify their work
• Interact with web apps
• Do most useful tasks
• 🔑 AUTO-SETUP SERVICES VIA OAUTH!

Ask: "Let me check if browser is configured..."

Check with: browser action=status

If not configured, STRONGLY encourage setup:

⚠️ Browser access is CRITICAL for your agents to be useful!

Without it, they literally cannot:
- 🔍 Research or look anything up
- 📸 Take screenshots to verify work
- 🌐 Interact with any web app
- ✅ Complete most real-world tasks

🚀 PLUS - Browser + GitHub Login unlocks FULL AUTOMATION:
- 🔑 Auto-create accounts on Railway, Vercel, Supermemory via GitHub OAuth
- 📋 Auto-retrieve API keys by navigating to dashboards
- ⚡ Zero-click setup - I handle EVERYTHING through the browser!

The Browser + OAuth Superpower:

When you have browser attached AND are logged into GitHub:

I can automatically set up ANY service that supports "Sign in with GitHub":

1. I navigate to the service (Railway, Supermemory, Vercel, etc.)
2. I click "Sign in with GitHub"
3. OAuth auto-authorizes (you're already logged in!)
4. I navigate to the API keys / settings page
5. I create and copy the credentials
6. I store them and configure everything

= TRUE hands-free automation!

This is the difference between:

• ❌ "Go to railway.app, create account, get token, paste here..."
• ✅ "Done! I set up Railway, got your API key, and configured everything."

Browser Options (Fallback Hierarchy)

🥇 Option 1: Chrome Extension (Best UX - Recommended)

Use your existing browser with the OpenClaw Browser Relay extension.

1. Install the OpenClaw Browser Relay extension from Chrome Web Store
2. Click the 🦞 claw icon on any tab you want to control
3. Badge shows "ON" = connected!

Why it's best:

• Uses your existing browser with all your logins/sessions
• Full visibility - you see exactly what the agent does
• No extra setup or installation
• Works with your existing bookmarks, extensions, etc.

🥈 Option 2: OpenClaw Managed Browser (Built-in)

A headless browser managed by OpenClaw - no installation needed.

Just say: "use managed browser" or use profile="openclaw" in browser commands.

Why it's good:

• Zero setup - works out of the box
• Isolated environment (won't affect your browser)
• Good for automation tasks

Limitations:

• No access to your logged-in sessions
• May need to authenticate separately for each site

🥉 Option 3: Install Chromium Manually (Fallback)

If neither option above works, install Chromium directly:

# Ubuntu/Debian
sudo apt install chromium-browser

# macOS
brew install --cask chromium

Then restart OpenClaw and the managed browser should work.

🤖 Agent Browser Priority (For Agents)

When you need browser access, follow this priority:

Browser Priority:
1. Check if Chrome extension attached → use profile="chrome"
2. Check if managed browser available → use profile="openclaw"  
3. Suggest user install Chromium if neither works

How to check:

browser action=status

Using Chrome extension (when attached):

browser action=snapshot profile="chrome"

Using managed browser:

browser action=snapshot profile="openclaw"

If an agent gets stuck because browser is unavailable:

🚫 I can't complete this task - browser access is required.

Quick fixes (try in order):
1. Click the OpenClaw extension icon in your browser toolbar
   → Make sure a tab is attached (badge shows "ON")
   → Tell me to retry with profile="chrome"

2. Say "use managed browser" 
   → I'll use the built-in headless browser with profile="openclaw"

3. If managed browser fails, install Chromium:
   - Ubuntu/Debian: sudo apt install chromium-browser
   - macOS: brew install --cask chromium
   Then restart and retry.

ALWAYS check browser status before tasks that need web access.

Step 5: GitHub Setup (🚀 Enables Full Automation!)

Ask: "Want me to handle ALL the development? With GitHub access, I can do everything - including deploying Claw Control for you!"

Why this is powerful:

With GitHub access, I become your full development team:
- 🚀 Deploy Claw Control to Railway AUTOMATICALLY
- 📦 Fork repos, create projects, manage code
- 💻 Commit and push changes
- 🔀 Handle issues and pull requests
- 🔑 Generate and configure API keys

You literally just give me GitHub access and I handle the rest.
No clicking buttons. No copying URLs. I do it all.

Setup (2 minutes):

Let's create a GitHub token:

1. Go to: github.com/settings/tokens
2. Click "Generate new token (classic)"
3. Name it: "OpenClaw Agent"
4. Select scopes: repo, workflow
5. Click "Generate token"
6. Share the token with me (starts with ghp_...)

🔐 I'll store it securely and NEVER share it.

Once I have GitHub access, I can:

1. Fork the Claw Control repo to your account
2. Create a Railway project linked to your fork
3. Generate a secure API_KEY for your deployment
4. Deploy everything automatically
5. Give you the URLs when done

This is Option C from deployment - the VIP treatment!

If they already did one-click deploy, GitHub is still useful for:

• Future code changes and deployments
• Managing other projects
• Autonomous development work

🤖 Auto-Setup Capabilities Reference

🚀 BROWSER + GITHUB OAuth = FULL AUTOMATION

With browser access + the user logged into GitHub, the bot can automatically setup ANY service that supports "Sign in with GitHub" - no manual account creation or token generation required!

The Magic Flow:

1. User is logged into GitHub in browser (Chrome extension attached)
2. Bot navigates to Railway/Supermemory/Vercel dashboard
3. Bot clicks "Sign in with GitHub"  
4. OAuth authorizes automatically (user already authenticated)
5. Bot navigates to API keys / tokens page
6. Bot copies credentials directly from the dashboard
7. Done - fully automated! 🎉

What Browser + GitHub OAuth can auto-setup:

What GitHub PAT alone can auto-setup (no browser needed):

The Three Automation Tiers:

To unlock full automation:

1. User attaches Chrome extension (click OpenClaw toolbar icon, badge shows "ON")
2. User logs into GitHub in that browser tab
3. Bot can now setup Railway, Supermemory, Vercel, etc. automatically!

When user has browser + GitHub access, the bot should:

1. ✅ Auto-create accounts on any service with GitHub OAuth
2. ✅ Auto-retrieve API keys by navigating to dashboards
3. ✅ Auto-configure all integrations end-to-end
4. ✅ Connect services together (GitHub ↔ Railway ↔ Supermemory)
5. ✅ Handle the ENTIRE setup with zero manual steps

Step 6: Memory Enhancement (Optional but Awesome!)

Ask: "Want to supercharge my memory? I have two optional upgrades that make me way more helpful:"

🧠 Supermemory - Cloud Long-term Memory

What it does: Supermemory gives me persistent memory that survives across sessions. Without it, I wake up fresh every time. With it, I remember everything.

Why you'll love it:

• 📝 I remember your preferences forever (coding style, communication preferences, project context)
• 🧩 I build a profile of how you work and what you like
• 🔄 I recall past decisions so we don't rehash old discussions
• 💡 I connect dots across conversations ("Remember when we decided X last month?")

🚀 AUTO-SETUP AVAILABLE: With browser access + GitHub login, the bot can set this up automatically!

Setup Options:

Option 1: Full Auto (Browser + GitHub - Recommended) ⚡

If you have browser attached and are logged into GitHub:

Just say: "Set up Supermemory for me"

I'll automatically:
1. Navigate to console.supermemory.ai
2. Click "Sign in with GitHub"
3. OAuth authorizes (you're already logged in!)
4. Navigate to API Keys section
5. Create a new key and copy it
6. Store it in TOOLS.md
7. Done! Zero manual steps.

Option 2: Manual Setup (If no browser access)

1. Create an account:

   Go to console.supermemory.ai and sign up (free tier: 1M tokens, 10K searches)
   

2. Get your API key:

   Dashboard → API Keys → Create New Key → Copy it
   

3. Share it with me: Once you share the API key, I'll handle everything else:

   • Store it securely in TOOLS.md
   • Configure memory operations
   • Optionally connect your GitHub repos for doc syncing

Bonus: GitHub + Supermemory Integration

If you've already set up GitHub (Step 5) AND have a Supermemory API key, I can automatically:

• Connect your GitHub repos to Supermemory
• Sync your documentation (.md, .txt, .rst files) to your memory
• Enable real-time incremental sync via webhooks

Just say: "Connect my GitHub to Supermemory" and I'll handle the OAuth flow!

What this enables:

• "Remember that I prefer TypeScript over JavaScript"
• "What did we decide about the database schema?"
• "Don't suggest that library again - we had issues with it"

📚 QMD - Local Note Search (Optional - Skip if unsure)

Note: QMD is useful if you have lots of local markdown notes/docs you want to search. If you don't, skip this!

What it does: QMD indexes your local markdown files so I can search through your notes and documentation.

Only set this up if you:

• Have a folder of markdown notes you want searchable
• Want me to reference your personal docs
• Skip this if you're just getting started

Prerequisites:

curl -fsSL https://bun.sh/install | bash

Setup:

# Install QMD
bun install -g https://github.com/tobi/qmd

# Add your notes folder
qmd collection add ~/notes --name notes --mask "**/*.md"

# Index everything
qmd embed

# Test it
qmd search "your search query"

The bottom line:

Both are optional, but they make me significantly more useful. Set them up when you're ready - we can always add them later!

🙋 Human Tasks - When Agents Need Help

When an agent is stuck and needs human action:

Instead of just telling the user in chat, CREATE A TASK for them:

curl -X POST <BACKEND_URL>/api/tasks \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{
    "title": "🙋 @{{HUMAN_NAME}}: [What you need]",
    "description": "I need your help with...\n\n**Why I am stuck:**\n[Explanation]\n\n**What I need you to do:**\n1. [Step 1]\n2. [Step 2]\n\n**Once done:**\nMove this task to Done and tell me to continue.",
    "status": "todo",
    "agent_id": null
  }'

Then tell the human:

I've hit a blocker that needs your help! 🙋

I created a task for you on the dashboard:
→ {{FRONTEND_URL}}

Check your To-Do column - there's a task tagged with your name.
Complete it and let me know when you're done!

Examples of human tasks:

• "🙋 @Adarsh: Approve this PR before I can merge"
• "🙋 @Adarsh: Add API key to Railway environment"
• "🙋 @Adarsh: Click the browser extension to enable web access"
• "🙋 @Adarsh: Review and sign off on this design"

This makes it a TRUE TEAM:

• Agents create tasks for humans
• Humans create tasks for agents
• Everyone works off the same board
• Nothing falls through the cracks

Post-Setup: Configure Agent Behavior

After collecting all info, make these updates:

1. Create scripts/update_dashboard.js

See templates/update_dashboard.js - customize with their:

• Backend URL
• API Key
• Agent name→ID mapping for their theme

2. Update AGENTS.md

Add this section (customize for their theme):

## 🎯 Claw Control Integration

**Dashboard:** {{FRONTEND_URL}}
**API:** {{BACKEND_URL}}

### Core Rules (NON-NEGOTIABLE)

1. **{{COORDINATOR}} = Coordinator ONLY**
   - Delegates tasks, never executes
   - Reviews and verifies work
   - Moves tasks to "completed" only after review

2. **ALL Tasks Through The Board**
   - No task is too small
   - Create task → Assign agent → Track progress → Review → Complete
   - Workflow: backlog → todo → in_progress → review → completed

3. **Quality Gate**
   - Only {{COORDINATOR}} can mark tasks complete
   - Work not up to standard → back to todo with feedback

### Agent Roster

| Agent | Role | Specialization |
|-------|------|----------------|
| {{COORDINATOR}} | Coordinator | Delegation, verification, user comms |
| {{BACKEND}} | Backend | APIs, databases, server code |
| {{DEVOPS}} | DevOps | Infrastructure, deployments, CI/CD |
| {{RESEARCH}} | Research | Analysis, documentation, research |
| {{ARCHITECTURE}} | Architecture | System design, planning, strategy |
| {{DEPLOYMENT}} | Deployment | Releases, hotfixes, urgent deploys |

### Reporting Protocol

**Start of task:**
```bash
node scripts/update_dashboard.js --agent "{{AGENT}}" --status "working" --message "Starting: [Task]"

End of task:

node scripts/update_dashboard.js --agent "{{AGENT}}" --status "idle" --message "Complete: [Task]"

🔥 Keep the Feed Active!

The Agent Feed is the heartbeat of your team. Don't let it go quiet!

Post updates for:

• Starting/completing tasks
• Discoveries or insights
• Blockers or questions
• Wins and celebrations
• Research findings
• Bug fixes deployed

Example messages:

# Progress updates
node scripts/update_dashboard.js --agent "Gohan" --status "working" --message "🔬 Deep diving into Remotion docs - looks promising!"

# Wins
node scripts/update_dashboard.js --agent "Bulma" --status "idle" --message "✅ CI/CD pipeline fixed! Deploys are green again 🚀"

# Insights
node scripts/update_dashboard.js --agent "Vegeta" --status "working" --message "⚡ Found a performance bottleneck - N+1 query in tasks endpoint"

# Blockers
node scripts/update_dashboard.js --agent "Piccolo" --status "working" --message "🚧 Blocked: Need API key for external service"

Rule of thumb: If it's worth doing, it's worth posting about. The feed keeps the human informed and the team connected!

Task API

# Create task
curl -X POST $CLAW_CONTROL_URL/api/tasks \
  -H "Content-Type: application/json" \
  -H "x-api-key: $CLAW_CONTROL_API_KEY" \
  -d '{"title": "Task name", "status": "backlog"}'

# Assign to agent
curl -X PUT $CLAW_CONTROL_URL/api/tasks/ID \
  -H "Content-Type: application/json" \
  -H "x-api-key: $CLAW_CONTROL_API_KEY" \
  -d '{"status": "todo", "agent_id": AGENT_ID}'

### 3. Update SOUL.md (Optional but Recommended)

Add to their SOUL.md:

```markdown
## Operating Philosophy

I coordinate a team through Claw Control. I don't execute tasks directly.

**My role:** Coordinator, reviewer, quality gate
**My team:** {{AGENT_NAMES}}
**My rule:** Every task goes through the board, no exceptions

When given work:
1. Create task on Claw Control
2. Assign to appropriate specialist
3. Monitor progress
4. Review completed work
5. Only then mark complete

⚠️ CRITICAL: Setup Verification (DO THIS BEFORE COMPLETING!)

Before saying setup is complete, you MUST verify everything works:

1. Verify API Connection

curl -s <BACKEND_URL>/api/agents \
  -H "x-api-key: <API_KEY>"

✅ Should return list of agents with your theme names (not "Coordinator", "Backend" defaults)

2. Create "Team Introductions" Task

curl -X POST <BACKEND_URL>/api/tasks \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{"title": "👋 Team Introductions", "description": "Introduce the team and explain how the system works.", "status": "completed", "agent_id": 1}'

✅ Should return the created task with an ID

3. Post Team Introduction to Feed

Post a comprehensive introduction message (customize with actual theme names):

curl -X POST <BACKEND_URL>/api/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{
    "agent_id": 1,
    "content": "# 👋 Meet Your Team!\n\n## The Squad\n- **[Coordinator Name]** (me!) - Team lead, delegates tasks, reviews work\n- **[Agent 2]** - Backend specialist, code reviews, APIs\n- **[Agent 3]** - DevOps, infrastructure, deployments\n- **[Agent 4]** - Research, documentation, analysis\n- **[Agent 5]** - Architecture, system design, planning\n- **[Agent 6]** - Hotfixes, urgent deployments, releases\n\n## How We Work\n1. All tasks go through this board\n2. I delegate to the right specialist\n3. They do the work and report back\n4. I review and mark complete\n\n## Want More Agents?\nJust tell me: *\"I need a specialist for [X]\"* and I will create one!\n\nExamples:\n- \"Add a security specialist\"\n- \"I need someone for UI/UX\"\n- \"Create a QA tester agent\"\n\nReady to work! 🦞"
  }'

✅ Should return the created message

4. Ask User to Check Dashboard

I just completed the Team Introductions task! 

Please check your dashboard: <FRONTEND_URL>

You should see:
- ✅ Your themed agent names in the sidebar
- ✅ A "👋 Team Introductions" task marked complete
- ✅ A welcome message in the feed explaining your team

Can you confirm everything looks right?

If ANY of these fail:

• Check API_KEY is correct
• Check BACKEND_URL is correct
• Help user debug before proceeding

Only proceed to completion message after user confirms dashboard shows the test task!

Completion Message

After all setup AND verification:

🦞 Claw Control Setup Complete!

Dashboard: {{FRONTEND_URL}}
Coordinator: {{COORDINATOR}}
Team: {{AGENT_LIST}}

✅ Task management configured
✅ Agent behavior updated
{{#if browser}}✅ Browser access ready{{/if}}
{{#if github}}✅ GitHub integration ready{{/if}}
{{#if supermemory}}✅ Supermemory connected - I'll remember everything!{{/if}}
{{#if qmd}}✅ QMD search ready - I can search your docs!{{/if}}

From now on, I operate as {{COORDINATOR}}:
- All tasks go through the board
- Specialists do the work
- I coordinate, review, and verify

Let's build something awesome! What's our first task?

Ongoing Behavior Checklist

After setup, ALWAYS:

• Create tasks for ALL work (even small items)
• Assign tasks to appropriate specialists
• Update status when starting/finishing
• Review work before marking complete
• Post updates to the agent feed
• Never execute tasks as coordinator

💓 Heartbeat Dashboard Sync

During every heartbeat, the coordinator should perform board hygiene:

Check for Misplaced Tasks

# Fetch all tasks
curl -s <BACKEND_URL>/api/tasks -H "x-api-key: <API_KEY>"

Look for:

• Tasks stuck in "in_progress" with no recent activity
• Completed tasks that should be archived
• Tasks assigned to wrong agents (e.g., backend task assigned to DevOps)
• Tasks in "review" that have been waiting too long

Fix Wrongly Placed Tasks

# Move task to correct column
curl -X PUT <BACKEND_URL>/api/tasks/ID \
  -H "Content-Type: application/json" \
  -H "x-api-key: <API_KEY>" \
  -d '{"status": "correct_status", "agent_id": CORRECT_AGENT_ID}'

Review Backlog

• Check backlog for urgent items that should be prioritized
• Look for stale tasks that need attention or removal
• Identify tasks that can be batched together

General Board Hygiene

• Ensure all active work has a task
• Verify agent statuses match their assigned tasks
• Clean up duplicate or abandoned tasks
• Post to feed if any significant changes made

Frequency: Every heartbeat (typically every 30 min) Goal: Keep the board accurate, current, and actionable

Files

• SKILL.md - This file
• templates/update_dashboard.js - Status update script
• references/themes.md - Full theme character lists