oxe-cc 0.9.2 → 1.0.0

package/lib/runtime/projection/projection-engine.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectionEngine = void 0;
+function isoToDate(iso) {
+    if (!iso)
+        return '—';
+    return iso.slice(0, 10);
+}
+function statusIcon(status) {
+    switch (status) {
+        case 'completed': return '✓';
+        case 'failed': return '✗';
+        case 'blocked': return '⊘';
+        case 'running': return '⟳';
+        default: return '○';
+    }
+}
+function verifyIcon(status) {
+    switch (status) {
+        case 'pass': return '✓ PASS';
+        case 'fail': return '✗ FAIL';
+        case 'skip': return '— SKIP';
+        case 'error': return '! ERROR';
+        default: return status;
+    }
+}
+class ProjectionEngine {
+    projectPlan(state, graph) {
+        const run = state.run;
+        const lines = [
+            '# 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, results, checkResults) {
+        const run = state.run;
+        const lines = [
+            '# 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) {
+        const run = state.run;
+        const completed = [...state.completedWorkItems];
+        const failed = [...state.failedWorkItems];
+        const blocked = [...state.blockedWorkItems];
+        const lines = [
+            '# 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) {
+        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 = [
+            `## 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, graph) {
+        const run = state.run;
+        const completed = [...state.completedWorkItems];
+        const failed = [...state.failedWorkItems];
+        const lines = [
+            '## 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');
+    }
+}
+exports.ProjectionEngine = ProjectionEngine;

package/lib/runtime/reducers/debug-reducer.d.ts

@@ -0,0 +1,10 @@
+import type { OxeEvent } from '../events/envelope';
+import type { RunState } from './run-state-reducer';
+export interface ReplayStep {
+    index: number;
+    event: OxeEvent;
+    state: RunState;
+}
+export declare function stepReplay(events: OxeEvent[]): Generator<ReplayStep>;
+export declare function replayUntil(events: OxeEvent[], predicate: (step: ReplayStep) => boolean): ReplayStep | null;
+export declare function replaySlice(events: OxeEvent[], from: number, to: number): ReplayStep[];

package/lib/runtime/reducers/debug-reducer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepReplay = stepReplay;
+exports.replayUntil = replayUntil;
+exports.replaySlice = replaySlice;
+const run_state_reducer_1 = require("./run-state-reducer");
+function* stepReplay(events) {
+    let state = (0, run_state_reducer_1.createEmptyRunState)();
+    for (let i = 0; i < events.length; i++) {
+        state = (0, run_state_reducer_1.applyEventExported)(state, events[i]);
+        yield { index: i, event: events[i], state };
+    }
+}
+function replayUntil(events, predicate) {
+    for (const step of stepReplay(events)) {
+        if (predicate(step))
+            return step;
+    }
+    return null;
+}
+function replaySlice(events, from, to) {
+    const steps = [];
+    for (const step of stepReplay(events)) {
+        if (step.index >= from && step.index <= to)
+            steps.push(step);
+        if (step.index > to)
+            break;
+    }
+    return steps;
+}

package/lib/runtime/reducers/index.d.ts

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

package/lib/runtime/reducers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./run-state-reducer"), exports);
+__exportStar(require("./debug-reducer"), exports);

package/lib/runtime/reducers/run-state-reducer.d.ts

@@ -0,0 +1,20 @@
+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 declare function createEmptyRunState(): RunState;
+export declare function reduce(events: OxeEvent[]): RunState;
+export { applyEvent as applyEventExported };
+declare function applyEvent(state: RunState, event: OxeEvent): RunState;
+export declare function getWorkItemStatus(state: RunState, workItemId: string): WorkItem['status'] | null;
+export declare function getAttemptCount(state: RunState, workItemId: string): number;

package/lib/runtime/reducers/run-state-reducer.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyRunState = createEmptyRunState;
+exports.reduce = reduce;
+exports.applyEventExported = applyEvent;
+exports.getWorkItemStatus = getWorkItemStatus;
+exports.getAttemptCount = getAttemptCount;
+function createEmptyRunState() {
+    return {
+        run: null,
+        workItems: new Map(),
+        attempts: new Map(),
+        workspaces: new Map(),
+        completedWorkItems: new Set(),
+        failedWorkItems: new Set(),
+        blockedWorkItems: new Set(),
+    };
+}
+function reduce(events) {
+    return events.reduce(applyEvent, createEmptyRunState());
+}
+function applyEvent(state, event) {
+    switch (event.type) {
+        case 'RunStarted': {
+            const run = event.payload;
+            return { ...state, run };
+        }
+        case 'RunCompleted': {
+            if (!state.run)
+                return state;
+            const status = event.payload.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;
+                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_id: event.attempt_id,
+                work_item_id: event.work_item_id,
+                attempt_number: event.payload.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;
+            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;
+    }
+}
+function getWorkItemStatus(state, workItemId) {
+    return state.workItems.get(workItemId)?.status ?? null;
+}
+function getAttemptCount(state, workItemId) {
+    return state.attempts.get(workItemId)?.length ?? 0;
+}

package/lib/runtime/scheduler/index.d.ts

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

package/lib/runtime/scheduler/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./scheduler"), exports);

package/lib/runtime/scheduler/multi-agent-coordinator.d.ts

@@ -0,0 +1,34 @@
+import type { ExecutionGraph } from '../compiler/graph-compiler';
+import type { WorkspaceManager } from '../workspace/workspace-manager';
+import type { TaskExecutor, SchedulerContext } from './scheduler';
+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[];
+    }>;
+}
+export declare class MultiAgentCoordinator {
+    run(graph: ExecutionGraph, opts: CoordinationOptions): Promise<CoordinationResult>;
+}

package/lib/runtime/scheduler/multi-agent-coordinator.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAgentCoordinator = void 0;
+const bus_1 = require("../events/bus");
+const scheduler_1 = require("./scheduler");
+// ─── Parallel mode ───────────────────────────────────────────────────────────
+// Tasks are partitioned across agents. Each agent runs its own Scheduler
+// on a sub-graph. Results are merged.
+async function runParallel(graph, opts) {
+    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);
+        });
+    }
+    (0, bus_1.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 = {
+            projectRoot,
+            sessionId,
+            runId: `${runId}-agent${idx}`,
+            executor: agent.executor,
+            workspaceManager: agent.workspaceManager,
+            onEvent: opts.onEvent,
+        };
+        const scheduler = new scheduler_1.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);
+    (0, bus_1.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, opts) {
+    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;
+    (0, bus_1.appendEvent)(projectRoot, sessionId, {
+        type: 'RunStarted',
+        run_id: runId,
+        payload: { mode: 'competitive' },
+    });
+    const completed = [];
+    const failed = [];
+    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;
+    }
+    (0, bus_1.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, node, agentA, agentB, opts) {
+    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,
+    });
+    (0, bus_1.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', evidence: [], output: String(e),
+        })),
+        agentB.executor.execute(node, allocB, runId, 1).catch((e) => ({
+            success: false, failure_class: 'env', 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) {
+        (0, bus_1.appendEvent)(projectRoot, sessionId, { type: 'WorkItemCompleted', run_id: runId, work_item_id: nodeId, payload: { mode: 'competitive' } });
+    }
+    else {
+        (0, bus_1.appendEvent)(projectRoot, sessionId, { type: 'WorkItemBlocked', run_id: runId, work_item_id: nodeId, payload: { mode: 'competitive', failure_class: winner.failure_class } });
+    }
+    return winner;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+class MultiAgentCoordinator {
+    async run(graph, opts) {
+        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}`);
+        }
+    }
+}
+exports.MultiAgentCoordinator = MultiAgentCoordinator;
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function subGraphFor(graph, nodeIds) {
+    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 },
+    };
+}

package/lib/runtime/scheduler/scheduler.d.ts

@@ -0,0 +1,39 @@
+import type { OxeEvent } from '../events/envelope';
+import type { ExecutionGraph, GraphNode } from '../compiler/graph-compiler';
+import type { WorkspaceManager } from '../workspace/workspace-manager';
+import type { WorkspaceLease } from '../models/workspace';
+export interface TaskResult {
+    success: boolean;
+    failure_class: 'env' | 'policy' | 'test' | 'timeout' | null;
+    evidence: string[];
+    output: string;
+}
+export interface TaskExecutor {
+    execute(node: GraphNode, lease: WorkspaceLease, runId: string, attemptNumber: number): Promise<TaskResult>;
+}
+export interface SchedulerContext {
+    projectRoot: string;
+    sessionId: string | null;
+    runId: string;
+    executor: TaskExecutor;
+    workspaceManager: WorkspaceManager;
+    onEvent?: (event: OxeEvent) => void;
+}
+export interface RunResult {
+    run_id: string;
+    status: 'completed' | 'failed' | 'cancelled';
+    completed: string[];
+    failed: string[];
+    blocked: string[];
+}
+export declare class Scheduler {
+    private cancelled;
+    private paused;
+    run(graph: ExecutionGraph, ctx: SchedulerContext): Promise<RunResult>;
+    private runWave;
+    private runNode;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    private emit;
+}