oxe-cc 0.9.3 → 1.0.0

package/packages/runtime/src/projection/projection-engine.ts

@@ -0,0 +1,249 @@
+import type { RunState } from '../reducers/run-state-reducer';
+import type { ExecutionGraph } from '../compiler/graph-compiler';
+import type { VerificationResult } from '../models/verification-result';
+import type { CheckResult } from '../verification/verification-compiler';
+
+function isoToDate(iso: string | null | undefined): string {
+  if (!iso) return '—';
+  return iso.slice(0, 10);
+}
+
+function statusIcon(status: string): string {
+  switch (status) {
+    case 'completed': return '✓';
+    case 'failed': return '✗';
+    case 'blocked': return '⊘';
+    case 'running': return '⟳';
+    default: return '○';
+  }
+}
+
+function verifyIcon(status: string): string {
+  switch (status) {
+    case 'pass': return '✓ PASS';
+    case 'fail': return '✗ FAIL';
+    case 'skip': return '— SKIP';
+    case 'error': return '! ERROR';
+    default: return status;
+  }
+}
+
+export class ProjectionEngine {
+  projectPlan(state: RunState, graph: ExecutionGraph): string {
+    const run = state.run;
+    const lines: string[] = [
+      '# OXE — Plano de Execução',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Resumo',
+      '',
+      `- **Run:** ${run?.run_id ?? '—'}`,
+      `- **Status:** ${run?.status ?? 'sem run'}`,
+      `- **Iniciado em:** ${isoToDate(run?.started_at)}`,
+      `- **Nós:** ${graph.metadata.node_count} tarefas em ${graph.metadata.wave_count} onda(s)`,
+      '',
+      '## Ondas e tarefas',
+      '',
+    ];
+
+    for (const wave of graph.waves) {
+      lines.push(`### Onda ${wave.wave_number}`);
+      lines.push('');
+      lines.push('| ID | Título | Status | Dependências |');
+      lines.push('|----|--------|--------|--------------|');
+      for (const nodeId of wave.node_ids) {
+        const node = graph.nodes.get(nodeId);
+        const wItem = state.workItems.get(nodeId);
+        const status = wItem?.status ?? 'pending';
+        const deps = node?.depends_on.join(', ') || '—';
+        lines.push(`| ${nodeId} | ${node?.title ?? nodeId} | ${statusIcon(status)} ${status} | ${deps} |`);
+      }
+      lines.push('');
+    }
+
+    if (state.completedWorkItems.size > 0 || state.failedWorkItems.size > 0) {
+      lines.push('## Progresso');
+      lines.push('');
+      lines.push(`- **Concluídos:** ${[...state.completedWorkItems].join(', ') || '—'}`);
+      lines.push(`- **Falhos:** ${[...state.failedWorkItems].join(', ') || '—'}`);
+      lines.push(`- **Bloqueados:** ${[...state.blockedWorkItems].join(', ') || '—'}`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  projectVerify(
+    state: RunState,
+    results: VerificationResult[],
+    checkResults?: CheckResult[]
+  ): string {
+    const run = state.run;
+    const lines: string[] = [
+      '# OXE — Verificação',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Auditoria de pré-execução',
+      '',
+      `- **Run:** ${run?.run_id ?? '—'}`,
+      `- **Iniciado em:** ${isoToDate(run?.started_at)}`,
+      `- **Concluído em:** ${isoToDate(run?.ended_at)}`,
+      `- **Status:** ${run?.status ?? '—'}`,
+      '',
+    ];
+
+    if (results.length > 0) {
+      lines.push('## Critérios de aceite');
+      lines.push('');
+      lines.push('| ID | Check | Status | Evidências |');
+      lines.push('|----|-------|--------|------------|');
+      for (const r of results) {
+        const evidenceList = r.evidence_refs.join(', ') || '—';
+        lines.push(`| ${r.check_id} | ${r.summary ?? r.check_id} | ${verifyIcon(r.status)} | ${evidenceList} |`);
+      }
+      lines.push('');
+    }
+
+    if (checkResults && checkResults.length > 0) {
+      lines.push('## Resultados dos checks executados');
+      lines.push('');
+      lines.push('| Check | Aceite | Status | Duração |');
+      lines.push('|-------|--------|--------|---------|');
+      for (const cr of checkResults) {
+        lines.push(`| ${cr.check_id} | ${cr.acceptance_ref ?? '—'} | ${verifyIcon(cr.status)} | ${cr.duration_ms}ms |`);
+      }
+      lines.push('');
+    }
+
+    const passed = results.filter((r) => r.status === 'pass').length;
+    const failed = results.filter((r) => r.status === 'fail').length;
+    const allPass = failed === 0 && results.length > 0;
+
+    lines.push('## Conclusão');
+    lines.push('');
+    lines.push(`- **Total de critérios:** ${results.length}`);
+    lines.push(`- **Aprovados:** ${passed}`);
+    lines.push(`- **Reprovados:** ${failed}`);
+    lines.push('');
+    lines.push(allPass
+      ? '> ✓ **Verificação concluída com sucesso.** Todos os critérios foram atendidos.'
+      : `> ✗ **Verificação com falhas.** ${failed} critério(s) não atendido(s).`);
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  projectState(state: RunState): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+    const blocked = [...state.blockedWorkItems];
+
+    const lines: string[] = [
+      '# OXE — Estado',
+      '',
+      '<!-- Gerado automaticamente pelo Projection Engine — não editar diretamente -->',
+      '',
+      '## Fase atual',
+      '',
+      `- **Status da run:** ${run?.status ?? 'sem run ativa'}`,
+      `- **Run ID:** ${run?.run_id ?? '—'}`,
+      `- **Modo:** ${run?.mode ?? '—'}`,
+      '',
+      '## Runtime operacional',
+      '',
+      `- **runtime_status:** ${run?.status ?? '—'}`,
+      `- **active_run_ref:** ${run?.run_id ?? '—'}`,
+      '',
+      '## Progresso',
+      '',
+      `- **Concluídos (${completed.length}):** ${completed.join(', ') || '—'}`,
+      `- **Falhos (${failed.length}):** ${failed.join(', ') || '—'}`,
+      `- **Bloqueados (${blocked.length}):** ${blocked.join(', ') || '—'}`,
+      '',
+      `- **lifecycleStatus:** ${run?.status === 'completed' ? 'closed' : run?.status === 'running' ? 'executing' : 'pending_execute'}`,
+      '',
+    ];
+
+    return lines.join('\n');
+  }
+
+  projectRunSummary(state: RunState): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+    const blocked = [...state.blockedWorkItems];
+    const totalAttempts = [...state.attempts.values()].reduce((s, a) => s + a.length, 0);
+
+    const lines: string[] = [
+      `## Run Summary — ${run?.run_id ?? 'unknown'}`,
+      '',
+      `**Status:** ${run?.status ?? '—'}  `,
+      `**Mode:** ${run?.mode ?? '—'}  `,
+      `**Started:** ${isoToDate(run?.started_at)}  `,
+      `**Ended:** ${isoToDate(run?.ended_at)}  `,
+      '',
+      `**Completed:** ${completed.length} tasks  `,
+      `**Failed:** ${failed.length} tasks  `,
+      `**Blocked:** ${blocked.length} tasks  `,
+      `**Total attempts:** ${totalAttempts}  `,
+      '',
+    ];
+
+    if (completed.length > 0) {
+      lines.push(`**✓ Completed:** ${completed.join(', ')}`);
+    }
+    if (failed.length > 0) {
+      lines.push(`**✗ Failed:** ${failed.join(', ')}`);
+    }
+    if (blocked.length > 0) {
+      lines.push(`**⊘ Blocked:** ${blocked.join(', ')}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  projectPRSummary(state: RunState, graph: ExecutionGraph): string {
+    const run = state.run;
+    const completed = [...state.completedWorkItems];
+    const failed = [...state.failedWorkItems];
+
+    const lines: string[] = [
+      '## Summary',
+      '',
+    ];
+
+    if (completed.length > 0) {
+      for (const id of completed) {
+        const node = graph.nodes.get(id);
+        lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
+      }
+    }
+
+    if (failed.length > 0) {
+      lines.push('');
+      lines.push('**⚠️ Incomplete tasks:**');
+      for (const id of failed) {
+        const node = graph.nodes.get(id);
+        lines.push(`- ✗ ${node?.title ?? id} (\`${id}\`)`);
+      }
+    }
+
+    lines.push('');
+    lines.push('## Test plan');
+    lines.push('');
+
+    for (const wave of graph.waves) {
+      lines.push(`- [ ] Wave ${wave.wave_number}: ${wave.node_ids.join(', ')}`);
+    }
+
+    lines.push('');
+    lines.push(`**Run:** \`${run?.run_id ?? '—'}\` | **Status:** ${run?.status ?? '—'}`);
+    lines.push('');
+    lines.push('🤖 Generated with [OXE Runtime](https://github.com/propagno/oxe-build)');
+
+    return lines.join('\n');
+  }
+}

package/packages/runtime/src/reducers/debug-reducer.ts

@@ -0,0 +1,36 @@
+import type { OxeEvent } from '../events/envelope';
+import { createEmptyRunState, applyEventExported as applyEvent } from './run-state-reducer';
+import type { RunState } from './run-state-reducer';
+
+export interface ReplayStep {
+  index: number;
+  event: OxeEvent;
+  state: RunState;
+}
+
+export function* stepReplay(events: OxeEvent[]): Generator<ReplayStep> {
+  let state = createEmptyRunState();
+  for (let i = 0; i < events.length; i++) {
+    state = applyEvent(state, events[i]);
+    yield { index: i, event: events[i], state };
+  }
+}
+
+export function replayUntil(
+  events: OxeEvent[],
+  predicate: (step: ReplayStep) => boolean
+): ReplayStep | null {
+  for (const step of stepReplay(events)) {
+    if (predicate(step)) return step;
+  }
+  return null;
+}
+
+export function replaySlice(events: OxeEvent[], from: number, to: number): ReplayStep[] {
+  const steps: ReplayStep[] = [];
+  for (const step of stepReplay(events)) {
+    if (step.index >= from && step.index <= to) steps.push(step);
+    if (step.index > to) break;
+  }
+  return steps;
+}

package/packages/runtime/src/reducers/index.ts

@@ -0,0 +1,2 @@
+export * from './run-state-reducer';
+export * from './debug-reducer';

package/packages/runtime/src/reducers/run-state-reducer.ts

@@ -0,0 +1,127 @@
+import type { OxeEvent } from '../events/envelope';
+import type { Run } from '../models/run';
+import type { WorkItem } from '../models/work-item';
+import type { Attempt } from '../models/attempt';
+import type { Workspace } from '../models/workspace';
+
+export interface RunState {
+  run: Run | null;
+  workItems: Map<string, WorkItem>;
+  attempts: Map<string, Attempt[]>;
+  workspaces: Map<string, Workspace>;
+  completedWorkItems: Set<string>;
+  failedWorkItems: Set<string>;
+  blockedWorkItems: Set<string>;
+}
+
+export function createEmptyRunState(): RunState {
+  return {
+    run: null,
+    workItems: new Map(),
+    attempts: new Map(),
+    workspaces: new Map(),
+    completedWorkItems: new Set(),
+    failedWorkItems: new Set(),
+    blockedWorkItems: new Set(),
+  };
+}
+
+export function reduce(events: OxeEvent[]): RunState {
+  return events.reduce(applyEvent, createEmptyRunState());
+}
+
+// Exported alias so debug-reducer can import applyEvent without circular issues
+export { applyEvent as applyEventExported };
+
+function applyEvent(state: RunState, event: OxeEvent): RunState {
+  switch (event.type) {
+    case 'RunStarted': {
+      const run = event.payload as unknown as Run;
+      return { ...state, run };
+    }
+
+    case 'RunCompleted': {
+      if (!state.run) return state;
+      const status = (event.payload as { status?: Run['status'] }).status ?? 'completed';
+      return {
+        ...state,
+        run: { ...state.run, status, ended_at: event.timestamp },
+      };
+    }
+
+    case 'WorkItemReady': {
+      if (!event.work_item_id) return state;
+      const workItems = new Map(state.workItems);
+      const existing = workItems.get(event.work_item_id);
+      if (existing) {
+        workItems.set(event.work_item_id, { ...existing, status: 'ready' });
+      } else {
+        // First time we see this work item — create from payload
+        const item = event.payload as unknown as WorkItem;
+        workItems.set(event.work_item_id, { ...item, work_item_id: event.work_item_id, status: 'ready' });
+      }
+      return { ...state, workItems };
+    }
+
+    case 'AttemptStarted': {
+      if (!event.work_item_id || !event.attempt_id) return state;
+      const attempts = new Map(state.attempts);
+      const attempt: Attempt = {
+        attempt_id: event.attempt_id,
+        work_item_id: event.work_item_id,
+        attempt_number: (event.payload as { attempt_number?: number }).attempt_number ?? 1,
+        workspace_id: null,
+        agent_profile: null,
+        model: null,
+        started_at: event.timestamp,
+        ended_at: null,
+        outcome: null,
+      };
+      const existing = attempts.get(event.work_item_id) ?? [];
+      attempts.set(event.work_item_id, [...existing, attempt]);
+      return { ...state, attempts };
+    }
+
+    case 'WorkspaceAllocated': {
+      const ws = event.payload as unknown as Workspace;
+      if (!ws.workspace_id) return state;
+      const workspaces = new Map(state.workspaces);
+      workspaces.set(ws.workspace_id, { ...ws, status: 'ready' });
+      return { ...state, workspaces };
+    }
+
+    case 'WorkItemCompleted': {
+      if (!event.work_item_id) return state;
+      const workItems = new Map(state.workItems);
+      const item = workItems.get(event.work_item_id);
+      if (item) workItems.set(event.work_item_id, { ...item, status: 'completed' });
+      const completedWorkItems = new Set(state.completedWorkItems);
+      completedWorkItems.add(event.work_item_id);
+      return { ...state, workItems, completedWorkItems };
+    }
+
+    case 'WorkItemBlocked': {
+      if (!event.work_item_id) return state;
+      const workItems = new Map(state.workItems);
+      const item = workItems.get(event.work_item_id);
+      if (item) workItems.set(event.work_item_id, { ...item, status: 'blocked' });
+      const blockedWorkItems = new Set(state.blockedWorkItems);
+      blockedWorkItems.add(event.work_item_id);
+      return { ...state, workItems, blockedWorkItems };
+    }
+
+    default:
+      return state;
+  }
+}
+
+export function getWorkItemStatus(
+  state: RunState,
+  workItemId: string
+): WorkItem['status'] | null {
+  return state.workItems.get(workItemId)?.status ?? null;
+}
+
+export function getAttemptCount(state: RunState, workItemId: string): number {
+  return state.attempts.get(workItemId)?.length ?? 0;
+}

package/packages/runtime/src/scheduler/index.ts

@@ -0,0 +1 @@
+export * from './scheduler';

package/packages/runtime/src/scheduler/multi-agent-coordinator.ts

@@ -0,0 +1,231 @@
+import { appendEvent } from '../events/bus';
+import type { ExecutionGraph, GraphNode } from '../compiler/graph-compiler';
+import type { WorkspaceManager } from '../workspace/workspace-manager';
+import type { TaskExecutor, TaskResult, SchedulerContext } from './scheduler';
+import { Scheduler } from './scheduler';
+import type { WorkspaceLease } from '../models/workspace';
+
+export type CoordinationMode = 'parallel' | 'competitive' | 'cooperative';
+
+export interface AgentSpec {
+  id: string;
+  executor: TaskExecutor;
+  workspaceManager: WorkspaceManager;
+  /** Task IDs this agent is responsible for (used in parallel mode) */
+  assignedTaskIds?: string[];
+}
+
+export interface CoordinationOptions {
+  mode: CoordinationMode;
+  agents: AgentSpec[];
+  projectRoot: string;
+  sessionId: string | null;
+  runId: string;
+  onEvent?: SchedulerContext['onEvent'];
+}
+
+export interface CoordinationResult {
+  mode: CoordinationMode;
+  run_id: string;
+  completed: string[];
+  failed: string[];
+  blocked: string[];
+  agent_results: Array<{ agent_id: string; completed: string[]; failed: string[] }>;
+}
+
+// ─── Parallel mode ───────────────────────────────────────────────────────────
+// Tasks are partitioned across agents. Each agent runs its own Scheduler
+// on a sub-graph. Results are merged.
+
+async function runParallel(
+  graph: ExecutionGraph,
+  opts: CoordinationOptions
+): Promise<CoordinationResult> {
+  const { agents, projectRoot, sessionId, runId } = opts;
+
+  // Partition tasks across agents (round-robin if assignedTaskIds not set)
+  const partitions = agents.map((a) => a.assignedTaskIds ?? []);
+  if (partitions.every((p) => p.length === 0)) {
+    const allIds = [...graph.nodes.keys()];
+    allIds.forEach((id, i) => {
+      partitions[i % agents.length].push(id);
+    });
+  }
+
+  appendEvent(projectRoot, sessionId, {
+    type: 'RunStarted',
+    run_id: runId,
+    payload: { mode: 'parallel', agent_count: agents.length },
+  });
+
+  const agentResults = await Promise.all(
+    agents.map(async (agent, idx) => {
+      const subGraph = subGraphFor(graph, partitions[idx]);
+      if (subGraph.nodes.size === 0) {
+        return { agent_id: agent.id, completed: [], failed: [] };
+      }
+      const ctx: SchedulerContext = {
+        projectRoot,
+        sessionId,
+        runId: `${runId}-agent${idx}`,
+        executor: agent.executor,
+        workspaceManager: agent.workspaceManager,
+        onEvent: opts.onEvent,
+      };
+      const scheduler = new Scheduler();
+      const result = await scheduler.run(subGraph, ctx);
+      return { agent_id: agent.id, completed: result.completed, failed: result.failed };
+    })
+  );
+
+  const completed = agentResults.flatMap((r) => r.completed);
+  const failed = agentResults.flatMap((r) => r.failed);
+
+  appendEvent(projectRoot, sessionId, {
+    type: 'RunCompleted',
+    run_id: runId,
+    payload: { mode: 'parallel', completed: completed.length, failed: failed.length },
+  });
+
+  return { mode: 'parallel', run_id: runId, completed, failed, blocked: [], agent_results: agentResults };
+}
+
+// ─── Competitive mode ────────────────────────────────────────────────────────
+// Two agents attempt the same task. First success wins; the loser's workspace
+// is disposed. Requires exactly 2 agents.
+
+async function runCompetitive(
+  graph: ExecutionGraph,
+  opts: CoordinationOptions
+): Promise<CoordinationResult> {
+  if (opts.agents.length < 2) {
+    throw new Error('Competitive mode requires at least 2 agents');
+  }
+  const [agentA, agentB] = opts.agents;
+  const { projectRoot, sessionId, runId } = opts;
+
+  appendEvent(projectRoot, sessionId, {
+    type: 'RunStarted',
+    run_id: runId,
+    payload: { mode: 'competitive' },
+  });
+
+  const completed: string[] = [];
+  const failed: string[] = [];
+
+  for (const wave of graph.waves) {
+    for (const nodeId of wave.node_ids) {
+      const node = graph.nodes.get(nodeId)!;
+      const result = await competeTwoAgents(nodeId, node, agentA, agentB, opts);
+      if (result.success) completed.push(nodeId);
+      else failed.push(nodeId);
+      if (failed.length > 0) break;
+    }
+    if (failed.length > 0) break;
+  }
+
+  appendEvent(projectRoot, sessionId, {
+    type: 'RunCompleted',
+    run_id: runId,
+    payload: { mode: 'competitive', completed: completed.length },
+  });
+
+  return {
+    mode: 'competitive',
+    run_id: runId,
+    completed,
+    failed,
+    blocked: [],
+    agent_results: [
+      { agent_id: agentA.id, completed, failed },
+      { agent_id: agentB.id, completed: [], failed: [] },
+    ],
+  };
+}
+
+async function competeTwoAgents(
+  nodeId: string,
+  node: GraphNode,
+  agentA: AgentSpec,
+  agentB: AgentSpec,
+  opts: CoordinationOptions
+): Promise<TaskResult> {
+  const { projectRoot, sessionId, runId } = opts;
+
+  const allocA = await agentA.workspaceManager.allocate({
+    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
+  });
+  const allocB = await agentB.workspaceManager.allocate({
+    work_item_id: nodeId, attempt_number: 1, strategy: node.workspace_strategy, mutation_scope: node.mutation_scope,
+  });
+
+  appendEvent(projectRoot, sessionId, {
+    type: 'AttemptStarted',
+    run_id: runId,
+    work_item_id: nodeId,
+    payload: { mode: 'competitive', agents: [agentA.id, agentB.id] },
+  });
+
+  // Race both agents — first success wins
+  const [resultA, resultB] = await Promise.all([
+    agentA.executor.execute(node, allocA, runId, 1).catch((e) => ({
+      success: false, failure_class: 'env' as const, evidence: [], output: String(e),
+    })),
+    agentB.executor.execute(node, allocB, runId, 1).catch((e) => ({
+      success: false, failure_class: 'env' as const, evidence: [], output: String(e),
+    })),
+  ]);
+
+  // Clean up both workspaces
+  await Promise.all([
+    agentA.workspaceManager.dispose(allocA.workspace_id).catch(() => {}),
+    agentB.workspaceManager.dispose(allocB.workspace_id).catch(() => {}),
+  ]);
+
+  // Pick winner: prefer success; if both succeed, prefer A (primary agent)
+  const winner = resultA.success ? resultA : resultB.success ? resultB : resultA;
+
+  if (winner.success) {
+    appendEvent(projectRoot, sessionId, { type: 'WorkItemCompleted', run_id: runId, work_item_id: nodeId, payload: { mode: 'competitive' } });
+  } else {
+    appendEvent(projectRoot, sessionId, { type: 'WorkItemBlocked', run_id: runId, work_item_id: nodeId, payload: { mode: 'competitive', failure_class: winner.failure_class } });
+  }
+
+  return winner;
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+export class MultiAgentCoordinator {
+  async run(graph: ExecutionGraph, opts: CoordinationOptions): Promise<CoordinationResult> {
+    switch (opts.mode) {
+      case 'parallel': return runParallel(graph, opts);
+      case 'competitive': return runCompetitive(graph, opts);
+      case 'cooperative':
+        // Cooperative mode: planner (agent[0]) prepares context,
+        // executor (agent[1]) implements. For R3, delegate to sequential parallel.
+        return runParallel(graph, { ...opts, mode: 'parallel' });
+      default:
+        throw new Error(`Unknown coordination mode: ${opts.mode}`);
+    }
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function subGraphFor(graph: ExecutionGraph, nodeIds: string[]): ExecutionGraph {
+  const ids = new Set(nodeIds);
+  const nodes = new Map([...graph.nodes].filter(([id]) => ids.has(id)));
+  const edges = graph.edges.filter((e) => ids.has(e.from) && ids.has(e.to));
+  const waves = graph.waves.map((w) => ({
+    wave_number: w.wave_number,
+    node_ids: w.node_ids.filter((id) => ids.has(id)),
+  })).filter((w) => w.node_ids.length > 0);
+
+  return {
+    nodes,
+    edges,
+    waves,
+    metadata: { ...graph.metadata, node_count: nodes.size, wave_count: waves.length },
+  };
+}