manta-cast-decide

manta-cast-decide

Purpose

You're the main agent (the user's Claude Code orchestrator). A task arrived. Before you manta cast, run this skill: every cast eats into your Claude Code subscription's usage/rate limit and costs your own context. Claude Code is a subscription (Pro/Max), not pay-per-token — the constraint is never dollars, and there are no charges or cooldowns; it's how much of your subscription's usage you spend and how many clones you run in parallel (the one hard cap, --max-parallel-clones). Many "feels parallel" tasks are actually serial and a single agent does them faster with less usage.

This skill does two jobs: (1) decide whether to cast, and (2) pick which mode. Use it reactively (before a cast) and proactively — when you spot a task shape below mid-conversation, suggest the mode to the user ("this looks like a refactor-wave across ~12 files — want me to cast it?").

Allowed

Run this three-step gate. It's a solo decision — never a cast itself.

Step 1 — Should this be a cast at all?

Cast only if at least one is true:

• The task reads/touches > 5 files across different layers of the repo.
• There are ≥ 2 unobvious approaches worth building in parallel and comparing.
• It's a same-pattern change repeated across N places.
• It's a multi-layer bug with an unknown root cause.
• It's a > 10-minute implementation with a clear, self-contained contract.

Do it solo (skip the cast) if: the task is < 10 minutes, surgical, already in your context, or you can't articulate why parallel beats serial. Big ≠ parallelizable.

Step 2 — Which mode? (all 9 ship today)

Pick the mode whose shape matches the task. Each maps to a clone-side skill the clone auto-loads.

Mode	Cast when…	Clones	Output shape
recon-swarm	mapping / discovery / "where does X live" across many files	2–5, each takes a subtree	read-only findings → ZK notes, PARA facts, a map doc
bug-hunt	a bug (or a well-scoped implementation task) with a clear contract	1–N	a fix/feature on a branch, committed
refactor-wave	same mechanical change across N disjoint locations	2–5, partitioned	each clone owns a partition; no overlap, merges clean
forking-realities	≥ 2 architectural alternatives — you want to compare, not guess	2–N competing	rival branches + docs/merge-reviews/cast-<id>.md; you pick the winner, no auto-merge
pair-programming	one risky/subtle change worth a tight writer↔reviewer loop	2 (writer + reviewer)	reviewed change on a branch
test-storm	build a feature and its test wall together	3 (coder + tester + fuzzer)	implementation + unit + property/boundary tests
documentation-chase	turn existing code into docs	1–N, each a doc area	markdown in docs/ only, no source edits
council 🔒	a hard judgment call — want N independent opinions (wisdom of crowds)	3–5 independent proposers	N reasoned proposals; you aggregate by hand, no auto-merge
decoy 🔒	you want a draft to react to, not a finished artifact	≤ 2	a DRAFT deliverable you review/edit/finalize

🔒 council and decoy are Aghs-locked (higher-power modes). A cast is rejected unless the operator opted in: .manta/config/budget.json → aghs.unlocked: ["council","decoy"], or the MANTA_UNLOCK_AGHS env var. If you want one and it's locked, tell the user how to unlock — don't retry blindly.

phantom-lance (recursive self-cast) does NOT ship — manta cast phantom-lance is rejected as "not supported". Don't suggest it.

Step 3 — Usage self-check (before you spawn)

The real question is "am I within my subscription's usage?", never "can I afford the dollars?" (there are none — no charges, no cooldown, no dollar budget). Check:

• Parallelism: how many clones at once? --max-parallel-clones (default 5) caps how many clones of a single cast spawn at once. More parallel clones drain your subscription's rate limit faster and load your machine harder — spawn the fewest that actually parallelize. Exhausting your Claude Code usage limit blocks you for hours.
• The global clone budget is 5 letters (A–E), shared across ALL running casts. Concurrent casts are SAFE — they get disjoint letters + cast-scoped worktrees, no collision — but the SUM of live clones across everything must stay ≤ 5 (e.g. a recon-swarm ×2 + a bug-hunt ×1 = 3 is fine; three ×3 casts is not — the 9th–6th are rejected with concurrent_cast_limit_reached). You don't have to serialize, but you do have to fit the budget. Serial is still simpler to observe/harvest, so overlap only when the parallelism earns the extra bookkeeping.
• Use --dry-run to preview the plan (modes, clone count, scope) without spawning.

Long session? Force full inheritance.

The whole point of Manta is a warm clone — it boots from a fork of your live transcript, so it already knows what you and the user worked out. There's a safe default auto-fork threshold (~2 MB, tunable via --distill-threshold-bytes) so a cast doesn't blindly copy a huge transcript across every clone; above it the clone boots cold with a loud warning (never silently). For a long, context-rich session where inheritance is the point, pass --force-full-transcript — it forks the entire transcript regardless of size (proven on an 18 MB session: the clone recalled the conversation). Use it whenever the task depends on what was just discussed.

Forbidden

• Casting "to be safe". A speculative cast is wasted usage. Can't articulate why parallel beats serial? Do it serial.
• Skipping Step 1 because the task "feels big." Big ≠ parallelizable.
• Recursive cast from this check. The pre-cast decision is always a solo decision.
• Blind-retrying a locked Aghs mode. If council/decoy is rejected, surface the unlock path instead.

Examples

"Document every public API in this codebase." → discovery + docs. Two good fits: recon-swarm (3 clones map subtrees → findings) or documentation-chase (clones write docs/ directly). Pick documentation-chase if you want finished markdown; recon-swarm if you first need the map. Proactive: "That's a documentation-chase across ~4 areas — cast 4 clones?"

"Why does the integration test flake on CI but not locally?" → multi-layer bug, unknown root cause → bug-hunt. If there are genuinely rival fixes (fix the test vs fix the race vs mark flaky) and you want to compare them, forking-realities instead.

"Rename User.email to User.emailAddress everywhere." → same-pattern, disjoint locations → refactor-wave, partition by directory. Proactive: "~15 call sites across 3 packages — refactor-wave with 3 clones, one per package?"

"Should we use Postgres or DynamoDB for the event store?" → a hard judgment call with independent viewpoints worth gathering → council (🔒 if locked, suggest unlocking). You aggregate the proposals.

"Add a feature flag to the auth middleware." → none of Step 1 hits cleanly, < 10 min. Solo. Skip the cast.