oxe-cc 0.9.3 → 1.2.1

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAgentCoordinator = void 0;
+const bus_1 = require("../events/bus");
+const scheduler_1 = require("./scheduler");
+const agent_roles_1 = require("./agent-roles");
+// ─── 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;
+}
+// ─── Cooperative mode ────────────────────────────────────────────────────────
+// planner (agent[0]) does a dry-run to collect context, then hands off to
+// executor (agent[1]) which performs the real run. Handoffs are recorded.
+async function runCooperative(graph, opts) {
+    if (opts.agents.length < 2) {
+        throw new Error('Cooperative mode requires at least 2 agents');
+    }
+    const [planner, executor] = opts.agents;
+    const { projectRoot, sessionId, runId } = opts;
+    const handoffs = [];
+    (0, bus_1.appendEvent)(projectRoot, sessionId, {
+        type: 'RunStarted',
+        run_id: runId,
+        payload: { mode: 'cooperative', planner: planner.id, executor: executor.id },
+    });
+    const completed = [];
+    const failed = [];
+    for (const wave of graph.waves) {
+        for (const nodeId of wave.node_ids) {
+            const node = graph.nodes.get(nodeId);
+            // Phase 1: planner allocates workspace + signals readiness (no output used)
+            const planAlloc = await planner.workspaceManager.allocate({
+                work_item_id: nodeId,
+                attempt_number: 1,
+                strategy: node.workspace_strategy,
+                mutation_scope: node.mutation_scope,
+            });
+            await planner.workspaceManager.dispose(planAlloc.workspace_id).catch(() => { });
+            const handoff = (0, agent_roles_1.buildHandoff)({
+                from_agent_id: planner.id,
+                to_agent_id: executor.id,
+                from_role: 'planner',
+                to_role: 'executor',
+                work_item_id: nodeId,
+                context_pack_ref: null,
+            });
+            handoffs.push(handoff);
+            (0, bus_1.appendEvent)(projectRoot, sessionId, {
+                type: 'AttemptStarted',
+                run_id: runId,
+                work_item_id: nodeId,
+                payload: { mode: 'cooperative', handoff_id: handoff.handoff_id },
+            });
+            // Phase 2: executor performs the real task
+            const execAlloc = await executor.workspaceManager.allocate({
+                work_item_id: nodeId,
+                attempt_number: 1,
+                strategy: node.workspace_strategy,
+                mutation_scope: node.mutation_scope,
+            });
+            let result;
+            try {
+                result = await executor.executor.execute(node, execAlloc, runId, 1);
+            }
+            catch (e) {
+                result = { success: false, failure_class: 'env', evidence: [], output: String(e) };
+            }
+            await executor.workspaceManager.dispose(execAlloc.workspace_id).catch(() => { });
+            if (result.success) {
+                completed.push(nodeId);
+                (0, bus_1.appendEvent)(projectRoot, sessionId, { type: 'WorkItemCompleted', run_id: runId, work_item_id: nodeId, payload: { mode: 'cooperative' } });
+            }
+            else {
+                failed.push(nodeId);
+                (0, bus_1.appendEvent)(projectRoot, sessionId, { type: 'WorkItemBlocked', run_id: runId, work_item_id: nodeId, payload: { mode: 'cooperative', failure_class: result.failure_class } });
+                break;
+            }
+        }
+        if (failed.length > 0)
+            break;
+    }
+    (0, bus_1.appendEvent)(projectRoot, sessionId, {
+        type: 'RunCompleted',
+        run_id: runId,
+        payload: { mode: 'cooperative', completed: completed.length, failed: failed.length },
+    });
+    return {
+        mode: 'cooperative',
+        run_id: runId,
+        completed,
+        failed,
+        blocked: [],
+        agent_results: [
+            { agent_id: planner.id, completed: [], failed: [] },
+            { agent_id: executor.id, completed, failed },
+        ],
+        handoffs,
+    };
+}
+// ─── 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': return runCooperative(graph, opts);
+            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/run-journal.d.ts

@@ -0,0 +1,18 @@
+import type { RunResult } from './scheduler';
+export interface RunJournal {
+    run_id: string;
+    paused_at: string | null;
+    cancelled: boolean;
+    eligible_work_items: string[];
+    completed_work_items: string[];
+    failed_work_items: string[];
+    blocked_work_items: string[];
+    pending_gates: string[];
+    replay_cursor: string | null;
+    scheduler_state: 'running' | 'paused' | 'cancelled' | 'completed';
+    partial_result: Omit<RunResult, 'status'> | null;
+}
+export declare function saveJournal(projectRoot: string, runId: string, journal: RunJournal): void;
+export declare function loadJournal(projectRoot: string, runId: string): RunJournal | null;
+export declare function deleteJournal(projectRoot: string, runId: string): void;
+export declare function createJournal(runId: string): RunJournal;

package/lib/runtime/scheduler/run-journal.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveJournal = saveJournal;
+exports.loadJournal = loadJournal;
+exports.deleteJournal = deleteJournal;
+exports.createJournal = createJournal;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function journalPath(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'journal.json');
+}
+function saveJournal(projectRoot, runId, journal) {
+    const p = journalPath(projectRoot, runId);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(journal, null, 2), 'utf8');
+}
+function loadJournal(projectRoot, runId) {
+    const p = journalPath(projectRoot, runId);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function deleteJournal(projectRoot, runId) {
+    const p = journalPath(projectRoot, runId);
+    try {
+        fs_1.default.unlinkSync(p);
+    }
+    catch {
+        // ignore if not found
+    }
+}
+function createJournal(runId) {
+    return {
+        run_id: runId,
+        paused_at: null,
+        cancelled: false,
+        eligible_work_items: [],
+        completed_work_items: [],
+        failed_work_items: [],
+        blocked_work_items: [],
+        pending_gates: [],
+        replay_cursor: null,
+        scheduler_state: 'running',
+        partial_result: null,
+    };
+}

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

@@ -0,0 +1,49 @@
+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';
+import type { RunJournal } from './run-journal';
+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' | 'paused';
+    completed: string[];
+    failed: string[];
+    blocked: string[];
+}
+export declare class Scheduler {
+    private cancelled;
+    private paused;
+    private journal;
+    private ctx;
+    run(graph: ExecutionGraph, ctx: SchedulerContext): Promise<RunResult>;
+    /**
+     * Recover a previously paused run by loading its journal and re-running
+     * only the work items that haven't completed yet.
+     */
+    recover(runId: string, ctx: SchedulerContext, graph: ExecutionGraph): Promise<RunResult | null>;
+    private runWave;
+    private runNode;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    getJournal(): RunJournal | null;
+    static loadJournal(projectRoot: string, runId: string): RunJournal | null;
+    private emit;
+}