### Verify Installation and Automated Setup

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Commands to verify the successful installation of ClawTeam and its integration with OpenClaw, or alternatively, running the automated installation script.

```bash
clawteam --version
clawteam config health
openclaw skills list | grep clawteam

# Automated installer
bash scripts/install-openclaw.sh
```

--------------------------------

### Install ClawTeam from Source

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Clones the repository and installs the package in editable mode. Includes an optional step for P2P transport support via ZeroMQ.

```bash
git clone https://github.com/win4r/ClawTeam-OpenClaw.git
cd ClawTeam-OpenClaw
pip install -e .
pip install -e ".[p2p]"
```

--------------------------------

### Clawteam JSON Output Examples

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Examples demonstrating how to use the `--json` flag with clawteam commands for machine-readable output. This output can be piped to tools like `jq` for further processing.

```bash
clawteam --json team discover
clawteam --json board show my-team
clawteam --json task list my-team --status pending

# Combine with jq for scripting:
clawteam --json board show my-team | jq '.taskSummary'
clawteam --json task list my-team | jq '.[].subject'
```

--------------------------------

### Install ClawTeam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Installs the ClawTeam CLI using pip. Requires Python 3.10+. For P2P transport support, install with the 'p2p' extra.

```bash
pip install clawteam

```

```bash
pip install clawteam[p2p]

```

--------------------------------

### Live Kanban Board (Bash)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/cli-reference.md

Starts a live-updating kanban board for a specified team. The board auto-refreshes at a configurable interval. Press Ctrl+C to stop the live view.

```bash
clawteam board live <team> [--interval 2.0]
```

--------------------------------

### ClawTeam CLI - Manual Team Setup

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Manually create and configure an agent team, define tasks, and spawn agents.

```APIDOC
## ClawTeam CLI - Manual Team Setup

### Description
Provides a step-by-step guide to manually set up an agent team, including creating tasks with dependencies, spawning agents, and monitoring their progress.

### Method
CLI Command

### Endpoint
N/A (CLI command)

### Parameters
#### 1. Create Team
- **team spawn-team** (command) - Required - Command to create a new team.
- **<name>** (string) - Required - The name of the team to create.
- **-d "<desc>"** (string) - Required - A description for the team.
- **-n <leader>** (string) - Required - The name of the leader agent for the team.

#### 2. Create Tasks
- **task create <team>** (command) - Required - Command to create a task within a team.
- **"<subject>"** (string) - Required - The subject or title of the task.
- **-o <owner>** (string) - Required - The agent name assigned to own this task.
- **-d "<desc>"** (string) - Optional - A detailed description of the task.
- **--blocked-by <id>** (string) - Optional - The ID of a task that must be completed before this task can start.

#### 3. Spawn Agents
- **spawn** (command) - Required - Command to spawn an agent.
- **-t <team>** (string) - Required - The name of the team the agent belongs to.
- **-n <name>** (string) - Required - The name of the agent to spawn.
- **--task "<task description>"** (string) - Required - The description of the task the agent will work on.
- **--workspace** (flag) - Optional - Enables git worktree isolation for the agent.
- **--repo /path/to/repo** (string) - Optional - Specifies the repository path when using `--workspace`.

#### 4. Monitor
- **board show <team>** (command) - Displays a Kanban view of the team's tasks.
- **board attach <team>** (command) - Attaches to all agent tmux windows for side-by-side monitoring.
- **board serve --port <port>** (command) - Starts a web-based dashboard.

### Request Example
```bash
# 1. Create team
clawteam team spawn-team my-team -d "Build a web app" -n leader

# 2. Create tasks
clawteam task create my-team "Design API schema" -o architect
# Returns task ID, e.g., abc123
clawteam task create my-team "Implement auth" -o backend --blocked-by abc123
clawteam task create my-team "Build frontend" -o frontend --blocked-by abc123
clawteam task create my-team "Write tests" -o tester

# 3. Spawn agents
clawteam spawn -t my-team -n architect --task "Design the API schema for a web app"
clawteam spawn -t my-team -n backend --task "Implement OAuth2 authentication"
clawteam spawn -t my-team -n frontend --task "Build React dashboard"

# 4. Monitor
clawteam board show my-team
```

### Response
#### Success Response
- CLI commands will output status messages and task IDs upon successful execution.

#### Response Example
(CLI output indicating successful team/task creation, agent spawning, or board display)
```

--------------------------------

### Verify System Prerequisites

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Checks the installed versions of Python, tmux, and the chosen CLI coding agent to ensure compatibility with ClawTeam requirements.

```bash
python3 --version
tmux -V
openclaw --version
```

--------------------------------

### Process ClawTeam Output with JSON

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Examples of using the --json flag combined with jq to parse and manipulate team data and task lists in shell scripts.

```bash
clawteam task list my-team --json | jq '.[] | {id, subject, status}'
clawteam team status my-team --json | jq '.members[].name'
TASKS=$(clawteam task list my-team --status pending --json)
echo "$TASKS" | jq -r '.[].id' | while read id; do
  clawteam task update my-team "$id" --status in_progress
done
```

--------------------------------

### Manage Task Dependencies with Clawteam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/workflows.md

Demonstrates how to create a chain of dependent tasks where completion of one task automatically unblocks the next. Requires the Clawteam CLI installed and configured for the target team.

```bash
clawteam task create team "Task A" -o alice
clawteam task create team "Task B" -o bob --blocked-by aaa
clawteam task create team "Task C" -o carol --blocked-by bbb
clawteam task update team aaa --status completed
clawteam task update team bbb --status completed
```

--------------------------------

### Configure OpenClaw Templates with TOML

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/specs/2026-03-21-per-agent-model-assignment-design.md

Examples of defining agent models within a TOML configuration file. Shows both explicit per-agent overrides and the use of the 'auto' model strategy.

```toml
[template]
name = "code-review"
command = ["openclaw"]
model = "sonnet-4.6"

[template.leader]
name = "lead-reviewer"
model = "opus"

[[template.agents]]
name = "security-reviewer"
model = "codex"

[[template.agents]]
name = "style-checker"

[template]
name = "hedge-fund"
command = ["openclaw"]
model_strategy = "auto"

[template.leader]
name = "portfolio-manager"

[[template.agents]]
name = "quant-analyst"
model_tier = "strong"

[[template.agents]]
name = "data-collector"
```

--------------------------------

### Implement configuration unit tests

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Test cases for verifying default configuration values, custom model assignments, and round-trip serialization of ClawTeamConfig.

```python
def test_default_model_empty(self):
    cfg = ClawTeamConfig()
    assert cfg.default_model == ""

def test_model_tiers_empty(self):
    cfg = ClawTeamConfig()
    assert cfg.model_tiers == {}

def test_custom_model_config(self):
    cfg = ClawTeamConfig(default_model="opus", model_tiers={"strong": "gpt-5.4"})
    assert cfg.default_model == "opus"
    assert cfg.model_tiers["strong"] == "gpt-5.4"

def test_model_config_roundtrip(self):
    cfg = ClawTeamConfig(default_model="opus", model_tiers={"strong": "gpt-5.4"})
    save_config(cfg)
    loaded = load_config()
    assert loaded.default_model == "opus"
    assert loaded.model_tiers == {"strong": "gpt-5.4"}
```

--------------------------------

### Set Up Team and Tasks with ClawTeam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Demonstrates setting environment variables for agent identity, creating a team, adding tasks with assigned workers, and viewing the team's task board.

```bash
# Set identity for the current session
export CLAWTEAM_AGENT_ID="leader-001"
export CLAWTEAM_AGENT_NAME="leader"
export CLAWTEAM_AGENT_TYPE="leader"

# Create team
clawteam team spawn-team my-team -d "Project team" -n leader

# Create tasks
clawteam task create my-team "Design system" -o leader
clawteam task create my-team "Implement feature" -o worker1
clawteam task create my-team "Write tests" -o worker2

# View board
clawteam board show my-team

```

--------------------------------

### Configure OpenClaw Integration

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Installs the ClawTeam skill for OpenClaw and updates the execution approval configuration to allowlist mode, preventing agent blocking during command execution.

```bash
mkdir -p ~/.openclaw/workspace/skills/clawteam
cp skills/openclaw/SKILL.md ~/.openclaw/workspace/skills/clawteam/SKILL.md

python3 -c "
import json, pathlib
p = pathlib.Path.home() / '.openclaw' / 'exec-approvals.json'
if p.exists():
    d = json.loads(p.read_text())
    d.setdefault('defaults', {})['security'] = 'allowlist'
    p.write_text(json.dumps(d, indent=2))
"
openclaw approvals allowlist add --agent "*" "*/clawteam"
```

--------------------------------

### Configure and Launch Agents

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Commands for managing global configuration and launching agent teams using templates.

```bash
clawteam config show
clawteam config set transport p2p
clawteam config health

clawteam launch <template> --team <name> --goal "Build X"
clawteam template list
```

--------------------------------

### AI Hedge Fund Team Launch using TOML Template

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Launches a pre-configured 7-agent investment team using a TOML template with a single command. The team includes specialized analyst agents, a risk manager, and a portfolio manager to analyze and make investment decisions.

```bash
clawteam launch hedge-fund --team fund1 --goal "Analyze AAPL, MSFT, NVDA for Q2 2026"
```

--------------------------------

### Track and Manage Agent Costs

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Commands to report token usage, view cost summaries, and set budget constraints for agent teams to prevent overspending.

```bash
clawteam cost report my-team --input-tokens 1500 --output-tokens 800 --cost-cents 2.5 --provider anthropic --model claude-3-opus
clawteam cost show my-team
clawteam cost budget my-team 10.00
```

--------------------------------

### Launch Pre-built Agent Teams

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Quickly initialize a multi-agent team using predefined templates. This command sets up the necessary environment and agent roles automatically.

```bash
clawteam launch hedge-fund --team fund1
clawteam launch code-review --team review1
clawteam launch research-paper --team paper1
```

--------------------------------

### Create Team and Manage Task Dependencies

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/workflows.md

Demonstrates initializing a project team and defining tasks with sequential dependencies. Tasks are created with blocking constraints, and updating a parent task automatically unblocks dependent tasks.

```bash
export CLAWTEAM_AGENT_ID="leader-001"
export CLAWTEAM_AGENT_NAME="leader"
export CLAWTEAM_AGENT_TYPE="leader"

clawteam team spawn-team my-project -d "Web app development" -n leader

clawteam task create my-project "Design API schema" -o leader
clawteam task create my-project "Implement backend" -o backend-dev --blocked-by aaa11111
clawteam task create my-project "Build frontend" -o frontend-dev --blocked-by aaa11111
clawteam task create my-project "Integration testing" --blocked-by bbb22222,ccc33333

clawteam board show my-project
clawteam task update my-project aaa11111 --status completed
```

--------------------------------

### Show Kanban Board Details (Bash)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/cli-reference.md

Displays a detailed kanban board for a specified team, including headers, member inbox counts, and a 4-column task board. Supports JSON output for programmatic access.

```bash
clawteam board show <team>
clawteam --json board show <team>
```

--------------------------------

### ClawTeam CLI - Launch Templates

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Launch pre-built agent teams using predefined templates.

```APIDOC
## ClawTeam CLI - Launch Templates

### Description
Launches a pre-built agent team from a specified template. This is the recommended way to start with ClawTeam for common use cases.

### Method
CLI Command

### Endpoint
N/A (CLI command)

### Parameters
#### Command Parameters
- **launch** (command) - Required - The command to launch a team template.
- **template_name** (string) - Required - The name of the pre-built template (e.g., `hedge-fund`, `code-review`, `research-paper`).
- **--team** (string) - Optional - The name to assign to the new team. If not provided, a default name might be generated.

### Request Example
```bash
clawteam launch hedge-fund --team fund1
clawteam launch code-review --team review1
clawteam launch research-paper --team paper1
```

### Response
#### Success Response
- The command will initiate the creation and setup of the specified agent team.

#### Response Example
(CLI output indicating successful team launch and agent setup)
```

--------------------------------

### Configure Clawteam System Settings

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Manage system-level configurations including transport backends and permission prompts. These commands ensure the environment is correctly set up for agent operations.

```bash
clawteam config show                           # Show all settings
clawteam config set transport file             # Set transport backend
clawteam config set skip_permissions true      # Auto-skip permission prompts
clawteam config health                         # System health check
```

--------------------------------

### Show Team Overview (Bash)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/cli-reference.md

Provides a summary of all teams in a tabular format. Also supports JSON output for integration with other tools.

```bash
clawteam board overview
clawteam --json board overview
```

--------------------------------

### Manual Team Orchestration

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Demonstrates the manual process of creating a team, spawning specific workers with assigned tasks, and attaching to the monitoring board.

```bash
clawteam team spawn-team my-team -d "Build the auth module" -n leader
clawteam spawn --team my-team --agent-name alice --task "Implement OAuth2 flow"
clawteam spawn --team my-team --agent-name bob --task "Write unit tests for auth"
clawteam board attach my-team
```

--------------------------------

### Spawn and Coordinate Agents with ClawTeam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Shows how to spawn worker agents for a team, specifying tasks and optionally the backend and command. Also demonstrates attaching to agent workspaces and sending messages.

```bash
# Spawn workers — defaults: tmux backend, claude command, git worktree isolation, skip-permissions on
clawteam spawn --team my-team --agent-name worker1 --task "Implement the auth module"
clawteam spawn --team my-team --agent-name worker2 --task "Write unit tests"

# Or explicitly specify backend and command (positional args: [BACKEND] [COMMAND])
clawteam spawn tmux claude --team my-team --agent-name worker3 --task "Build API endpoints"
clawteam spawn subprocess claude --team my-team --agent-name worker4 --task "Run linting"

# Watch all agents working simultaneously (tiled tmux panes)
clawteam board attach my-team

# Send instructions
clawteam inbox send my-team worker1 "Start implementing the auth module"

# Monitor task board
clawteam board live my-team --interval 3

```

--------------------------------

### Implementing Model Parameter in Backend Logic

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Modifies the spawn method to accept a model parameter and inject it into the command list and environment dictionary.

```python
def spawn(self, ..., model: str | None = None):
    if model:
        final_command.extend(["--model", model])
        env_vars["CLAWTEAM_MODEL"] = model
```

--------------------------------

### Submit Plan for Approval (Bash)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/cli-reference.md

Submits a plan for leader approval. The plan content can be provided as inline text or a path to a file. An optional summary can be included.

```bash
clawteam plan submit <team> <agent> <plan-content-or-file> [--summary TEXT]
```

--------------------------------

### Configure System PATH and Symlinks

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Creates a symlink in ~/bin to ensure the clawteam binary is accessible in non-interactive shells and updates the shell profile to include the directory in the system PATH.

```bash
mkdir -p ~/bin
ln -sf "$(which clawteam)" ~/bin/clawteam
export PATH="$HOME/bin:$PATH"
```

--------------------------------

### Orchestrate Agents with Python API

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Demonstrates programmatic control over team creation, member management, task dependency tracking, and inter-agent communication using the ClawTeam Python library.

```python
from clawteam.team.manager import TeamManager
from clawteam.team.tasks import TaskStore
from clawteam.team.mailbox import MailboxManager
from clawteam.workspace import get_workspace_manager

config = TeamManager.create_team(name="my-team", leader_name="leader", leader_id="abc123", description="My agent team", user="alice")
member = TeamManager.add_member(team_name="my-team", member_name="worker1", agent_id="def456", agent_type="developer")

store = TaskStore("my-team")
task1 = store.create(subject="Design API", owner="architect", description="Create OpenAPI spec")
task2 = store.create(subject="Implement API", owner="developer", blocked_by=[task1.id])
store.update(task1.id, status=TaskStatus.completed)

mailbox = MailboxManager("my-team")
mailbox.send(from_agent="leader", to="worker1", content="Start working on auth module")

ws_mgr = get_workspace_manager()
workspace = ws_mgr.create_workspace(team_name="my-team", agent_name="worker1", agent_id="def456")
```

--------------------------------

### Team Management Commands (Bash)

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Commands for creating, discovering, viewing status, and cleaning up agent teams. Teams are identified by name and can have a descriptive purpose. Team status displays members and their roles.

```bash
clawteam team spawn-team my-team -d "Build the auth module" -n leader

clawteam team discover

clawteam team status my-team

clawteam team cleanup my-team --force
```

--------------------------------

### Manage Workspaces and Lifecycle

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Commands for managing git worktrees, agent plan approvals, and lifecycle states such as shutdowns and idle status.

```bash
clawteam workspace list <team>
clawteam workspace checkpoint <team> <agent>
clawteam workspace merge <team> <agent>
clawteam workspace cleanup <team> <agent>

clawteam plan submit <team> <agent> "plan" --summary "TL;DR"
clawteam plan approve <team> <plan-id> <agent> --feedback "LGTM"
clawteam plan reject <team> <plan-id> <agent> --feedback "Revise X"

clawteam lifecycle request-shutdown <team> <agent> --reason "done"
clawteam lifecycle approve-shutdown <team> <request-id> <agent>
clawteam lifecycle idle <team>
```

--------------------------------

### Agentic Software Engineering for Full-Stack App Development

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Automates the creation of a full-stack todo application with authentication, database, and a React frontend. A leader agent coordinates multiple specialized agents for different development tasks, managing dependencies and merging work.

```text
Human: "Build a full-stack todo app with auth, database, and React frontend."

Leader agent:
├── Creates tasks with dependency chains (API schema → auth + DB → frontend → tests)
├── Spawns 5 agents (architect, 2 backend, frontend, tester) in separate worktrees
├── Dependencies auto-resolve: architect completes → backend unblocks → tester unblocks
├── Agents coordinate via inbox: "Here's the OpenAPI spec", "Auth endpoints ready"
└── Leader merges all worktrees into main when complete
```

--------------------------------

### Create Task with Dependencies using ClawTeam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Illustrates creating a task that is blocked by the completion of other tasks, specifying dependencies using the '--blocked-by' flag.

```bash
# Create with dependencies
clawteam task create my-team "Deploy" --blocked-by <impl-task-id>,<test-task-id>

```

--------------------------------

### Committing Backend Changes

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Shell commands to stage and commit the implemented feature changes to the repository.

```bash
cd ~/Projects/ClawTeam-OpenClaw
git add clawteam/spawn/base.py clawteam/spawn/tmux_backend.py clawteam/spawn/subprocess_backend.py tests/test_spawn_backends.py
git commit -m "feat: add --model injection to spawn backends"
```

--------------------------------

### Execute test suite for model resolution

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Command-line instructions to execute the pytest suite for verifying the model resolution logic.

```bash
cd ~/Projects/ClawTeam-OpenClaw && python -m pytest tests/test_model_resolution.py -v
```

--------------------------------

### Manage Agent Sessions

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Utilities for saving, viewing, and clearing agent session states to support persistence and cleanup in multi-agent workflows.

```bash
clawteam session save my-team --session-id sess123 --last-task task456
clawteam session show my-team
clawteam session clear my-team --agent worker1
```

--------------------------------

### Spawn New Agent Process (Bash)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/cli-reference.md

Spawns a new agent process, configuring it with team environment variables. Supports different backends like 'subprocess' and 'tmux', and allows specifying agent name, type, and team.

```bash
clawteam spawn <backend> <command...> [options]
clawteam spawn subprocess claude --team dev-team --agent-name bob --agent-type researcher
```

--------------------------------

### ClawTeam Core Commands Reference

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Provides a reference for core command-line operations in ClawTeam for managing teams, spawning agents, handling tasks, messaging, and monitoring. These commands are essential for interacting with the multi-agent system.

```bash
# Team lifecycle
clawteam team spawn-team <team> -d "description" -n <leader>
clawteam team discover                    # List all teams
clawteam team status <team>               # Show members
clawteam team cleanup <team> --force      # Delete team

# Spawn agents
clawteam spawn --team <team> --agent-name <name> --task "do this"
clawteam spawn tmux codex --team <team> --agent-name <name> --task "do this"

# Task management
clawteam task create <team> "subject" -o <owner> --blocked-by <id1>,<id2>
clawteam task update <team> <id> --status completed   # auto-unblocks dependents
clawteam task list <team> --status blocked --owner worker1
clawteam task wait <team> --timeout 300

# Messaging
clawteam inbox send <team> <to> "message"
clawteam inbox broadcast <team> "message"
clawteam inbox receive <team>             # consume messages
clawteam inbox peek <team>                # read without consuming

# Monitoring
clawteam board show <team>                # terminal kanban
clawteam board live <team> --interval 3   # auto-refresh
clawteam board attach <team>              # tiled tmux view
clawteam board serve --port 8080          # web UI
```

--------------------------------

### Define Global CSS Variables and Base Styles

Source: https://github.com/win4r/clawteam-openclaw/blob/main/clawteam/board/static/index.html

Sets up the design system foundation including color variables, border radii, and global reset styles for the application.

```css
:root { --bg: #000000; --surface: #0a0a0a; --surface2: #111111; --surface3: #1a1a1a; --border: rgba(255,255,255,0.08); --border-hover: rgba(255,255,255,0.15); --text: #f5f5f7; --text-secondary: #86868b; --text-tertiary: #6e6e73; --accent: #ffffff; --green: #30d158; --orange: #ff9f0a; --red: #ff453a; --blue: #0a84ff; --purple: #bf5af2; --radius: 12px; --radius-sm: 8px; }
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; -webkit-font-smoothing: antialiased; }
```

--------------------------------

### React DOM Rendering

Source: https://github.com/win4r/clawteam-openclaw/blob/main/clawteam/board/static/index.html

This code snippet demonstrates how to render a React application into the DOM. It uses ReactDOM.createRoot to find the root element in the HTML and then renders the main App component.

```javascript
ReactDOM.createRoot(document.getElementById('root')).render(<App />);
```

--------------------------------

### Process JSON Output with jq

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/workflows.md

Shows how to pipe JSON output from the Clawteam CLI into jq for data extraction and formatting. Useful for automation scripts and parsing complex team status data.

```bash
BLOCKED=$(clawteam --json task list dev-team --status blocked)
echo "$BLOCKED" | jq -r '.[].id'
clawteam --json board overview | jq '.[] | "\(.name): \(.pendingMessages) pending"'
clawteam --json team status dev-team | jq -r '.members[].name'
```

--------------------------------

### Multi-Agent Spawn and Coordination

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/workflows.md

Covers the lifecycle of spawning worker agents, assigning tasks, and communicating via the inbox system. Includes both leader-side orchestration and worker-side task execution.

```bash
# Leader side
clawteam team spawn-team dev-team -d "Feature development" -n leader
clawteam spawn tmux claude --team dev-team --agent-name researcher --agent-type researcher
clawteam spawn tmux claude --team dev-team --agent-name coder --agent-type general-purpose
clawteam inbox send dev-team researcher "Research authentication patterns"

# Worker side
clawteam identity show
clawteam inbox receive dev-team
clawteam task update dev-team <task-id> --status completed
clawteam lifecycle idle dev-team --last-task <task-id> --task-status completed
```

--------------------------------

### Manual Team and Task Orchestration

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Create custom teams, define tasks with dependency chains, and spawn agents into isolated tmux windows. This workflow allows for granular control over agent assignments and task execution order.

```bash
clawteam team spawn-team my-team -d "Build a web app" -n leader

clawteam task create my-team "Design API schema" -o architect
clawteam task create my-team "Implement auth" -o backend --blocked-by abc123
clawteam task create my-team "Build frontend" -o frontend --blocked-by abc123
clawteam task create my-team "Write tests" -o tester

clawteam spawn -t my-team -n architect --task "Design the API schema for a web app"
clawteam spawn -t my-team -n backend --task "Implement OAuth2 authentication"
clawteam spawn -t my-team -n frontend --task "Build React dashboard"

clawteam board show my-team
clawteam board attach my-team
clawteam board serve --port 8080
```

--------------------------------

### Parse TOML with Model and Strategy Fields (Python)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

These tests verify the ability to load template configurations from TOML files that include model and model_strategy settings. It uses pytest fixtures for temporary paths and monkeypatching to simulate user directories.

```python
import pytest
import clawteam.templates as tmod
from clawteam.templates import load_template, AgentDef, TemplateDef # Assuming load_template is available

# Mock load_template if not directly importable
def load_template(name):
    # This is a placeholder. In a real scenario, this would parse a TOML file.
    # For testing purposes, we'll simulate the parsed object based on context.
    if name == "model-test":
        leader = AgentDef(name="boss", model="opus")
        agents = [AgentDef(name="worker", model_tier="cheap")]
        return TemplateDef(name="model-test", model="sonnet-4.6", leader=leader, agents=agents)
    elif name == "strategy-test":
        leader = AgentDef(name="boss", type="leader")
        return TemplateDef(name="strategy-test", model_strategy="auto", leader=leader)
    return None


class TestParseTomlWithModel:
    def test_toml_with_agent_model(self, tmp_path, monkeypatch):
        toml_content = """
[template]
name = "model-test"
model = "sonnet-4.6"

[template.leader]
name = "boss"
model = "opus"

[[template.agents]]
name = "worker"
model_tier = "cheap"
"""
        tpl_dir = tmp_path / "templates"
        tpl_dir.mkdir()
        (tpl_dir / "model-test.toml").write_text(toml_content)

        monkeypatch.setattr(tmod, "_USER_DIR", tpl_dir)

        tmpl = load_template("model-test")
        assert tmpl.model == "sonnet-4.6"
        assert tmpl.leader.model == "opus"
        assert tmpl.agents[0].model_tier == "cheap"

    def test_toml_with_strategy(self, tmp_path, monkeypatch):
        toml_content = """
[template]
name = "strategy-test"
model_strategy = "auto"

[template.leader]
name = "boss"
type = "leader"
"""
        tpl_dir = tmp_path / "templates"
        tpl_dir.mkdir()
        (tpl_dir / "strategy-test.toml").write_text(toml_content)

        monkeypatch.setattr(tmod, "_USER_DIR", tpl_dir)

        tmpl = load_template("strategy-test")
        assert tmpl.model_strategy == "auto"

```

--------------------------------

### Monitoring and Debugging with JSON

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/references/workflows.md

Provides commands for inspecting team health, including live monitoring and piping output to jq for automated parsing.

```bash
clawteam board overview
clawteam --json board show dev-team | jq '.taskSummary'
clawteam --json task list dev-team --status blocked | jq '.[].subject'
clawteam board live dev-team --interval 3
```

--------------------------------

### Task Management Commands (Bash)

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Commands for creating, listing, updating, and managing tasks within a team. Tasks can have dependencies, block other tasks, and be filtered by status or owner. Task completion automatically unblocks dependent tasks.

```bash
# Create a basic task
clawteam task create my-team "Implement user authentication" -o alice

# Create task with dependencies (blocked until dependencies complete)
clawteam task create my-team "Write integration tests" \
  -o bob \
  --blocked-by task1,task2

# Create task that blocks others
clawteam task create my-team "Design API schema" \
  -o architect \
  --blocks impl-task,test-task

# List all tasks
clawteam task list my-team

# Filter tasks by status or owner
clawteam task list my-team --status blocked
clawteam task list my-team --owner alice

# Update task status (auto-unblocks dependents when completed)
clawteam task update my-team a1b2c3d4 --status completed

# Get detailed task info
clawteam task get my-team a1b2c3d4

# Get task timing statistics
clawteam task stats my-team

# Wait for all tasks to complete (blocking)
clawteam task wait my-team --timeout 300
```

--------------------------------

### Execute project tests

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Shell commands to run specific unit tests or the full test suite using pytest.

```bash
cd ~/Projects/ClawTeam-OpenClaw && python -m pytest tests/test_config.py::TestClawTeamConfig::test_default_model_empty tests/test_config.py::TestGetEffective::test_default_model_from_env -v
cd ~/Projects/ClawTeam-OpenClaw && python -m pytest tests/test_config.py -v
```

--------------------------------

### Orchestrate Agent Swarms

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Commands for setting up a team, defining task dependencies, and spawning workers. This workflow enables autonomous management of complex projects through task chaining.

```bash
# Create team
clawteam team spawn-team <team> -d "<goal description>" -n leader

# Create tasks with dependency chains
clawteam task create <team> "Design API" -o architect
# Save the returned task ID (e.g., abc123)
clawteam task create <team> "Build backend" -o backend --blocked-by abc123
clawteam task create <team> "Build frontend" -o frontend --blocked-by abc123
clawteam task create <team> "Integration tests" -o tester --blocked-by <backend-id>,<frontend-id>

# Spawn workers
clawteam spawn -t <team> -n architect --task "Design REST API schema for <goal>"
clawteam spawn -t <team> -n backend --task "Implement backend based on API schema"
clawteam spawn -t <team> -n frontend --task "Build React frontend"
clawteam spawn -t <team> -n tester --task "Write and run integration tests"
```

--------------------------------

### ClawTeam CLI - Monitoring Board

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Commands for monitoring agent team progress using a Kanban board or a live tmux view.

```APIDOC
## ClawTeam CLI - Monitoring Board

### Description
Provides commands to monitor the progress of agent teams. This includes viewing tasks in a Kanban-style board, attaching to all agent tmux windows for a live, side-by-side view, and serving a web-based dashboard.

### Method
CLI Command

### Endpoint
N/A (CLI command)

### Parameters
#### Monitoring Commands
- **clawteam board show <team>**
  - **<team>** (string) - Required - The name of the team to display the board for.
  - Shows a Kanban-style view of all tasks in the specified team, their statuses, and owners.

- **clawteam board attach <team>**
  - **<team>** (string) - Required - The name of the team to attach to.
  - Opens a tmux session displaying all active agent windows for the specified team, allowing real-time monitoring.

- **clawteam board serve --port <port>**
  - **--port <port>** (integer) - Required - The port number on which to serve the web dashboard.
  - Starts a web server that provides a dashboard interface for monitoring team progress.

### Request Example
```bash
# Show the Kanban board for 'my-team'
clawteam board show my-team

# Attach to the tmux session for 'my-team'
clawteam board attach my-team

# Serve the web dashboard on port 8080
clawteam board serve --port 8080
```

### Response
#### Success Response
- `board show`: Displays the Kanban board in the terminal.
- `board attach`: Opens a new tmux window with agent views.
- `board serve`: Starts a web server and outputs the URL to access the dashboard.

#### Response Example
(Terminal output for Kanban board, tmux session initiation, or web dashboard URL)
```

--------------------------------

### Autonomous ML Research with 8 Agents and 8 GPUs

Source: https://github.com/win4r/clawteam-openclaw/blob/main/README.md

Launches 8 research agents across multiple GPUs to autonomously design and optimize experiments. Agents are managed by a leader agent that spawns, coordinates, and cross-pollinates configurations for improved results.

```text
Human: "Use 8 GPUs to optimize train.py. Read program.md for instructions."

Leader agent:
├── Spawns 8 agents, each assigned a research direction (depth, width, LR, batch size...)
├── Each agent gets its own git worktree for isolated experiments
├── Every 30 min: checks results, cross-pollinates best configs to new agents
├── Reassigns GPUs as agents finish — fresh agents start from best known config
└── Result: val_bpb 1.044 → 0.977 (6.4% improvement) across 2430 experiments in ~30 GPU-hours
```

--------------------------------

### Configure ClawTeam Environment Variables

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Sets the core environment variables required for ClawTeam operation, including user identity, transport protocol, workspace persistence, and backend spawning methods.

```bash
export CLAWTEAM_USER=alice
export CLAWTEAM_TRANSPORT=p2p
export CLAWTEAM_WORKSPACE=always
export CLAWTEAM_DEFAULT_BACKEND=tmux
```

--------------------------------

### Agent Spawning Commands (Bash)

Source: https://context7.com/win4r/clawteam-openclaw/llms.txt

Commands to spawn agent processes, assigning them to teams and tasks. Supports various backends (tmux, subprocess) and agent types (openclaw, claude, codex). Optional workspace isolation via git worktrees can be enabled. Environment variables are injected into spawned agents.

```bash
# Spawn an agent with default settings (tmux backend, openclaw command)
clawteam spawn --team my-team --agent-name worker1 --task "Implement OAuth2 flow"

# Spawn with specific backend and command
clawteam spawn tmux claude --team my-team --agent-name alice --task "Write unit tests"

# Spawn codex agent with workspace isolation
clawteam spawn tmux codex --team my-team --agent-name bob \
  --task "Implement database schema" \
  --workspace

# Spawn with custom Python script
clawteam spawn subprocess python my_agent.py --team my-team --agent-name custom1

# Resume a previous session
clawteam spawn --team my-team --agent-name worker1 --resume
```

--------------------------------

### Commit implementation changes

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Git command to stage and commit the newly implemented model resolution module and its corresponding tests.

```bash
cd ~/Projects/ClawTeam-OpenClaw
git add clawteam/model_resolution.py tests/test_model_resolution.py
git commit -m "feat: add resolve_model() with 7-level priority chain"
```

--------------------------------

### Unit Testing Spawn Backend Model Injection

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Uses pytest and monkeypatch to simulate a subprocess environment. It verifies that the 'model' argument is correctly passed to the command line and environment variables.

```python
monkeypatch.setattr(sys, "argv", [str(clawteam_bin)])
captured: dict[str, object] = {}
def fake_popen(cmd, **kwargs):
    captured["cmd"] = cmd
    captured["env"] = kwargs["env"]
    return DummyProcess()

monkeypatch.setattr("clawteam.spawn.command_validation.shutil.which", lambda name, path=None: "/usr/bin/openclaw" if name == "openclaw" else None)
monkeypatch.setattr("clawteam.spawn.subprocess_backend.subprocess.Popen", fake_popen)
backend = SubprocessBackend()
backend.spawn(command=["openclaw"], model="opus", ...)
assert "--model" in captured["cmd"]
assert captured["env"]["CLAWTEAM_MODEL"] == "opus"
```

--------------------------------

### Integrate Model Parameters in Spawn Backends

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/specs/2026-03-21-per-agent-model-assignment-design.md

Implementation of model parameter injection within the base spawn class and specific backends like Tmux and Subprocess.

```python
@abstractmethod
def spawn(
    self,
    command: list[str],
    agent_name: str,
    agent_id: str,
    agent_type: str,
    team_name: str,
    prompt: str | None = None,
    env: dict[str, str] | None = None,
    cwd: str | None = None,
    skip_permissions: bool = False,
    model: str | None = None,
) -> str:

# Tmux backend injection
if model:
    final_command.extend(["--model", model])

# Subprocess backend injection
if model:
    final_command.extend(["--model", model])

# Environment variable propagation
if model:
    env_vars["CLAWTEAM_MODEL"] = model
```

--------------------------------

### Attach to Agent Monitoring with Clawteam CLI

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/clawteam/SKILL.md

Commands to attach to a tiled view of all agent tmux windows for comprehensive observation. Alternatively, manually attach to the tmux session and switch windows.

```bash
# Tile all agent tmux windows into one view (best way to observe)
clawteam board attach my-team

# Or attach to the tmux session manually and switch windows with Ctrl-b + number	mux attach -t clawteam-my-team
```

--------------------------------

### Wire Model Resolution in Agent Loop

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Integrates the model resolution logic into the agent spawning loop. It uses the provided CLI overrides and configuration defaults to determine the final model, with a fallback warning if the command lacks support.

```python
resolved_model = resolve_model(
	cli_model=model_override,
	agent_model=agent.model,
	agent_model_tier=agent.model_tier,
	template_model_strategy=model_strategy_override or tmpl.model_strategy,
	template_model=tmpl.model,
	config_default_model=cfg.default_model,
	agent_type=agent.type,
	tier_overrides=cfg.model_tiers or None,
)

if resolved_model and not (_is_openclaw_command(a_cmd) or _is_claude_command(a_cmd)):
	console.print(f"[yellow]Warning: model '{resolved_model}' resolved for {agent.name} but command {a_cmd[0]} may not support --model[/yellow]")
```

--------------------------------

### Test AgentDef and TemplateDef Model Fields (Python)

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

These tests verify the default values and assignments for model and model_tier in AgentDef, and model and model_strategy in TemplateDef. It includes tests for valid and invalid tier/strategy values, ensuring proper validation.

```python
import pytest
from pydantic import ValidationError

# Assuming AgentDef and TemplateDef are imported from clawteam.templates
# from clawteam.templates import AgentDef, TemplateDef

# Mock classes for demonstration if not importable directly
class AgentDef:
    def __init__(self, name: str, type: str = "general-purpose", task: str = "", command: list[str] | None = None, model: str | None = None, model_tier: str | None = None):
        self.name = name
        self.type = type
        self.task = task
        self.command = command
        self.model = model
        self.model_tier = model_tier

    def validate_tier(self, v: str | None) -> str | None:
        VALID_TIERS = {"strong", "balanced", "cheap"}
        if v is not None and v not in VALID_TIERS:
            raise ValueError(f"Invalid model_tier '{v}'. Must be one of: {VALID_TIERS}")
        return v

class TemplateDef:
    def __init__(self, name: str, description: str = "", command: list[str] = ["openclaw"], backend: str = "tmux", model: str | None = None, model_strategy: str | None = None, leader: AgentDef, agents: list[AgentDef] = [], tasks: list[TaskDef] = []):
        self.name = name
        self.description = description
        self.command = command
        self.backend = backend
        self.model = model
        self.model_strategy = model_strategy
        self.leader = leader
        self.agents = agents
        self.tasks = tasks

    def validate_strategy(self, v: str | None) -> str | None:
        VALID_STRATEGIES = {"auto", "none"}
        if v is not None and v not in VALID_STRATEGIES:
            raise ValueError(f"Invalid model_strategy '{v}'. Must be one of: {VALID_STRATEGIES}")
        return v

class TaskDef:
    def __init__(self, subject: str, description: str = "", owner: str = ""):
        self.subject = subject
        self.description = description
        self.owner = owner


class TestModelFields:
    def test_agent_def_model_defaults_none(self):
        a = AgentDef(name="worker")
        assert a.model is None
        assert a.model_tier is None

    def test_agent_def_with_model(self):
        a = AgentDef(name="worker", model="opus")
        assert a.model == "opus"

    def test_agent_def_with_valid_tier(self):
        a = AgentDef(name="worker", model_tier="strong")
        assert a.model_tier == "strong"

    def test_agent_def_invalid_tier_raises(self):
        with pytest.raises(ValueError, match="model_tier"):
            AgentDef(name="worker", model_tier="ultra")

    def test_template_def_model_defaults(self):
        leader = AgentDef(name="lead")
        t = TemplateDef(name="test", leader=leader)
        assert t.model is None
        assert t.model_strategy is None

    def test_template_def_with_model(self):
        leader = AgentDef(name="lead")
        t = TemplateDef(name="test", leader=leader, model="sonnet-4.6")
        assert t.model == "sonnet-4.6"

    def test_template_def_valid_strategy(self):
        leader = AgentDef(name="lead")
        t = TemplateDef(name="test", leader=leader, model_strategy="auto")
        assert t.model_strategy == "auto"

    def test_template_def_none_strategy(self):
        leader = AgentDef(name="lead")
        t = TemplateDef(name="test", leader=leader, model_strategy="none")
        assert t.model_strategy == "none"

    def test_template_def_invalid_strategy_raises(self):
        leader = AgentDef(name="lead")
        with pytest.raises(ValueError, match="model_strategy"):
            TemplateDef(name="test", leader=leader, model_strategy="magic")

```

--------------------------------

### Enable Machine-Readable Output

Source: https://github.com/win4r/clawteam-openclaw/blob/main/skills/openclaw/SKILL.md

Prefix any clawteam subcommand with --json to receive output in JSON format, facilitating integration with automated scripts and external tools.

```bash
clawteam --json task list my-team
clawteam --json team status my-team
```

--------------------------------

### Auto Strategy Matches Architect to Strong Tier

Source: https://github.com/win4r/clawteam-openclaw/blob/main/docs/superpowers/plans/2026-03-21-per-agent-model-assignment.md

Tests the 'auto' strategy's mapping of 'system-architect' agent type to the 'strong' model tier. This verifies the function's ability to assign appropriate tiers based on agent roles.

```python
def test_architect_matches_strong(self):
        result = resolve_model(
            cli_model=None, agent_model=None, agent_model_tier=None,
            template_model_strategy="auto", template_model=None,
            config_default_model="", agent_type="system-architect",
        )
        assert result == DEFAULT_TIERS["strong"]
```