novusedge/palpatine/adversary

// Single adversary response
const ADVERSARY_SCHEMA = {
  type: "object",
  properties: {
    counter: {
      type: "string",
      description: "Their response move, not reasoning"
    },
    exploits: {
      type: "array",
      items: { type: "string" },
      maxItems: 3,
      description: "Target weaknesses they'd hit"
    },
    escalation: {
      type: "string",
      description: "How they escalate if resisted"
    },
    weakPoint: {
      type: "string",
      description: "Where they're exposed"
    }
  },
  required: ["counter", "exploits", "escalation", "weakPoint"]
}
// Multi-party player analysis
const PLAYER_SCHEMA = {
  type: "object",
  properties: {
    move: { type: "string" },
    alliance: {
      type: "string",
      description: "Who they side with and why it serves them"
    },
    threat: {
      type: "string",
      description: "How they could hurt target"
    },
    price: {
      type: "string",
      description: "Cost to neutralize or buy them off"
    },
    threatLevel: {
      type: "string",
      enum: ["high", "medium", "low"]
    }
  },
  required: ["move", "alliance", "threat", "price", "threatLevel"]
}
function validateJsonObject(rawResponse, schema) {
  let response;
  try {
    response = typeof rawResponse === "string"
      ? JSON.parse(rawResponse)
      : rawResponse;
  } catch {
    return null;
  }
  if (response === null || typeof response !== "object" || Array.isArray(response)) {
    return null;
  }
  const expectedKeys = [...schema.required].sort();
  const actualKeys = Object.keys(response).sort();
  if (
    actualKeys.length !== expectedKeys.length ||
    actualKeys.some((key, index) => key !== expectedKeys[index])
  ) {
    return null;
  }
  for (const key of schema.required) {
    const definition = schema.properties[key];
    const value = response[key];
    if (definition.type === "string" && typeof value !== "string") return null;
    if (
      definition.type === "array" &&
      (!Array.isArray(value) ||
        value.some((item) => typeof item !== definition.items.type) ||
        (definition.maxItems !== undefined && value.length > definition.maxItems))
    ) {
      return null;
    }
    if (definition.enum && !definition.enum.includes(value)) return null;
  }
  return response;
}

async function runClaudeAdversary() {
  let rawResponse = await Agent({
    description: "Adversary: [role]",
    prompt: `Model [OPPONENT] as ruthless rational actor.
OPPONENT: [role/name]
GOALS: [what they want — specific]
RESOURCES: [leverage, relationships, info, authority]
CONSTRAINTS: [what stops them from going nuclear]
TARGET is about to: [user's planned move]
Assume competent and self-interested. What's their counter-move?
Return only raw JSON with exactly these keys: counter, exploits, escalation, weakPoint.
No Markdown fences. Most likely play, stated cold.`
  });
  let response = validateJsonObject(rawResponse, ADVERSARY_SCHEMA);
  if (!response) {
    rawResponse = await Agent({
      description: "Correct adversary JSON",
      prompt: `The prior response was invalid: ${rawResponse}
Return only raw JSON with exactly these keys: counter, exploits, escalation, weakPoint.`
    });
    response = validateJsonObject(rawResponse, ADVERSARY_SCHEMA);
  }
  if (!response) throw new Error("Claude adversary returned invalid JSON after correction.");
  return response;
}

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);
}
function hasExactKeys(value, expectedKeys) {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
  const actualKeys = Object.keys(value).sort();
  const sortedExpectedKeys = [...expectedKeys].sort();
  return actualKeys.length === sortedExpectedKeys.length &&
    actualKeys.every((key, index) => key === sortedExpectedKeys[index]);
}
async function runMultiPartyAdversary({
  situation,
  explicitlyRequestedModel,
}) {
  const players = [
    { name: "CEO", goals: "...", leverage: "..." },
    { name: "HR Director", goals: "...", leverage: "..." },
    { name: "Skip-level", goals: "...", leverage: "..." }
  ];
  const userRequestedModel = explicitlyRequestedModel;
  const PLAYER_OUTPUT_KEYS = ["move", "alliance", "threat", "price", "threatLevel"];
  const MAX_PLAYER_MODELS = 5;
  const COLLECTION_TIMEOUT_MS = 120_000;
  const COLLECTION_TIMEOUT_DESCRIPTION = `${COLLECTION_TIMEOUT_MS / 1_000} seconds`;
  const remainingPlayers = players.slice(0, MAX_PLAYER_MODELS);
  const results = [];
  const collectionGaps = players.slice(MAX_PLAYER_MODELS).map((player) => ({
    workerTask: null,
    player: player.name,
    gap: `Player ${player.name} was not dispatched because the ${MAX_PLAYER_MODELS}-player cap was reached.`
  }));
  const initialAgentSnapshot = await list_agents({});
  const runComponent = chooseUnusedRunComponent(initialAgentSnapshot.agents, "player");
  async function dispatchCodexPlayer(workerTaskName, player, userRequestedModel) {
    const { task_name: workerTask } = await spawn_agent({
      task_name: workerTaskName,
      fork_turns: "none",
      ...(userRequestedModel ? { model: userRequestedModel } : {}),
      message: `Model ${player.name} as a self-interested actor.
PLAYER: ${player.name}
GOALS: ${player.goals}
LEVERAGE: ${player.leverage}
SITUATION: ${situation}
Return only raw JSON with exactly these keys: ${PLAYER_OUTPUT_KEYS.join(", ")}.
No Markdown fences.`
    });
    return { workerTask, player };
  }
  async function collectCodexPlayerFinals(workerTasks) {
    const playerByWorkerTask = new Map(
      workerTasks.map(({ workerTask, player }) => [workerTask, player])
    );
    const pendingWorkerTasks = new Set(workerTasks.map(({ workerTask }) => workerTask));
    const resultsByWorkerTask = new Map();
    const correctionRequested = new Set();
    const rejectedFinalByWorkerTask = new Map();
    const collectionGaps = [];
    const collectionDeadline = Date.now() + COLLECTION_TIMEOUT_MS;
    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 = validateJsonObject(rawResponse, PLAYER_SCHEMA);
        if (!hasExactKeys(response, PLAYER_OUTPUT_KEYS)) {
          if (correctionRequested.has(workerTask)) {
            const player = playerByWorkerTask.get(workerTask);
            collectionGaps.push({
              workerTask,
              player: player.name,
              gap: `Player ${player.name} returned invalid JSON after one correction.`
            });
            pendingWorkerTasks.delete(workerTask);
            continue;
          }
          if (Date.now() >= collectionDeadline) continue;
          await followup_task({
            target: workerTask,
            message: `Return only raw JSON with exactly these keys: ${PLAYER_OUTPUT_KEYS.join(", ")}. No Markdown fences.`
          });
          correctionRequested.add(workerTask);
          rejectedFinalByWorkerTask.set(workerTask, rawResponse);
          // The next pass rechecks collectionDeadline before waiting for this correction.
          continue;
        }
        const player = playerByWorkerTask.get(workerTask);
        resultsByWorkerTask.set(workerTask, { workerTask, player, response });
        pendingWorkerTasks.delete(workerTask);
      }
    }
    for (const workerTask of pendingWorkerTasks) {
      await interrupt_agent({ target: workerTask });
      const player = playerByWorkerTask.get(workerTask);
      collectionGaps.push({
        workerTask,
        player: player.name,
        gap: `No valid final was delivered for player ${player.name} from canonical task ${workerTask} before the ${COLLECTION_TIMEOUT_DESCRIPTION} collection deadline.`
      });
    }
    return { resultsByWorkerTask, collectionGaps };
  }