hive-drive

/hive-drive — Autonomous Swarm Coordinator

Drive a swarm from start to finish autonomously. This skill enters a wave-based loop: pollinate, spawn bees as background Task agents, monitor via TaskOutput, re-pollinate, and repeat until the swarm completes or fails.

Arguments: $ARGUMENTS

Modes

Mode 1: Start and drive a new swarm

Pattern: /hive-drive <blueprint_id> <task...>

Example: /hive-drive feature-dev Add user authentication system

1. Call mcp__hive__hive_swarm_start with the blueprint_id and task.
2. Enter the Wave Loop with the returned swarm_id.

Mode 2: Drive an existing swarm

Pattern: /hive-drive <number>

Example: /hive-drive 3

1. Call mcp__hive__hive_swarm_summary with the swarm_id resolved from the number.
2. Verify the swarm is buzzing. If not, report the status and exit.
3. Enter the Wave Loop with the swarm_id.

Mode 3: No arguments

Pattern: /hive-drive

1. Call mcp__hive__hive_swarm_list with status=buzzing.
2. If buzzing swarms exist, show them and ask the user which to drive.
3. If no buzzing swarms, show available blueprints and offer to start one.

---

Wave Loop

The core execution loop. Repeat until the swarm completes, fails, or safety limits are hit.

Variables

• wave — Counter starting at 1 (max 50)
• empty_polls — Counter of consecutive empty pollinates (max 3)
• last_epoch — Last seen epoch value (start at -1)
• swarm_id — The swarm being driven

Each Wave

Step 1: Check epoch (skip if first wave)

• Call mcp__hive__hive_check_epoch.
• If epoch equals last_epoch, sleep 5 seconds and re-check (up to 3 times).
• Update last_epoch.

Step 2: Pollinate

• Call mcp__hive__hive_pollinate with the swarm_id.
• If zero spawns returned, increment empty_polls.
• If spawns returned, reset empty_polls to 0.

Step 3: Spawn bees

• For each SpawnRequest in the pollinate result:
  • Use the Task tool to spawn a background agent:
    • subagent_type: "general-purpose"
    • run_in_background: true
    • prompt: The SpawnRequest's prompt field
    • model: The SpawnRequest's model field
    • max_turns: The SpawnRequest's maxTurns field
  • Report: "Dispatched bee {beeId}: {flightDescription}"

Step 4: Monitor background tasks

• Wait for all spawned tasks to complete using TaskOutput with block=true.
• Report completion of each bee.

Step 5: Check swarm status

• Call mcp__hive__hive_swarm_summary with the swarm_id.
• Report progress: flight pipeline position, cell completion ratio.
• If swarm status is completed: call mcp__hive__hive_swarm_analytics and report success with timing summary. Exit loop.
• If swarm status is failed: report failure and exit loop.
• If swarm status is cancelled: report and exit loop.
• If swarm status is blocked: Check for gated flights. Show the gated flight details and ask the user: "Approve this flight to continue? (flight: {flight_id}, gate: approval)". If the user approves, call mcp__hive__hive_gate_approve with the flight_id. Resume the loop.

Step 6: Safety checks

• If wave >= 50: report max waves reached, suggest /hive-drive {number} to continue. Exit loop.
• If empty_polls >= 3: call mcp__hive__hive_beekeeper_check. If beekeeper finds issues, reset empty_polls to 0. If no issues found, report possible stall and exit loop.

Step 7: Next wave

• Increment wave.
• Go to Step 1.

---

Output Format

Report progress after each wave:

Wave {N} — Swarm #{number}
  Dispatched: {count} bee(s)
  Pipeline: {done}/{total} flights done
  Cells: {done}/{total} done
  Status: {status}

On completion:

Swarm #{number} completed successfully!
  Task: {task}
  Waves: {count}
  Flights: {total} completed
  Cells: {done}/{total} done
  Total time: {duration}s
  Bottleneck: {flight_id} ({duration}s)
  Parallelism: {ratio}x

On failure:

Swarm #{number} failed.
  Task: {task}
  Waves: {count}
  Use `/hive resume {number}` to retry failed flights.

---

Important Rules

• This skill DRIVES swarms autonomously. It spawns bee subagents and waits for them.
• Do NOT write code, edit files, or run bash commands yourself. Bees do the work.
• Do NOT call hive_flight_claim, hive_flight_complete, or hive_flight_fail directly. Bees call these.
• Always spawn bees as background Task agents so they run in parallel.
• Use hive_check_epoch to avoid expensive polls when nothing has changed.
• If a bee task returns an error, the flight will be marked failed by the bee. Continue the loop.
• Maximum 50 waves per invocation. The user can re-run /hive-drive {number} to continue.