assets/claude/claude-md-orchestration.md
# Agent orchestration (merge into CLAUDE.md)
Copy the sections below into project or global `CLAUDE.md`. Full guide: fixmyskills `agent-orchestration` → [claude-code.md](references/claude-code.md).
---
## General preferences
- If asked to do too much work at once, stop and state that clearly.
- For bulk implementation, review, or verification, **shell out to `cursor-agent`** (Grok 4.6 Low, standard / not Fast) instead of doing token-heavy work inline on Fable.
- Load skills `cursor-worker-implement` and `cursor-worker-review` when delegating.
## Picking models (workflows and subagents)
Defaults, not limits. Override when output quality is not enough — judge output, not price; escalating costs less than shipping mediocre work.
| model | cost (delegate ↑) | intelligence | taste |
| ----------------------------------- | ----------------- | ------------ | ----- |
| **cursor-grok-4.6-low[fast=false]** | 9 | 7 | 7 |
| **opus-4.8** | 4 | 7 | 8 |
| **fable-5** | 2 | 9 | 9 |
- **Intelligence:** hardest problem the model can handle unsupervised.
- **Taste:** UI/UX, code quality, API design, copy.
- **Cost:** tiebreaker when axes conflict; for shipped work, intelligence > taste > cost.
### How to apply
- **Bulk / mechanical** (clear spec, migrations, data passes): `cursor-agent` + **cursor-grok-4.6-low[fast=false]** via `cursor-worker-implement`.
- **User-facing** (UI, copy, API shape): Fable or Opus; taste ≥ 7.
- **Reviews** of plans or implementations: Fable or Opus; optionally **cursor-grok-4.6-low[fast=false]** via `cursor-worker-review` for an independent pass.
- **Fable effort:** prefer Low–High; avoid X-High / Max / Ultra-style over-reasoning unless the user insists.
## cursor-agent mechanics (Grok 4.6 Low workers)
Claude Code subagent/workflow `model:` only accepts **Claude** models. To use **Grok 4.6 Low**, shell out to `cursor-agent` (Cursor subscription).
Prerequisite: `cursor-agent` on PATH.
```bash
WS="--workspace $(git rev-parse --show-toplevel) --model 'cursor-grok-4.6-low[fast=false]' --output-format json"
cursor-agent -p --mode ask $WS "Review prompt." # review / Q&A (read-only)
cursor-agent -p --force $WS "Implement prompt." # edits + shell
```
`--force` auto-approves tools (headless has no prompt); `--trust` alone only trusts the workspace. `--mode plan` for read-only investigation. Add `--worktree <slug>` for parallel isolated edits.
**Workflow wrappers:** a workflow stage must be a Claude model — use a thin **Sonnet (low effort)** agent that writes the `cursor-agent` prompt, runs it via Bash, returns structured output. Label stages `grok-low:task-name`.
**Timeouts:** long runs may exceed Bash limits — background + poll.
**Prompts:** self-contained (paths, scope, done criteria) — not Claude-style system messages.
assets/claude/skills/cursor-worker-implement/SKILL.md
---
name: cursor-worker-implement
description: >-
Runs bounded implementation via cursor-agent CLI with Grok 4.6 Low. Use when
Fable has a clear plan and bulk edits, migrations, or multi-file work should
not run on Fable tokens. Requires cursor-agent on PATH and Cursor subscription.
user-invocable: true
disable-model-invocation: true
---
# Cursor worker — implement
Parent (Fable) orchestrates; **Grok 4.6 Low** executes via `cursor-agent`. Do not prompt `cursor-agent` like Claude — use a **self-contained** brief (paths, scope, constraints, verification).
## Prerequisite
```bash
which cursor-agent # must exist; uses Cursor subscription auth
```
## Workflow
1. Confirm scope with the user if ambiguous.
2. Write a self-contained prompt (repo root, files, acceptance criteria).
3. Run from repo root:
```bash
REPO="$(git rev-parse --show-toplevel)"
cursor-agent -p --force --output-format json \
--workspace "$REPO" \
--model 'cursor-grok-4.6-low[fast=false]' \
"YOUR_SELF_CONTAINED_PROMPT"
```
4. Parse JSON stdout; summarize files changed, commands run, blockers.
5. If the parent needs proof, load `cursor-worker-review` or run project checks.
`--force` auto-approves edits/shell (headless has no prompt to answer); `--trust` alone only trusts the workspace. Add `--worktree <slug>` for parallel edits that must not collide. Default model `cursor-grok-4.6-low[fast=false]` (standard speed, not Fast).
## Timeouts
Long runs may exceed the parent shell timeout. For multi-hour work: run in background, log to a file, poll for completion.
## When parent should use this
- Clear-spec implementation, refactors, migrations, repetitive edits
- Parent should **not** bulk-edit when this skill is available
assets/claude/skills/cursor-worker-review/SKILL.md
---
name: cursor-worker-review
description: >-
Independent read-only review via cursor-agent CLI (Grok 4.6 Low, ask mode).
Use for skeptical validation of diffs, plans, or claimed completion before
Fable declares done. Requires cursor-agent on PATH.
user-invocable: true
disable-model-invocation: true
---
# Cursor worker — review
Skeptical **read-only** pass via `cursor-agent`. Parent must not trust claims without evidence.
## Prerequisite
```bash
which cursor-agent
```
## Workflow
1. Identify review target (uncommitted diff, branch, specific files, or plan doc).
2. Write a self-contained prompt: what to inspect, what “pass” means, output format.
3. Run from repo root:
```bash
REPO="$(git rev-parse --show-toplevel)"
cursor-agent -p --trust --mode ask --output-format json \
--workspace "$REPO" \
--model 'cursor-grok-4.6-low[fast=false]' \
"Review target: [describe]. Inspect git diff and relevant files. Output: Verified (with evidence), Issues (must-fix), Gaps (unverified), Verdict (ready/not ready). Do not edit files."
```
4. **Verify important claims** yourself (spot-check files, re-run checks) before presenting to the user.
5. If review finds nothing, say so clearly and state what was inspected.
`--mode ask` and `--mode plan` are both read-only (no `--force`); use `--mode plan` for investigation. Prompts are self-contained (paths, branch/SHA, scope, output sections) — simpler than Claude system framing.
## When parent should use this
- After implementation, before merge or “done”
- Second opinion on plans or large diffs
- Parent orchestrates; does not replace this with inline skimming
assets/cursor/implementer.md
---
name: implementer
description: >-
Implements code changes, refactors, and tests. Always use for multi-file
edits, feature work, installs, and shell commands that modify state. Runs on
cursor-grok-4.6-low[fast=false] (frontmatter pin). Parent must omit Task inline model.
model: cursor-grok-4.6-low[fast=false]
---
You are an implementation worker. The parent orchestrator has already planned the work — execute it.
When invoked:
1. Read only the files needed for the scoped task (not broad codebase exploration).
2. Make focused edits matching project conventions (`AGENTS.md`, `CLAUDE.md`, `.cursor/rules/`).
3. Run relevant checks or tests the task requires.
4. Report what changed, what you verified, and any blockers.
Constraints:
- Stay within the delegated scope. Do not expand scope without reporting back.
- Prefer existing patterns and helpers over new abstractions.
- If the repo has a project-specific local-stack / worktree / Docker skill, load it only when the delegated task needs that setup.
- For wrap-up with lint/type/test checks and commit, load the project's `finish-work` skill if installed.
Return a concise summary: files touched, verification run, and open questions.
assets/cursor/orchestrator-worker.md
---
description: >-
Orchestration mode: plan and delegate only. Workers on
cursor-grok-4.6-low[fast=false]. Orchestrator Grok 4.6 High standard (not Fast).
alwaysApply: false
---
# Orchestrator / worker split
You are the **orchestrator**. Plan, decide, and delegate. Do not implement.
The user's message is the **task**. Workers run on **`cursor-grok-4.6-low[fast=false]`** via `.cursor/agents/` pins — not on your model.
## Model pins (critical)
| Role | Model | Source |
| --------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------- |
| You (orchestrator) | Session picker: **Grok 4.6 High**, standard / not Fast (`cursor-grok-4.6-high[fast=false]`) | User-selected |
| `/implementer`, `/verifier` | `cursor-grok-4.6-low[fast=false]` | `.cursor/agents/*.md` frontmatter |
When spawning subagents via Task (`implementer`, `verifier`, `explore`, or others):
- **Omit `model`** — never pass `inherit`, Composer slugs, Fast (`*-fast`, `fast=true`), `cursor-grok-4.6-high`, or any inline model.
- For `/implementer` and `/verifier`, omitting `model` lets frontmatter `cursor-grok-4.6-low[fast=false]` apply.
- Built-in `explore` ignores `.cursor/agents/` pins (its own default); still omit inline `model`.
- Use `subagent_type: implementer` or `verifier`, not `generalPurpose` with an inline model.
## Orchestrator must not
- Bulk-read or explore the codebase widely — delegate to built-in `explore`
- Edit files or run state-changing commands — delegate to `/implementer`
- Trust "done" without proof — delegate to `/verifier` before finishing
- Pass `model` on Task calls (including `explore`)
Exceptions: trivial fixes under ~10 lines total, or the user says "no subagents".
## Delegation
| Task | Delegate to |
| ----------------------------------------------------------- | --------------------------------------- |
| Codebase search, file discovery | Built-in `explore` |
| Edits, multi-file work, tests, installs, state-changing git | `/implementer` |
| Read-only diagnostics (logs, status, non-mutating commands) | Built-in `bash` |
| Post-change validation, skeptical review | `/verifier` (readonly) |
| Browser / UI debugging | Built-in `browser` or agent-browser MCP |
Prefer `/implementer` over `bash` whenever edits or environment changes are possible.
## Invocation
- `/implementer [scoped brief]`, `/verifier [what to prove]`
- Task: `subagent_type: implementer` or `verifier`, **no `model` field**
- Parallel Task calls in one message when subtasks are independent
- Each brief must be self-contained (paths, scope, constraints, verification steps)
## Workflow
1. Break work into independent subtasks.
2. Delegate cohesive implementation to **one** `/implementer` — do not split merely by file.
3. Parallelize only when subtasks are genuinely independent.
4. Synthesize results; decide next steps.
5. Before finishing, run `/verifier` unless the change is trivial.
## Pins to keep
- Do **not** use `model: inherit` on workers — that bills at your orchestrator (High) rate.
- Keep the frontmatter pin `cursor-grok-4.6-low[fast=false]`.
- Stay on **standard speed** for High and Low — Fast is the Grok 4.6 default on Pro+; do not enable it.
assets/cursor/verifier.md
---
name: verifier
description: >-
Skeptically validates completed work. Always use before declaring a task done.
Runs relevant checks, inspects diffs, and reports what actually passed vs what
was only claimed. Runs on cursor-grok-4.6-low[fast=false] (frontmatter pin).
Parent must omit Task inline model.
model: cursor-grok-4.6-low[fast=false]
readonly: true
---
You are a verification worker. Do not trust claims — prove them.
When invoked:
1. Inspect the actual diff or changed files (git diff, targeted reads).
2. Run the checks that matter for this change (e.g. `bun run check`, or the project's standard verify command).
3. Look for gaps: missing tests, edge cases, convention violations, incomplete wiring.
4. Report findings with evidence (command output, file paths, line references).
Output format:
- **Verified** — what you ran and what passed
- **Issues** — must-fix problems with evidence
- **Gaps** — untested or unverified areas
- **Verdict** — ready / not ready, with one-line rationale
Be skeptical. If checks were not run, say so. If something looks correct but was not executed, flag it.
references/claude-code.md
# Agent orchestration — Claude Code
**Fable 5** orchestrates in Claude Code (desktop or CLI). **Grok 4.6 Low** runs bulk work via **`cursor-agent` CLI** (Cursor subscription). Claude Code cannot pin Grok on subagent `model:` — shell out instead.
---
## What goes where
| Piece | Location | How it gets there |
| --------------------- | --------------------------------- | ------------------------------------------------------- |
| Procedure + templates | fixmyskills `agent-orchestration` | Skills CLI → `.agents/skills/` |
| Worker skills | `.claude/skills/cursor-worker-*` | `init-claude.sh` |
| Orchestration rules | `CLAUDE.md` | Merge `docs/claude-orchestration-snippet.md` after init |
| Parent model | Claude Code model picker | You pick Fable 5 each session |
| Worker execution | `cursor-agent` on PATH | Cursor subscription auth |
```mermaid
flowchart LR
Fable["Fable 5"]
CMd["CLAUDE.md"]
Skills["cursor-worker-* skills"]
CLI["cursor-agent cursor-grok-4.6-low[fast=false]"]
Fable --> CMd --> Skills --> CLI
```
---
## Bootstrap (one-time per repo)
```bash
bunx skills add FixMyBerlin/fixmyskills --skill agent-orchestration -a cursor -y
bash .agents/skills/agent-orchestration/scripts/init-claude.sh
# Merge docs/claude-orchestration-snippet.md into CLAUDE.md
git add .claude/skills docs/claude-orchestration-snippet.md skills-lock.json CLAUDE.md
git commit -m "Add Claude Code Fable orchestration setup"
```
`--no-docs` skips copying the snippet file. `TARGET_REPO=/path` overrides destination.
Reset templates: re-run `init-claude.sh` (overwrites copied skills and snippet).
---
## Prerequisites
```bash
which cursor-agent
cursor-agent --list-models # must list cursor-grok-4.6-low (use [fast=false])
```
Auth uses your **Cursor** subscription — not a separate OpenAI/Codex stack.
---
## Daily usage
Pick **Fable 5** (effort Low–High), then:
```
Orchestrate only. cursor-worker-implement for edits, cursor-worker-review before done.
Do not bulk-edit inline unless trivial (<10 lines).
```
Delegation: bulk edits → `cursor-worker-implement`; review → `cursor-worker-review`; discovery → Claude subagents or `cursor-agent --mode plan`; user-facing design → Fable/Opus.
`cursor-agent` command syntax, the workflow wrapper pattern, and the model table live in the copied `CLAUDE.md` snippet and the `cursor-worker-*` skills — not duplicated here.
---
## Cost traps
- Bulk edits on Fable when `cursor-agent` was available.
- Passing Composer, Grok High, or Fast (`*-fast`) to `cursor-agent` unless intentional.
- Parallel `cursor-agent` runs = parallel Cursor usage.
- Wrapper stages still cost Claude tokens — keep wrapper on Sonnet low.
---
## Customize & verify
- Edit `.claude/skills/cursor-worker-*` after init (project check commands, etc.); global copies go in `~/.claude/skills/` (project wins on name).
- Verify: `which cursor-agent`; Claude Code lists both `cursor-worker-*` skills; Fable delegates to Bash `cursor-agent` instead of editing inline.
references/cursor-ide.md
# Agent orchestration — Cursor IDE
**Grok 4.6 High** standard / not Fast (default orchestrator) plans in Cursor Agent chat. **`cursor-grok-4.6-low[fast=false]`** workers run as subagents with explicit `model:` pins in `.cursor/agents/`. Other orchestrators (Fable 5, Sonnet 5, GPT-5.6 Sol) work the same way. Both Grok variants stay on **standard speed** — Fast is the Grok 4.6 default on Pro+ and must be turned off.
---
## What goes where
| Piece | Location | How it gets there |
| --------------------- | ---------------------------------------------- | ---------------------------------------------------------------------- |
| Procedure + templates | fixmyskills `agent-orchestration` | Skills CLI → `.agents/skills/` |
| Worker model pins | `.cursor/agents/implementer.md`, `verifier.md` | `init-cursor.sh` |
| Orchestrator behavior | `.cursor/rules/orchestrator-worker.md` | `init-cursor.sh` |
| Parent model | Cursor Agent model picker | You pick an orchestrator each session |
| Personal workers | `~/.cursor/agents/` | Manual copy — see [cursor-personal-setup.md](cursor-personal-setup.md) |
```mermaid
flowchart LR
Orch["Orchestrator\nGrok 4.6 High[fast=false]"]
Rule["@orchestrator-worker"]
Workers[".cursor/agents\ncursor-grok-4.6-low[fast=false]"]
Orch --> Rule --> Workers
```
Skills CLI does **not** install `.cursor/agents/` — run `init-cursor.sh` after `bunx skills add`.
---
## Bootstrap (one-time per repo)
```bash
bunx skills add FixMyBerlin/fixmyskills --skill agent-orchestration -a cursor -y
bash .agents/skills/agent-orchestration/scripts/init-cursor.sh
git add .cursor/agents .cursor/rules skills-lock.json
git commit -m "Add Cursor agent orchestration setup"
```
`TARGET_REPO=/path` overrides destination.
Reset templates: re-run `init-cursor.sh` (overwrites).
---
## Picking an orchestrator
| Model | Good for |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Grok 4.6 High** ⭐ | **Default.** Smart work: long-running, multi-step orchestration. Frontier intelligence in the Fable/Opus class. Cursor Models pool. Use **standard speed** (`cursor-grok-4.6-high[fast=false]`), not Fast. |
| **Fable 5** | Complex, long-running, multi-step agentic work; third-party pool |
| **Sonnet 5** | Everyday coding with strong multi-step reasoning and reliable tool use |
| **GPT-5.6 Sol** | Long-running agent work; can over-delegate on mid-sized tasks — keep one `/implementer` per cohesive task |
Workers stay on **`cursor-grok-4.6-low[fast=false]`** regardless of orchestrator choice. Low effort at standard speed is Composer-priced grunt work with stronger results than Composer 2.5.
---
## Daily usage
1. Pick **Grok 4.6 High** as orchestrator, **standard / not Fast** (or Fable 5 / Sonnet 5 / GPT-5.6 Sol).
2. Attach **`@orchestrator-worker`** and state your task — nothing else required:
```
@orchestrator-worker
Fix the parking map zoom bug.
```
The rule is the complete orchestration instruction. Do **not** paste delegation boilerplate ("orchestrate only", "omit Task model", etc.) — those live in `.cursor/rules/orchestrator-worker.md`.
Workers use **`cursor-grok-4.6-low[fast=false]`** automatically via `.cursor/agents/` frontmatter.
**Skip** `@orchestrator-worker` for trivial one-file edits — subagent startup costs more than inline work.
---
## Delegation
| Task | Delegate to |
| ------------------------------------------ | ------------------------------ |
| Codebase search | Built-in `explore` |
| Edits, tests, installs, state-changing git | `/implementer` |
| Read-only diagnostics (logs, status) | Built-in `bash` |
| Post-change validation | `/verifier` (readonly) |
| Browser / UI | `browser` or agent-browser MCP |
Invocation: `/implementer [scoped brief]`, `/verifier [what to prove]`. For parallel work, send multiple subagent Task calls in one message.
Orchestrator may inline only trivial fixes (~10 lines) or when user says "no subagents".
---
## Worker model pins
`.cursor/agents/` frontmatter: `model: cursor-grok-4.6-low[fast=false]`. Verifier adds `readonly: true`. **Avoid** `inherit` on workers — bills at your orchestrator's High rate. **Avoid Fast** — Grok 4.6 Fast is the Pro+ default.
### Task tool vs frontmatter
Passing any inline `model` on `/implementer` or `/verifier` **overrides** the frontmatter pin. Task's allowed list includes Fast and High slugs — an inline override can silently enable Fast or upgrade cost.
**Fix:** when spawning custom workers, use `subagent_type: implementer` or `verifier` and **omit `model` entirely**. The frontmatter pin then applies `cursor-grok-4.6-low[fast=false]`.
| Spawn style | `model` on Task call | Result |
| -------------------------------------------- | -------------------- | ------------------------------------ |
| `/implementer`, no inline model | omitted | `cursor-grok-4.6-low[fast=false]` ✅ |
| Task + `model: inherit` | set | orchestrator High rate ❌ |
| Task + `model: cursor-grok-4.6-low` (no pin) | set | may default to Fast ❌ |
| Task + `model: composer-2.5-fast` | set | Composer fast ❌ |
| `generalPurpose` + inline model | set | bypasses worker pin ❌ |
Built-in `explore` is for search only and does **not** read `.cursor/agents/` frontmatter — it uses Cursor's own default. Still **omit** Task inline `model` for explore. For `/implementer` and `/verifier`, omit `model` so the frontmatter pin `cursor-grok-4.6-low[fast=false]` applies.
Parallel subagents = parallel token spend. Cursor may fall back from a pinned worker model when blocked by admin, unavailable Max Mode, or plan limits.
---
## Customize & verify
- Edit copied files in the target repo (`verifier.md` check commands, rule delegation for MCP, etc.). Do **not** put orchestration in global Cursor User Rules — attach `@orchestrator-worker` per task (rule only; no boilerplate in the prompt).
- Optional one-liner in `AGENTS.md`: point at `.cursor/rules/orchestrator-worker.md` (`@orchestrator-worker`) — not this long guide.
- Verify: `@orchestrator-worker` in rule picker; attaching it alone switches parent to orchestrate-only; `/implementer` and `/verifier` show `cursor-grok-4.6-low[fast=false]` in frontmatter; parent is Grok 4.6 High **not Fast**; parent spawns workers **without** Task inline `model`.
---
## References
- [Cursor Subagents](https://cursor.com/docs/subagents)
- [Grok 4.6](https://cursor.com/docs/models/grok-4-6)
- [Claude Fable 5](https://cursor.com/docs/models/claude-fable-5)
- [Claude Sonnet 5](https://cursor.com/docs/models/claude-sonnet-5)
- [GPT-5.6 Sol](https://cursor.com/docs/models/gpt-5-6-sol)
- Prototype: tilda-geo commit `9572b85`
references/cursor-personal-setup.md
# Personal setup (`~/.cursor/agents/`)
Cursor IDE only. For Claude Code, use project `.claude/skills/` or `~/.claude/skills/`.
Use personal subagents when you want the same **implementer** and **verifier** workers across all projects without copying into each repo.
## Copy workers only
```bash
mkdir -p ~/.cursor/agents
cp .agents/skills/agent-orchestration/assets/cursor/implementer.md ~/.cursor/agents/
cp .agents/skills/agent-orchestration/assets/cursor/verifier.md ~/.cursor/agents/
```
From fixmyskills dev checkout:
```bash
cp skills/agent-orchestration/assets/cursor/implementer.md ~/.cursor/agents/
cp skills/agent-orchestration/assets/cursor/verifier.md ~/.cursor/agents/
```
## Precedence
| Path | Scope |
| --------------------------------------- | -------------------- |
| `.cursor/agents/implementer.md` in repo | Wins over user-level |
| `~/.cursor/agents/implementer.md` | All projects |
Prefer **project-local** agents for team repos.
## What personal workers do not replace
Workers pin Grok 4.6 Low globally, but orchestration behavior still comes from the project rule — run init once per repo:
```bash
bash .agents/skills/agent-orchestration/scripts/init-cursor.sh
```
Then attach **`@orchestrator-worker`** plus your task. No delegation boilerplate to paste.
Do **not** put orchestration in global Cursor User Rules (`alwaysApply`).
scripts/common.sh
#!/usr/bin/env bash
# Shared helpers for init-cursor.sh and init-claude.sh
set -euo pipefail
agent_orchestration_skill_dir() {
local script_dir
script_dir="$(cd "$(dirname "${BASH_SOURCE[1]}")" && pwd)"
cd "$script_dir/.." && pwd
}
agent_orchestration_repo_root() {
local skill_dir="$1"
local dir="$skill_dir"
while [[ "$dir" != "/" ]]; do
if [[ -d "$dir/.git" ]] || [[ -f "$dir/skills-lock.json" ]]; then
echo "$dir"
return 0
fi
dir="$(cd "$dir/.." && pwd)"
done
echo "$(cd "$skill_dir/../.." && pwd)"
}
scripts/init-claude.sh
#!/usr/bin/env bash
# Bootstrap Claude Code orchestration (.claude/skills + CLAUDE.md snippet).
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck source=common.sh
source "$SCRIPT_DIR/common.sh"
SKILL_DIR="$(agent_orchestration_skill_dir)"
REPO_ROOT="$(cd "${TARGET_REPO:-$(agent_orchestration_repo_root "$SKILL_DIR")}" && pwd)"
ASSETS="$SKILL_DIR/assets/claude"
SKIP_DOCS=false
for arg in "$@"; do
case "$arg" in
--no-docs) SKIP_DOCS=true ;;
-h | --help)
echo "Usage: bash scripts/init-claude.sh [--no-docs]"
echo "Copies Claude Code skills into .claude/skills/ (and docs/claude-orchestration-snippet.md)."
echo "Set TARGET_REPO=/path/to/repo to override destination."
exit 0
;;
esac
done
mkdir -p "$REPO_ROOT/.claude/skills/cursor-worker-implement" \
"$REPO_ROOT/.claude/skills/cursor-worker-review"
cp "$ASSETS/skills/cursor-worker-implement/SKILL.md" \
"$REPO_ROOT/.claude/skills/cursor-worker-implement/SKILL.md"
cp "$ASSETS/skills/cursor-worker-review/SKILL.md" \
"$REPO_ROOT/.claude/skills/cursor-worker-review/SKILL.md"
SNIPPET="$REPO_ROOT/docs/claude-orchestration-snippet.md"
if [[ "$SKIP_DOCS" == false ]]; then
mkdir -p "$(dirname "$SNIPPET")"
cp "$ASSETS/claude-md-orchestration.md" "$SNIPPET"
fi
echo "Claude Code orchestration setup complete in: $REPO_ROOT"
echo " $REPO_ROOT/.claude/skills/cursor-worker-implement/SKILL.md"
echo " $REPO_ROOT/.claude/skills/cursor-worker-review/SKILL.md"
[[ "$SKIP_DOCS" == false ]] && echo " $SNIPPET"
echo ""
echo "Next: merge docs/claude-orchestration-snippet.md into CLAUDE.md; ensure cursor-agent on PATH"
scripts/init-cursor.sh
#!/usr/bin/env bash
# Bootstrap Cursor IDE orchestration (.cursor/agents + rule).
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck source=common.sh
source "$SCRIPT_DIR/common.sh"
SKILL_DIR="$(agent_orchestration_skill_dir)"
REPO_ROOT="$(cd "${TARGET_REPO:-$(agent_orchestration_repo_root "$SKILL_DIR")}" && pwd)"
ASSETS="$SKILL_DIR/assets/cursor"
for arg in "$@"; do
case "$arg" in
-h | --help)
echo "Usage: bash scripts/init-cursor.sh"
echo "Copies Cursor IDE templates into .cursor/agents/ and .cursor/rules/."
echo "Set TARGET_REPO=/path/to/repo to override destination."
exit 0
;;
esac
done
mkdir -p "$REPO_ROOT/.cursor/agents" "$REPO_ROOT/.cursor/rules"
cp "$ASSETS/implementer.md" "$REPO_ROOT/.cursor/agents/implementer.md"
cp "$ASSETS/verifier.md" "$REPO_ROOT/.cursor/agents/verifier.md"
cp "$ASSETS/orchestrator-worker.md" "$REPO_ROOT/.cursor/rules/orchestrator-worker.md"
echo "Cursor IDE orchestration setup complete in: $REPO_ROOT"
echo " $REPO_ROOT/.cursor/agents/implementer.md"
echo " $REPO_ROOT/.cursor/agents/verifier.md"
echo " $REPO_ROOT/.cursor/rules/orchestrator-worker.md"
echo ""
echo "Next: commit .cursor/; pick Grok 4.6 High (standard, not Fast); attach @orchestrator-worker + your task"
SKILL.md
---
name: agent-orchestration
description: >-
Orchestrator (default Grok 4.6 High, standard speed) with
cursor-grok-4.6-low[fast=false] workers. Two separate setups: Cursor IDE
(subagents in .cursor/agents) or Claude Code (cursor-agent CLI + .claude/skills).
Use when configuring orchestration; pick the guide for your host.
user-invocable: true
disable-model-invocation: true
---
# Agent orchestration
**Goal:** **Grok 4.6 High** standard / not Fast (default orchestrator) plans; **`cursor-grok-4.6-low[fast=false]`** executes bulk work at Composer-like cost with better quality.
Install once, then run **only** the init for your host from `.agents/skills/agent-orchestration/`:
```bash
bunx skills add FixMyBerlin/fixmyskills --skill agent-orchestration -a cursor -y
```
| Host | Mechanism | Files | Bootstrap | Guide |
| --------------- | -------------------------------------------------- | ------------------------------------------------------ | ---------------- | ------------------------------------------- |
| **Cursor IDE** | subagents (`model:` pins) + `@orchestrator-worker` | `.cursor/agents/`, `.cursor/rules/` | `init-cursor.sh` | [cursor-ide.md](references/cursor-ide.md) |
| **Claude Code** | `cursor-agent` CLI (`cursor-agent` on PATH) | `.claude/skills/cursor-worker-*` + `CLAUDE.md` snippet | `init-claude.sh` | [claude-code.md](references/claude-code.md) |
Do not mix both inits unless you use both tools on the same repo. Cursor personal workers: [cursor-personal-setup.md](references/cursor-personal-setup.md).