novusedge/palpatine/unlimited-power

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

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)
};

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
}

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"]
}

function normalizeWorkerResponse(rawResponse) {
  let response;
  try {
    response = typeof rawResponse === "string"
      ? JSON.parse(rawResponse)
      : rawResponse;
  } catch {
    return null;
  }
  const requiredKeys = ["result", "done", "gap", "evidence", "confidence"];
  if (
    response === null ||
    typeof response !== "object" ||
    Array.isArray(response) ||
    Object.keys(response).sort().join(",") !== [...requiredKeys].sort().join(",") ||
    typeof response.result !== "string" ||
    typeof response.done !== "boolean" ||
    typeof response.gap !== "string" ||
    typeof response.evidence !== "string" ||
    !["high", "medium", "low"].includes(response.confidence)
  ) {
    return null;
  }
  return response;
}
async function dispatchWorker(workerTaskName, task, acceptanceCheck, userRequestedModel) {
  const { task_name: workerTask } = await spawn_agent({
    task_name: workerTaskName,
    fork_turns: "none",
    ...(userRequestedModel ? { model: userRequestedModel } : {}),
    message: `Task: ${task.name}
${task.prompt}
Acceptance check: ${acceptanceCheck}
Leaf workers never spawn subagents.
Return only raw JSON with exactly these keys: result, done, gap, evidence, confidence.
No Markdown fences.`
  });
  return workerTask;
}
async function collectWorkerResults(workerTasks) {
  return collectCodexWorkerFinals(workerTasks);
}
const COLLECTION_TIMEOUT_MS = 120_000;
async function collectCodexWorkerFinals(workerTasks) {
  const pendingWorkerTasks = new Set(workerTasks);
  const resultsByWorkerTask = new Map();
  const correctionRequested = new Set();
  const rejectedFinalByWorkerTask = new Map();
  const collectionDeadline = Date.now() + COLLECTION_TIMEOUT_MS;
  const COLLECTION_TIMEOUT_DESCRIPTION = `${COLLECTION_TIMEOUT_MS / 1_000} seconds`;
  while (pendingWorkerTasks.size > 0 && Date.now() < collectionDeadline) {
    const remainingMs = collectionDeadline - Date.now();
    if (remainingMs <= 0) break;
    // Codex accepts a timeout_ms of at least 10 seconds, so the final wait can overshoot by at most that amount.
    const waitMs = Math.max(10_000, Math.min(60_000, remainingMs));
    await wait_agent({ timeout_ms: waitMs });
    const { agents } = await list_agents({});
    for (const agent of agents) {
      const workerTask = agent.agent_name;
      if (!pendingWorkerTasks.has(workerTask)) continue;
      if (
        typeof agent.agent_status !== "object" ||
        typeof agent.agent_status.completed !== "string"
      ) {
        continue;
      }
      const rawResponse = agent.agent_status.completed;
      if (rejectedFinalByWorkerTask.get(workerTask) === rawResponse) continue;
      const response = normalizeWorkerResponse(rawResponse);
      if (!response) {
        if (correctionRequested.has(workerTask)) {
          resultsByWorkerTask.set(workerTask, {
            result: "Invalid final result.",
            done: false,
            gap: `Worker ${workerTask} returned invalid JSON after one correction.`,
            evidence: `The completed payload for canonical worker task ${workerTask} did not match WORKER_SCHEMA.`,
            confidence: "low"
          });
          pendingWorkerTasks.delete(workerTask);
          continue;
        }
        if (Date.now() >= collectionDeadline) continue;
        await followup_task({
          target: workerTask,
          message: "Return only raw JSON with exactly these keys: result, done, gap, evidence, confidence. No Markdown fences."
        });
        correctionRequested.add(workerTask);
        rejectedFinalByWorkerTask.set(workerTask, rawResponse);
        continue;
      }
      resultsByWorkerTask.set(workerTask, response);
      pendingWorkerTasks.delete(workerTask);
    }
  }
  for (const workerTask of pendingWorkerTasks) {
    await interrupt_agent({ target: workerTask });
    resultsByWorkerTask.set(workerTask, {
      result: "No final result returned.",
      done: false,
      gap: `Worker ${workerTask} did not return before the ${COLLECTION_TIMEOUT_DESCRIPTION} collection deadline.`,
      evidence: `No final was delivered for canonical worker task ${workerTask} before the ${COLLECTION_TIMEOUT_DESCRIPTION} collection deadline.`,
      confidence: "low",
    });
  }
  return workerTasks.map((workerTask) => resultsByWorkerTask.get(workerTask));
}