Transformer Math

// Coordinator manages workers — never writes code directly
class CoordinatorMode {
  private coordinatorTools: string[] = [
    "Agent",        // spawn workers
    "SendMessage",  // communicate with running workers
    "TeamCreate",   // create worker teams
    "Read", "Glob", "Grep",  // can READ code to plan
    // NO Bash, Edit, Write — coordinator doesn't code
  ];

  private workerTools: string[] = [
    "Bash", "Read", "Write", "Edit", "Glob", "Grep",
    // NO Agent — workers can't spawn sub-workers
  ];

  async coordinate(task: Task): Promise<IntegrationResult> {
    // 1. Analyze the task
    const plan = await this.planDecomposition(task);

    // 2. Spawn workers for each subtask
    const workers: Agent[] = [];
    for (const subtask of plan.subtasks) {
      const worker = await spawnAgent({
        prompt: subtask.description,
        tools: this.workerTools,
        background: true, // parallel execution
      });
      workers.push(worker);
    }

    // 3. Monitor and aggregate results
    const results = await gatherResults(workers);

    // 4. Verify and integrate
    return this.verifyIntegration(results);
  }
}

const COORDINATOR_TOOLS: string[] = [
  "Agent", "SendMessage", "TeamCreate", "TeamDelete",
  "Read", "Glob", "Grep",  // read-only access
];

const WORKER_TOOLS: string[] = [
  "Bash", "Read", "Write", "Edit", "Glob", "Grep",
  // No Agent — strict two-level hierarchy
];

const ALL_TOOLS: string[] = [...COORDINATOR_TOOLS, ...WORKER_TOOLS];

// Tool set determined at startup, not by the agent
function getAvailableTools(mode: string): string[] {
  if (process.env.COORDINATOR_MODE) {
    return COORDINATOR_TOOLS; // management only
  }
  return ALL_TOOLS; // full access for single-agent mode
}

// Workers are spawned with explicit tool lists
async function spawnWorker(taskDescription: string): Promise<Agent> {
  return await Agent({
    prompt: taskDescription,
    tools: WORKER_TOOLS, // enforced at registry level
    // Agent tool NOT in WORKER_TOOLS — no recursion possible
  });
}

// Spawn workers for independent subtasks concurrently
async function runParallelWorkers(
  subtasks: Subtask[],
  workerTools: string[]
): Promise<WorkerResult[]> {
  async function runOne(subtask: Subtask): Promise<WorkerResult> {
    const result = await spawnAgent({
      prompt: subtask.description,
      tools: workerTools,
      background: true,
    });
    return { subtask: subtask.id, result };
  }

  // All workers run simultaneously
  const results = await Promise.all(subtasks.map(runOne));

  // Check for conflicts
  const modifiedFiles = new Map<string, string>();
  for (const r of results) {
    for (const f of r.result.filesModified) {
      if (modifiedFiles.has(f)) {
        throw new ConflictError(
          `${f} modified by workers ${modifiedFiles.get(f)} and ${r.subtask}`
        );
      }
      modifiedFiles.set(f, r.subtask);
    }
  }

  return results;
}