/unlimited-power

name: unlimited-power
description: Self-terminating recursive orchestrator. Dispatches waves of subagents until a verifiable done-condition passes or the budget caps. Power with a kill-switch.

Unlimited Power

Invoked via Claude Code `/palpatine:unlimited-power <objective>` or Codex `$palpatine:unlimited-power <objective>`, or auto-triggered when the user says "do whatever it takes", "keep going until it's done", "don't stop until", "fully automate this", "run until done".

Fools hear *unlimited* and remove the brakes. Then the rate limiter removes them. Real power is a loop that knows when to stop — caps, a kill-switch, and a definition of *done* fixed before the first move. Unbounded recursion isn't strength; it's a man electrocuting himself with his own lightning.

Prime Rule

**No done-condition, no launch.** Before anything fans out, the objective is reduced to a check that can return true/false. If it can't, refuse:

**No stop condition.** I don't run blind — that's a fork bomb, not a plan.
Define "done": [what observable state ends this?]

"Until the job is done" without a definition of *done* is the whole bug. Fix it first.

The Governor

Hard caps. Set before dispatch, enforced every wave. This is what makes "unlimited" survivable.

const BUDGET = {
  maxWaves:    5,   // loop iterations — recursion lives HERE, not in nesting
  maxWidth:    5,   // parallel agents per wave — rate-limit safe
  maxDispatch: 20,  // total agents across the whole run, ever
  maxDepth:    1    // leaf agents do NOT spawn (see Rule 4 — matches /palpatine:adversary)
};

The Loop

Decompose → dispatch a bounded wave → verify against the done-condition → terminate or re-plan the *gap only*. Repeat until done or the governor stops it.

const CODEX_TEAM_SLOT_LIMIT = 4;

function chooseUnusedRunComponent(agents, taskPrefix) {
  const existingLeafNames = agents.map((agent) => agent.agent_name.split("/").at(-1));
  for (let runIndex = 0; ; runIndex += 1) {
    const runComponent = `r${runIndex}`;
    const reservedPrefix = `${taskPrefix}_${runComponent}_`;
    if (!existingLeafNames.some((name) => name.startsWith(reservedPrefix))) {
      return runComponent;
    }
  }
}

function agentConsumesCodexSlot(agent) {
  const status = agent.agent_status;
  if (["pending", "running", "working"].includes(status)) return true;
  return status !== null &&
    typeof status === "object" &&
    !Object.prototype.hasOwnProperty.call(status, "completed");
}

function availableCodexWorkerSlots(agents) {
  const activeAgentCount = agents.filter(agentConsumesCodexSlot).length;
  return Math.max(0, CODEX_TEAM_SLOT_LIMIT - activeAgentCount);
}

async function runUnlimitedPower({
  objective,
  explicitlyRequestedModel,
}) {
  // PRIME RULE — refuse blind objectives.
  const done = defineAcceptanceCheck(objective);
  if (!done) return terminate("no-stop-condition", "No verifiable done-condition.");

  const userRequestedModel = explicitlyRequestedModel;
  let plan = decompose(objective);   // → dependency-LAYERED: a wave holds only independent tasks; dependents land in later waves
  let dispatched = 0, lastGap = null;
  let nextWorkerDispatchIndex = 0;
  const initialAgentSnapshot = await list_agents({});
  const runComponent = chooseUnusedRunComponent(initialAgentSnapshot.agents, "worker");

  for (let wave = 0; wave < BUDGET.maxWaves; wave++) {
    if (plan.length === 0) {
      const gap = lastGap === null
        ? "No runnable tasks were produced for the objective."
        : `No runnable tasks were produced for the remaining gap: ${lastGap}`;
      return terminate("stalled", gap);
    }

    const remainingDispatchBudget = BUDGET.maxDispatch - dispatched;
    if (remainingDispatchBudget === 0) break;

    const currentAgentSnapshot = await list_agents({});
    const availableWorkerSlots = availableCodexWorkerSlots(currentAgentSnapshot.agents);
    if (availableWorkerSlots <= 0) {
      return terminate(
        "stalled",
        "No worker capacity is available; retry when a worker slot opens."
      );
    }

    const effectiveWaveWidth = Math.min(
      BUDGET.maxWidth,
      availableWorkerSlots,
      remainingDispatchBudget
    );
    const batch = plan.slice(0, effectiveWaveWidth);

    // A wave is independent-only, so Promise.all is safe. Dependent work was deferred
    // to a later wave by decompose()/replan() — ordering lives ACROSS waves, not within.
    const workers = await Promise.all(
      batch.map(task => {
        const workerTaskName = `worker_${runComponent}_w${wave}_${nextWorkerDispatchIndex++}`;
        return dispatchWorker(workerTaskName, task, done, userRequestedModel);
      })
    );
    const results = await collectWorkerResults(workers);
    dispatched += batch.length;

    if (done.passes(results)) return terminate("done", results);

    const gap = synthesizeGap(results);            // what's still missing
    if (gap === lastGap) return terminate("stalled", gap);  // doom-loop guard (best-effort; maxWaves is the hard stop)
    lastGap = gap;
    plan = replan(gap);                            // next wave attacks only the remainder
  }
  return terminate("budget-exhausted", lastGap);   // partial results + exact gap, never silent
}

Worker Schema

Leaf agents return data and a self-assessment — the main loop decides, not them.

const WORKER_SCHEMA = {
  type: "object",
  properties: {
    result:     { type: "string", description: "The artifact or finding produced — not narration" },
    done:       { type: "boolean", description: "Did this subtask fully meet its acceptance check?" },
    gap:        { type: "string", description: "If not done: exactly what remains" },
    evidence:   { type: "string", description: "Where the result lives — path, output, citation" },
    confidence: { type: "string", enum: ["high", "medium", "low"] }
  },
  required: ["result", "done", "gap", "evidence", "confidence"]
}