| name | execute-fleet |
| description | Phase execution skill for licensed Atlas Fleet runs. Use when HANDOFF has selected Atlas Fleet and the project should be executed across isolated launcher worktrees with inbox-based result collection, verified CDD cards, sequential integration merges, and one final PR. |
| user-invocable | false |
| allowed-tools | ["Read","Bash","Skill","ToolSearch","mcp__atlas-engine","mcp__plugin_prd_go","mcp__plugin_prd-taskmaster_go","mcp__plugin_atlas-go_go"] |
execute-fleet
Atlas Fleet is the premium parallel sibling of execute-task. It keeps the
same proof discipline, but the orchestrator owns the scoreboard while workers
only build inside isolated worktrees.
Hard Gates
Before the first wave, all gates must pass. If any gate fails, report the gap
and stop; do not fall back to solo execution from inside this skill.
mcp__plugin_prd_go__detect_capabilities() reports
tier: "premium" and atlas-launcher MCP registration/aliveness.mcp__atlas-launcher__inbox_read is callable for this session..taskmaster/tasks/tasks.json exists..taskmaster/reports/task-complexity-report.json exists.git status --short is empty. Fleet starts only from a committed base.- The integration branch policy is clear: use
fleet-integration; main is never auto-touched.
SOLE-WRITER RULE: only this orchestrator writes
.taskmaster/tasks/tasks.json and .atlas-ai/state/pipeline.json. Workers
must never edit those files. The orchestrator may update task state only
through TaskMaster or the plugin pipeline MCP, and only after verification.
Wave Loop
Repeat until no runnable tasks remain:
- Call
mcp__plugin_prd_go__compute_fleet_waves(concurrency=<N>, tag=<tag>).
Use the returned frontier as the only dispatch source. If it reports a
deadlock, render status, mark the blocked set, and stop dispatching those
tasks.
- For each chunk in the current wave, spawn exactly one worker:
mcp__atlas-launcher__session_spawn(isolation="worktree", report_to=<this session>, model=<routing[task_id] model part>, prompt=<worker prompt>).
Model is NEVER left default: compute_fleet_waves returns a routing
map (task id -> backend:model) from the capability ladder — Fable for the
hardest/longest-running (frontier tier), down the cost-efficiency curve to
haiku for trivial tasks. Pass the model part explicitly; non-claude backends
require experimental_backends=true and the launcher backend param.
The prompt must include the full task JSON inline; never tell workers to
read shared tasks.json.
- Inspect the spawn result. If
prompt_injected is false, re-kick once with
mcp__atlas-launcher__session_send using the same worker prompt, then
confirm injection/readiness. If it is still false, treat that worker as
failed and apply the retry policy below.
- Render the fleet status view after the wave starts and after each wave
transition.
- Poll
mcp__atlas-launcher__inbox_read for terminal worker messages. The
only accepted terminal status vocabulary is DONE, DONE_WITH_CONCERNS,
NEEDS_CONTEXT, or BLOCKED; any other terminal word is a protocol
failure and counts as a worker failure.
- On a completion message, verify the branch, never the narration:
- The worker branch contains
.atlas-ai/cdd/task-<id>.json.
- No
.atlas-ai/evidence/ file in that branch contains a non-zero
Exit status N line.
- The branch changed only its own worktree scope and did not edit
.taskmaster/tasks/tasks.json or .atlas-ai/state/pipeline.json.
- Never mark a task done without the CDD card. Missing card means the worker
did not satisfy the contract, regardless of any
DONE message.
- Merge verified worker branches into
fleet-integration sequentially, one
at a time. After each merge, run the checker/build gate expected for the
project before merging the next branch.
- Mark the task done only after the merge gate passes:
python3 script.py set-status --id <id> --status done.
Worker Prompt Template
Embed this template verbatim for each worker, replacing placeholders before
dispatch:
WORKER_CONTRACT_ORCHESTRATOR_REPORT_TO
You are an Atlas Fleet worker. Your orchestrator is <ORCHESTRATOR_ID>. Report every question, blocker, and terminal result to <REPORT_TO_SESSION>.
WORKER_CONTRACT_FULL_TASK_JSON_INLINE
Your assigned task JSON is inline below. Treat this as the source of truth. Do not read shared .taskmaster/tasks/tasks.json.
<FULL_TASK_JSON>
WORKER_CONTRACT_WORKTREE_BRANCH
Work only in this isolated worktree and branch:
worktree: <WORKTREE_PATH>
branch: <WORKER_BRANCH>
WORKER_CONTRACT_CDD_CARD
Before reporting any terminal status, write this CDD card in your worktree: .atlas-ai/cdd/task-<id>.json. The card must list the checks you ran and the evidence paths that prove them. Evidence files under .atlas-ai/evidence/ must contain the FINAL verification run ONLY (one green run, one exit-status line) — intermediate TDD red runs go to .atlas-ai/logs/, never evidence/ (ship-check Gate 5 reads every Exit status line in evidence/ as final-state proof).
WORKER_CONTRACT_TERMINAL_STATUS
End with exactly one terminal status: DONE | DONE_WITH_CONCERNS | NEEDS_CONTEXT | BLOCKED.
Report it via mcp__atlas-launcher__inbox_send(target_session=<REPORT_TO_SESSION>, message_type="task_handoff", payload=<JSON string with at least {"task_id": <id>, "status": "<terminal status>", "branch": "<worktree branch>", "cdd_card": ".atlas-ai/cdd/task-<id>.json"}>, sender_session=<your session name>). The launcher message_type allowlist is task_handoff | notification | data | request | heartbeat — terminal reports use task_handoff; the status lives INSIDE the payload JSON.
WORKER_CONTRACT_HARD_RULES
Hard rules: never edit .taskmaster/tasks/tasks.json or .atlas-ai/state/pipeline.json; never git push; commit only in your own worktree branch.
WORKER_CONTRACT_QUESTIONS_INBOX
Ask questions before building if context is missing: use mcp__atlas-launcher__inbox_send(target_session=<REPORT_TO_SESSION>, message_type="request", payload=<your question as a string>, sender_session=<your session name>). ("question"/"completion"/"blocker" are template intents, not runtime message types — see docs/INTEGRATION-prd-taskmaster.md in the atlas-launcher repo, contract v1.)
Failure Paths
- Silent/dead worker: if there is no inbox message and the session is gone,
re-queue the task ONCE with a fresh worker prompt. On the second failure,
mark the task
BLOCKED in the orchestrator scoreboard and continue with
remaining tasks.
NEEDS_CONTEXT: answer through mcp__atlas-launcher__inbox_send, then let
the same worker continue. If it cannot continue, count it under the same
retry cap.- Worker
BLOCKED: record the blocker, mark the task BLOCKED, and continue
with independent tasks.
- Merge conflict: do not force. Do not resolve by guessing. Create a fix task
that captures the conflict and continue with remaining non-conflicting work.
- Evidence failure: do not merge, do not mark done, and do not rewrite the
worker's CDD card on their behalf.
Status Rendering
After every wave transition, render the terminal status view with the UX-SPEC
grammar. Use model plus index names such as claude-1, codex-1, and
claude-2. Keep the gate line in plain English every time.
┌─ atlas fleet ── wave 2 of 3 ──────────────── ▶ running 12m ┐
│ wave 1 ✓ merged 3 tasks · 18m · integration green │
│ wave 2 ▶ running │
│ claude-1 task 6 API endpoints ▰▰▰▱ 3/4 │
│ codex-1 task 7 UI components ▰▰▱▱ 2/4 │
│ claude-2 task 9 DB migrations ✓ done — waiting │
│ wave 3 ○ queued 4 tasks · starts when wave 2 merges │
│ │
│ Gate: a wave merges only after the checker approves it │
│ and the integration branch builds green. │
│ │
│ watch: atlas fleet status logs: .atlas-ai/fleet/ │
└────────────────────────────────────────────────────────────┘
Termination
When all waves are done, or all remaining tasks are BLOCKED, switch to
fleet-integration and run:
python3 skel/ship-check.py
If it exits non-zero, report the failing gate and stop. If it exits 0, emit
SHIP_CHECK_OK exactly once, then open one final PR from fleet-integration.
Do not print the token anywhere else. Do not merge the PR yourself.
Non-Exits
This skill never kills the shell and never pushes. Halt conditions are reported
to the caller and, when relevant, to the launcher inbox.
