oxe-cc 0.9.3 → 1.2.1

package/lib/runtime/scheduler/scheduler.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const bus_1 = require("../events/bus");
+const run_journal_1 = require("./run-journal");
+class Scheduler {
+    constructor() {
+        this.cancelled = false;
+        this.paused = false;
+        this.journal = null;
+        this.ctx = null;
+    }
+    async run(graph, ctx) {
+        this.cancelled = false;
+        this.paused = false;
+        this.ctx = ctx;
+        const status = new Map();
+        for (const id of graph.nodes.keys())
+            status.set(id, 'pending');
+        const completed = [];
+        const failed = [];
+        const blocked = [];
+        this.journal = (0, run_journal_1.createJournal)(ctx.runId);
+        (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+        this.emit(ctx, { type: 'RunStarted', payload: { run_id: ctx.runId } });
+        for (const wave of graph.waves) {
+            if (this.cancelled)
+                break;
+            // Respect pause: persist journal and return paused result
+            if (this.paused) {
+                this.journal.scheduler_state = 'paused';
+                this.journal.paused_at = new Date().toISOString();
+                this.journal.completed_work_items = completed.slice();
+                this.journal.failed_work_items = failed.slice();
+                this.journal.blocked_work_items = blocked.slice();
+                this.journal.partial_result = { run_id: ctx.runId, completed, failed, blocked };
+                (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+                return { run_id: ctx.runId, status: 'paused', completed, failed, blocked };
+            }
+            const waveFailed = await this.runWave(wave.node_ids, graph, ctx, status, completed, failed, blocked);
+            // Sync journal after each wave
+            this.journal.completed_work_items = completed.slice();
+            this.journal.failed_work_items = failed.slice();
+            this.journal.blocked_work_items = blocked.slice();
+            (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+            if (waveFailed)
+                break;
+        }
+        // Any remaining pending nodes become blocked
+        for (const [id, s] of status) {
+            if (s === 'pending') {
+                status.set(id, 'blocked');
+                blocked.push(id);
+                this.emit(ctx, {
+                    type: 'WorkItemBlocked',
+                    work_item_id: id,
+                    payload: { reason: 'upstream_wave_failed' },
+                });
+            }
+        }
+        const finalStatus = this.cancelled
+            ? 'cancelled'
+            : failed.length > 0
+                ? 'failed'
+                : 'completed';
+        this.emit(ctx, {
+            type: 'RunCompleted',
+            payload: { run_id: ctx.runId, status: finalStatus },
+        });
+        this.journal.scheduler_state = this.cancelled ? 'cancelled' : 'completed';
+        this.journal.completed_work_items = completed.slice();
+        this.journal.failed_work_items = failed.slice();
+        this.journal.blocked_work_items = blocked.slice();
+        (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+        return { run_id: ctx.runId, status: finalStatus, completed, failed, blocked };
+    }
+    /**
+     * Recover a previously paused run by loading its journal and re-running
+     * only the work items that haven't completed yet.
+     */
+    async recover(runId, ctx, graph) {
+        const journal = (0, run_journal_1.loadJournal)(ctx.projectRoot, runId);
+        if (!journal || journal.scheduler_state !== 'paused')
+            return null;
+        // Restore state from journal
+        this.cancelled = false;
+        this.paused = false;
+        this.ctx = ctx;
+        this.journal = { ...journal, scheduler_state: 'running', paused_at: null };
+        const restoredCompleted = new Set(journal.completed_work_items);
+        const restoredFailed = new Set(journal.failed_work_items);
+        const restoredBlocked = new Set(journal.blocked_work_items);
+        const status = new Map();
+        for (const id of graph.nodes.keys()) {
+            if (restoredCompleted.has(id))
+                status.set(id, 'completed');
+            else if (restoredFailed.has(id))
+                status.set(id, 'failed');
+            else if (restoredBlocked.has(id))
+                status.set(id, 'blocked');
+            else
+                status.set(id, 'pending');
+        }
+        const completed = [...restoredCompleted];
+        const failed = [...restoredFailed];
+        const blocked = [...restoredBlocked];
+        (0, run_journal_1.saveJournal)(ctx.projectRoot, runId, this.journal);
+        this.emit(ctx, { type: 'RunStarted', payload: { run_id: ctx.runId, recovered: true } });
+        for (const wave of graph.waves) {
+            if (this.cancelled)
+                break;
+            if (this.paused) {
+                this.journal.scheduler_state = 'paused';
+                this.journal.paused_at = new Date().toISOString();
+                this.journal.completed_work_items = completed.slice();
+                this.journal.failed_work_items = failed.slice();
+                this.journal.blocked_work_items = blocked.slice();
+                this.journal.partial_result = { run_id: ctx.runId, completed, failed, blocked };
+                (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+                return { run_id: ctx.runId, status: 'paused', completed, failed, blocked };
+            }
+            // Skip waves fully completed
+            const allDone = wave.node_ids.every((id) => restoredCompleted.has(id) || restoredFailed.has(id) || restoredBlocked.has(id));
+            if (allDone)
+                continue;
+            const waveFailed = await this.runWave(wave.node_ids, graph, ctx, status, completed, failed, blocked);
+            this.journal.completed_work_items = completed.slice();
+            this.journal.failed_work_items = failed.slice();
+            this.journal.blocked_work_items = blocked.slice();
+            (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+            if (waveFailed)
+                break;
+        }
+        for (const [id, s] of status) {
+            if (s === 'pending') {
+                status.set(id, 'blocked');
+                blocked.push(id);
+                this.emit(ctx, {
+                    type: 'WorkItemBlocked',
+                    work_item_id: id,
+                    payload: { reason: 'upstream_wave_failed' },
+                });
+            }
+        }
+        const finalStatus = this.cancelled
+            ? 'cancelled'
+            : failed.length > 0
+                ? 'failed'
+                : 'completed';
+        this.emit(ctx, {
+            type: 'RunCompleted',
+            payload: { run_id: ctx.runId, status: finalStatus, recovered: true },
+        });
+        this.journal.scheduler_state = this.cancelled ? 'cancelled' : 'completed';
+        this.journal.completed_work_items = completed.slice();
+        this.journal.failed_work_items = failed.slice();
+        this.journal.blocked_work_items = blocked.slice();
+        (0, run_journal_1.saveJournal)(ctx.projectRoot, ctx.runId, this.journal);
+        (0, run_journal_1.deleteJournal)(ctx.projectRoot, ctx.runId);
+        return { run_id: ctx.runId, status: finalStatus, completed, failed, blocked };
+    }
+    async runWave(nodeIds, graph, ctx, status, completed, failed, blocked) {
+        const eligible = [];
+        const depsNotMet = [];
+        for (const id of nodeIds) {
+            if (status.get(id) === 'completed')
+                continue; // already done in recovery
+            const node = graph.nodes.get(id);
+            const depsMet = node.depends_on.every((dep) => status.get(dep) === 'completed');
+            if (depsMet) {
+                eligible.push(id);
+            }
+            else {
+                depsNotMet.push(id);
+            }
+        }
+        for (const id of depsNotMet) {
+            status.set(id, 'blocked');
+            blocked.push(id);
+            this.emit(ctx, {
+                type: 'WorkItemBlocked',
+                work_item_id: id,
+                payload: { reason: 'dependency_not_met' },
+            });
+        }
+        const readOnly = eligible.filter((id) => {
+            const node = graph.nodes.get(id);
+            return node.mutation_scope.length === 0;
+        });
+        const mutations = eligible.filter((id) => !readOnly.includes(id));
+        if (readOnly.length > 0) {
+            await Promise.all(readOnly.map((id) => this.runNode(id, graph, ctx, status, completed, failed)));
+        }
+        for (const id of mutations) {
+            if (this.cancelled)
+                break;
+            await this.runNode(id, graph, ctx, status, completed, failed);
+        }
+        return failed.length > 0;
+    }
+    async runNode(nodeId, graph, ctx, status, completed, failed) {
+        const node = graph.nodes.get(nodeId);
+        status.set(nodeId, 'running');
+        this.emit(ctx, {
+            type: 'WorkItemReady',
+            work_item_id: nodeId,
+            payload: { title: node.title, wave: node.wave },
+        });
+        let lease = null;
+        let lastResult = null;
+        const maxAttempts = node.policy.max_retries + 1;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const attemptId = `${nodeId}-a${attempt}`;
+            this.emit(ctx, {
+                type: 'AttemptStarted',
+                work_item_id: nodeId,
+                attempt_id: attemptId,
+                payload: { attempt_number: attempt },
+            });
+            try {
+                const wsReq = {
+                    work_item_id: nodeId,
+                    attempt_number: attempt,
+                    strategy: node.workspace_strategy,
+                    mutation_scope: node.mutation_scope,
+                };
+                lease = await ctx.workspaceManager.allocate(wsReq);
+                this.emit(ctx, {
+                    type: 'WorkspaceAllocated',
+                    work_item_id: nodeId,
+                    attempt_id: attemptId,
+                    payload: { workspace_id: lease.workspace_id, strategy: lease.strategy },
+                });
+                lastResult = await ctx.executor.execute(node, lease, ctx.runId, attempt);
+                if (lastResult.success) {
+                    this.emit(ctx, {
+                        type: 'WorkItemCompleted',
+                        work_item_id: nodeId,
+                        attempt_id: attemptId,
+                        payload: { attempt_number: attempt, evidence: lastResult.evidence },
+                    });
+                    status.set(nodeId, 'completed');
+                    completed.push(nodeId);
+                    return;
+                }
+                if (lastResult.failure_class === 'policy')
+                    break;
+                if (attempt < maxAttempts) {
+                    this.emit(ctx, {
+                        type: 'RetryScheduled',
+                        work_item_id: nodeId,
+                        payload: { next_attempt: attempt + 1, reason: lastResult.failure_class },
+                    });
+                }
+            }
+            catch (err) {
+                lastResult = {
+                    success: false,
+                    failure_class: 'env',
+                    evidence: [],
+                    output: String(err),
+                };
+                if (attempt < maxAttempts) {
+                    this.emit(ctx, {
+                        type: 'RetryScheduled',
+                        work_item_id: nodeId,
+                        payload: { next_attempt: attempt + 1, reason: 'env' },
+                    });
+                }
+            }
+            finally {
+                if (lease) {
+                    await ctx.workspaceManager.dispose(lease.workspace_id).catch(() => { });
+                    lease = null;
+                }
+            }
+        }
+        this.emit(ctx, {
+            type: 'WorkItemBlocked',
+            work_item_id: nodeId,
+            payload: { failure_class: lastResult?.failure_class ?? 'env', max_attempts: maxAttempts },
+        });
+        status.set(nodeId, 'failed');
+        failed.push(nodeId);
+    }
+    pause() {
+        this.paused = true;
+        if (this.journal && this.ctx) {
+            this.journal.scheduler_state = 'paused';
+            this.journal.paused_at = new Date().toISOString();
+            (0, run_journal_1.saveJournal)(this.ctx.projectRoot, this.ctx.runId, this.journal);
+        }
+    }
+    resume() {
+        this.paused = false;
+        if (this.journal && this.ctx) {
+            this.journal.scheduler_state = 'running';
+            this.journal.paused_at = null;
+            (0, run_journal_1.saveJournal)(this.ctx.projectRoot, this.ctx.runId, this.journal);
+        }
+    }
+    cancel() {
+        this.cancelled = true;
+        if (this.journal && this.ctx) {
+            this.journal.cancelled = true;
+            this.journal.scheduler_state = 'cancelled';
+            (0, run_journal_1.saveJournal)(this.ctx.projectRoot, this.ctx.runId, this.journal);
+        }
+    }
+    getJournal() {
+        return this.journal;
+    }
+    static loadJournal(projectRoot, runId) {
+        return (0, run_journal_1.loadJournal)(projectRoot, runId);
+    }
+    emit(ctx, input) {
+        const event = (0, bus_1.appendEvent)(ctx.projectRoot, ctx.sessionId, {
+            run_id: ctx.runId,
+            ...input,
+        });
+        ctx.onEvent?.(event);
+    }
+}
+exports.Scheduler = Scheduler;

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

@@ -0,0 +1,2 @@
+export * from './verification-compiler';
+export * from './verification-manifest';

package/lib/runtime/verification/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("./verification-compiler"), exports);
+__exportStar(require("./verification-manifest"), exports);

package/lib/runtime/verification/verification-compiler.d.ts

@@ -0,0 +1,56 @@
+import type { EvidenceType } from '../models/evidence';
+import type { VerificationStatus } from '../models/verification-result';
+export type CheckType = 'unit' | 'integration' | 'contract' | 'smoke' | 'policy' | 'security' | 'ux_snapshot' | 'performance_baseline' | 'custom';
+export interface AcceptanceCheck {
+    id: string;
+    type: CheckType;
+    command: string | null;
+    evidence_type_expected: EvidenceType;
+    acceptance_ref: string | null;
+    description: string;
+}
+export interface AcceptanceCheckSuite {
+    checks: AcceptanceCheck[];
+    compiled_at: string;
+    spec_hash: string;
+    plan_hash: string;
+}
+export interface CheckResult {
+    check_id: string;
+    acceptance_ref: string | null;
+    status: VerificationStatus;
+    stdout: string;
+    stderr: string;
+    exit_code: number | null;
+    duration_ms: number;
+    error: string | null;
+}
+interface Criterion {
+    id: string;
+    criterion: string;
+    howToVerify: string;
+}
+interface ParsedSpecLike {
+    objective: string | null;
+    criteria: Criterion[];
+}
+interface ParsedTaskLike {
+    id: string;
+    verifyCommand: string | null;
+    aceite: string[];
+}
+interface ParsedPlanLike {
+    tasks: ParsedTaskLike[];
+}
+export declare function compile(spec: ParsedSpecLike, plan: ParsedPlanLike): AcceptanceCheckSuite;
+export declare function runCheck(check: AcceptanceCheck, cwd: string, timeoutMs?: number): Promise<CheckResult>;
+export declare function runSuite(suite: AcceptanceCheckSuite, cwd: string, timeoutMs?: number): Promise<CheckResult[]>;
+export declare function summarizeSuite(results: CheckResult[]): {
+    total: number;
+    pass: number;
+    fail: number;
+    skip: number;
+    error: number;
+    allPassed: boolean;
+};
+export {};

package/lib/runtime/verification/verification-compiler.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.runCheck = runCheck;
+exports.runSuite = runSuite;
+exports.summarizeSuite = summarizeSuite;
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
+function inferCheckType(howToVerify) {
+    const v = howToVerify.toLowerCase();
+    if (v.includes('npm test') || v.includes('jest') || v.includes('vitest') || v.includes('node --test'))
+        return 'unit';
+    if (v.includes('postman') || v.includes('newman') || v.includes('integration'))
+        return 'integration';
+    if (v.includes('smoke') || v.includes('curl'))
+        return 'smoke';
+    if (v.includes('eslint') || v.includes('lint') || v.includes('oxe-policy'))
+        return 'policy';
+    if (v.includes('security') || v.includes('audit') || v.includes('trivy'))
+        return 'security';
+    return 'custom';
+}
+function inferEvidenceType(checkType) {
+    switch (checkType) {
+        case 'unit': return 'junit_xml';
+        case 'integration': return 'api_output';
+        case 'security': return 'security_report';
+        case 'policy': return 'log';
+        default: return 'stdout';
+    }
+}
+function compile(spec, plan) {
+    const checks = [];
+    const seenRefs = new Set();
+    // Generate checks from spec criteria
+    for (const criterion of spec.criteria) {
+        // Find the verify command from the task that references this criterion
+        const task = plan.tasks.find((t) => t.aceite.includes(criterion.id));
+        const command = task?.verifyCommand ?? null;
+        const type = inferCheckType(criterion.howToVerify);
+        checks.push({
+            id: `check-${criterion.id.toLowerCase()}`,
+            type,
+            command: command ?? (criterion.howToVerify.startsWith('#') ? null : criterion.howToVerify),
+            evidence_type_expected: inferEvidenceType(type),
+            acceptance_ref: criterion.id,
+            description: criterion.criterion,
+        });
+        seenRefs.add(criterion.id);
+    }
+    // Add checks for task verify commands not already covered
+    for (const task of plan.tasks) {
+        if (!task.verifyCommand)
+            continue;
+        const uncovered = task.aceite.filter((ref) => !seenRefs.has(ref));
+        if (uncovered.length === 0 && checks.some((c) => c.command === task.verifyCommand))
+            continue;
+        checks.push({
+            id: `check-task-${task.id.toLowerCase()}`,
+            type: inferCheckType(task.verifyCommand),
+            command: task.verifyCommand,
+            evidence_type_expected: 'stdout',
+            acceptance_ref: uncovered[0] ?? null,
+            description: `Verify command for task ${task.id}`,
+        });
+    }
+    return {
+        checks,
+        compiled_at: new Date().toISOString(),
+        spec_hash: hashObject(spec),
+        plan_hash: hashObject(plan),
+    };
+}
+async function runCheck(check, cwd, timeoutMs = 60000) {
+    if (!check.command) {
+        return {
+            check_id: check.id,
+            acceptance_ref: check.acceptance_ref,
+            status: 'skip',
+            stdout: '',
+            stderr: '',
+            exit_code: null,
+            duration_ms: 0,
+            error: null,
+        };
+    }
+    const start = Date.now();
+    try {
+        // Split command into program + args (simple split; no shell expansion)
+        const parts = check.command.split(/\s+/);
+        const prog = parts[0];
+        const args = parts.slice(1);
+        const result = (0, child_process_1.spawnSync)(prog, args, {
+            cwd,
+            encoding: 'utf8',
+            timeout: timeoutMs,
+            maxBuffer: 2 * 1024 * 1024,
+        });
+        const duration_ms = Date.now() - start;
+        const status = result.status === 0 ? 'pass' : 'fail';
+        return {
+            check_id: check.id,
+            acceptance_ref: check.acceptance_ref,
+            status,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? '',
+            exit_code: result.status ?? null,
+            duration_ms,
+            error: result.error ? String(result.error) : null,
+        };
+    }
+    catch (err) {
+        return {
+            check_id: check.id,
+            acceptance_ref: check.acceptance_ref,
+            status: 'error',
+            stdout: '',
+            stderr: '',
+            exit_code: null,
+            duration_ms: Date.now() - start,
+            error: String(err),
+        };
+    }
+}
+async function runSuite(suite, cwd, timeoutMs = 60000) {
+    const results = [];
+    for (const check of suite.checks) {
+        results.push(await runCheck(check, cwd, timeoutMs));
+    }
+    return results;
+}
+function summarizeSuite(results) {
+    const counts = { total: results.length, pass: 0, fail: 0, skip: 0, error: 0 };
+    for (const r of results)
+        counts[r.status]++;
+    return { ...counts, allPassed: counts.fail === 0 && counts.error === 0 };
+}
+function hashObject(obj) {
+    return crypto_1.default
+        .createHash('sha256')
+        .update(JSON.stringify(obj))
+        .digest('hex')
+        .slice(0, 12);
+}

package/lib/runtime/verification/verification-manifest.d.ts

@@ -0,0 +1,58 @@
+import type { VerificationStatus } from '../models/verification-result';
+import type { CheckResult } from './verification-compiler';
+export type VerificationProfile = 'quick' | 'standard' | 'critical';
+export type FailureClass = 'deterministic' | 'flaky' | 'timeout' | 'env_setup' | 'policy_failure' | 'evidence_missing';
+export type VerificationGranularity = 'work_item' | 'wave' | 'run';
+export interface ManifestCheck {
+    check_id: string;
+    acceptance_ref: string | null;
+    status: VerificationStatus;
+    failure_class: FailureClass | null;
+    evidence_refs: string[];
+    duration_ms: number;
+}
+export interface VerificationManifest {
+    manifest_id: string;
+    run_id: string;
+    work_item_id: string | null;
+    wave: number | null;
+    granularity: VerificationGranularity;
+    profile: VerificationProfile;
+    compiled_at: string;
+    checks: ManifestCheck[];
+    summary: {
+        total: number;
+        pass: number;
+        fail: number;
+        skip: number;
+        error: number;
+        all_passed: boolean;
+    };
+}
+export interface ResidualRisk {
+    risk_id: string;
+    work_item_id: string | null;
+    check_id: string | null;
+    failure_class: FailureClass;
+    description: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    mitigation: string | null;
+}
+export interface ResidualRiskLedger {
+    run_id: string;
+    generated_at: string;
+    risks: ResidualRisk[];
+}
+export declare function classifyFailure(result: CheckResult): FailureClass | null;
+export declare function buildManifest(runId: string, results: CheckResult[], options?: {
+    workItemId?: string;
+    wave?: number;
+    granularity?: VerificationGranularity;
+    profile?: VerificationProfile;
+    evidenceRefs?: Map<string, string[]>;
+}): VerificationManifest;
+export declare function buildRiskLedger(runId: string, manifest: VerificationManifest): ResidualRiskLedger;
+export declare function saveManifest(projectRoot: string, runId: string, manifest: VerificationManifest): void;
+export declare function loadManifest(projectRoot: string, runId: string): VerificationManifest | null;
+export declare function saveRiskLedger(projectRoot: string, runId: string, ledger: ResidualRiskLedger): void;
+export declare function loadRiskLedger(projectRoot: string, runId: string): ResidualRiskLedger | null;