oxe-cc 0.9.3 → 1.2.1

package/lib/runtime/plugins/plugin-registry.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginRegistry = void 0;
+exports.globalRegistry = globalRegistry;
+exports.resetGlobalRegistry = resetGlobalRegistry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const plugin_manifest_1 = require("./plugin-manifest");
+class PluginRegistry {
+    constructor() {
+        this.plugins = [];
+    }
+    register(plugin) {
+        if (this.plugins.some((p) => p.name === plugin.name)) {
+            throw new Error(`Plugin "${plugin.name}" is already registered`);
+        }
+        const validation = (0, plugin_manifest_1.validatePlugin)(plugin);
+        if (!validation.valid && validation.errors.length > 0) {
+            throw new Error(`Plugin "${plugin.name}" failed validation: ${validation.errors.join('; ')}`);
+        }
+        this.plugins.push(plugin);
+    }
+    unregister(name) {
+        this.plugins = this.plugins.filter((p) => p.name !== name);
+    }
+    loadFromDirectory(dir) {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const loaded = [];
+        for (const file of fs_1.default.readdirSync(dir)) {
+            if (!file.endsWith('.cjs') && !file.endsWith('.js'))
+                continue;
+            const fullPath = path_1.default.resolve(dir, file);
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = require(fullPath);
+                const plugin = 'default' in mod && mod.default ? mod.default : mod;
+                if (plugin && plugin.name) {
+                    this.register(plugin);
+                    loaded.push(plugin.name);
+                }
+            }
+            catch {
+                // skip invalid plugin files
+            }
+        }
+        return loaded;
+    }
+    toolProviderFor(actionType) {
+        for (const plugin of this.plugins) {
+            const provider = plugin.toolProviders?.find((p) => p.supports(actionType));
+            if (provider)
+                return provider;
+        }
+        return null;
+    }
+    workspaceProviderFor(strategy) {
+        for (const plugin of this.plugins) {
+            const provider = plugin.workspaceProviders?.find((p) => p.supportsStrategy(strategy));
+            if (provider)
+                return provider;
+        }
+        return null;
+    }
+    verifierProviderFor(checkType) {
+        for (const plugin of this.plugins) {
+            const provider = plugin.verifierProviders?.find((p) => p.supports(checkType));
+            if (provider)
+                return provider;
+        }
+        return null;
+    }
+    contextProviderFor(name) {
+        for (const plugin of this.plugins) {
+            const provider = plugin.contextProviders?.find((p) => p.name === name);
+            if (provider)
+                return provider;
+        }
+        return null;
+    }
+    allContextProviders() {
+        return this.plugins.flatMap((p) => p.contextProviders ?? []);
+    }
+    allToolProviders() {
+        return this.plugins.flatMap((p) => p.toolProviders ?? []);
+    }
+    async runHook(hookName, ctx) {
+        for (const plugin of this.plugins) {
+            const hook = plugin.hooks?.[hookName];
+            if (hook)
+                await hook(ctx);
+        }
+    }
+    list() {
+        return this.plugins.map((p) => ({
+            name: p.name,
+            version: p.version,
+            providers: [
+                ...(p.toolProviders?.map((tp) => `tool:${tp.name}`) ?? []),
+                ...(p.workspaceProviders?.map((wp) => `workspace:${wp.name}`) ?? []),
+                ...(p.verifierProviders?.map((vp) => `verifier:${vp.name}`) ?? []),
+                ...(p.contextProviders?.map((cp) => `context:${cp.name}`) ?? []),
+            ],
+        }));
+    }
+}
+exports.PluginRegistry = PluginRegistry;
+let _globalRegistry = null;
+function globalRegistry() {
+    if (!_globalRegistry)
+        _globalRegistry = new PluginRegistry();
+    return _globalRegistry;
+}
+function resetGlobalRegistry() {
+    _globalRegistry = null;
+}

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

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

package/lib/runtime/policy/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("./policy-engine"), exports);

package/lib/runtime/policy/policy-engine.d.ts

@@ -0,0 +1,67 @@
+export type PolicyAction = 'allow' | 'deny' | 'require_human_gate';
+export type SideEffectClass = 'read_fs' | 'write_fs' | 'spawn_process' | 'network_call' | 'git_mutation' | 'db_change' | 'secret_access' | 'infra_operation';
+export type AutonomyTier = 'L0' | 'L1' | 'L2' | 'L3';
+export interface PolicyWhenClause {
+    tool?: string;
+    env?: string;
+    kind?: string;
+    side_effect_class?: SideEffectClass;
+    autonomy_tier?: AutonomyTier;
+}
+export interface PolicyAssertClause {
+    diff_within_scope?: boolean;
+}
+export interface NodePolicyConfig {
+    max_retries: number;
+    mutation_budget?: number;
+    autonomy_tier?: AutonomyTier;
+    allowed_side_effects?: SideEffectClass[];
+}
+export interface EnvironmentGuardrail {
+    protected_paths: string[];
+    protected_branches: string[];
+    require_human_gate_on: SideEffectClass[];
+}
+export interface PolicyRule {
+    id: string;
+    when: PolicyWhenClause;
+    assert?: PolicyAssertClause;
+    action: PolicyAction;
+}
+export interface PolicyContext {
+    tool: string;
+    env?: string;
+    kind?: string;
+    mutation_scope?: string[];
+    affected_paths?: string[];
+    side_effect_class?: SideEffectClass;
+    autonomy_tier?: AutonomyTier;
+    mutation_count?: number;
+    node_policy?: NodePolicyConfig;
+}
+export interface PolicyDecision {
+    allowed: boolean;
+    gate_required: boolean;
+    reason: string;
+    rule_id: string | null;
+}
+export declare class PolicyEngine {
+    private readonly rules;
+    private readonly guardrail;
+    constructor(rules?: PolicyRule[], guardrail?: EnvironmentGuardrail);
+    evaluate(ctx: PolicyContext): PolicyDecision;
+    private checkGuardrails;
+    private checkAutonomyTier;
+    private checkMutationBudget;
+    private matches;
+    private checkAssert;
+    withRule(rule: PolicyRule): PolicyEngine;
+    withGuardrail(guardrail: EnvironmentGuardrail): PolicyEngine;
+    getGuardrail(): EnvironmentGuardrail;
+    static fromConfig(config: {
+        policies?: PolicyRule[];
+        guardrail?: EnvironmentGuardrail;
+    }): PolicyEngine;
+    static fromConfigFile(configPath: string): PolicyEngine;
+    static defaultGuardrail(): EnvironmentGuardrail;
+}

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyEngine = void 0;
+const ALLOW_ALL = {
+    allowed: true,
+    gate_required: false,
+    reason: 'no matching policy — default allow',
+    rule_id: null,
+};
+const DEFAULT_GUARDRAIL = {
+    protected_paths: ['.oxe/config.json', '.env', 'package.json'],
+    protected_branches: ['main', 'master', 'production', 'release'],
+    require_human_gate_on: ['infra_operation', 'db_change', 'secret_access'],
+};
+// Autonomy tier → max side effect class allowed without a gate
+const TIER_SIDE_EFFECT_MAP = {
+    L0: ['read_fs'],
+    L1: ['read_fs', 'write_fs', 'spawn_process'],
+    L2: ['read_fs', 'write_fs', 'spawn_process', 'network_call', 'git_mutation'],
+    L3: ['read_fs', 'write_fs', 'spawn_process', 'network_call', 'git_mutation', 'db_change', 'secret_access', 'infra_operation'],
+};
+class PolicyEngine {
+    constructor(rules = [], guardrail = DEFAULT_GUARDRAIL) {
+        this.rules = rules;
+        this.guardrail = guardrail;
+    }
+    evaluate(ctx) {
+        // Check autonomy tier first — a denial takes priority over guardrail gates
+        const tierDecision = this.checkAutonomyTier(ctx);
+        if (tierDecision)
+            return tierDecision;
+        // Check environment guardrails (may require gate even when tier permits)
+        const guardrailDecision = this.checkGuardrails(ctx);
+        if (guardrailDecision)
+            return guardrailDecision;
+        // Check mutation budget
+        const budgetDecision = this.checkMutationBudget(ctx);
+        if (budgetDecision)
+            return budgetDecision;
+        // Evaluate rules (first match wins)
+        for (const rule of this.rules) {
+            if (!this.matches(rule.when, ctx))
+                continue;
+            if (rule.assert) {
+                const assertFailed = this.checkAssert(rule.assert, ctx);
+                if (assertFailed) {
+                    return {
+                        allowed: false,
+                        gate_required: false,
+                        reason: `Assert failed for rule ${rule.id}: ${assertFailed}`,
+                        rule_id: rule.id,
+                    };
+                }
+            }
+            switch (rule.action) {
+                case 'allow':
+                    return { allowed: true, gate_required: false, reason: `Allowed by rule ${rule.id}`, rule_id: rule.id };
+                case 'deny':
+                    return { allowed: false, gate_required: false, reason: `Denied by rule ${rule.id}`, rule_id: rule.id };
+                case 'require_human_gate':
+                    return { allowed: true, gate_required: true, reason: `Gate required by rule ${rule.id}`, rule_id: rule.id };
+            }
+        }
+        return ALLOW_ALL;
+    }
+    checkGuardrails(ctx) {
+        // Protected path check
+        const affected = ctx.affected_paths ?? [];
+        for (const p of affected) {
+            if (this.guardrail.protected_paths.some((pp) => p === pp || p.startsWith(pp + '/'))) {
+                return {
+                    allowed: true,
+                    gate_required: true,
+                    reason: `Protected path affected: ${p}`,
+                    rule_id: '__guardrail_path',
+                };
+            }
+        }
+        // Side effect class requiring gate
+        if (ctx.side_effect_class && this.guardrail.require_human_gate_on.includes(ctx.side_effect_class)) {
+            return {
+                allowed: true,
+                gate_required: true,
+                reason: `Side effect class '${ctx.side_effect_class}' requires human gate`,
+                rule_id: '__guardrail_side_effect',
+            };
+        }
+        return null;
+    }
+    checkAutonomyTier(ctx) {
+        if (!ctx.autonomy_tier || !ctx.side_effect_class)
+            return null;
+        const allowed = TIER_SIDE_EFFECT_MAP[ctx.autonomy_tier] ?? [];
+        if (!allowed.includes(ctx.side_effect_class)) {
+            return {
+                allowed: false,
+                gate_required: false,
+                reason: `Autonomy tier ${ctx.autonomy_tier} does not permit side effect '${ctx.side_effect_class}'`,
+                rule_id: '__autonomy_tier',
+            };
+        }
+        return null;
+    }
+    checkMutationBudget(ctx) {
+        const budget = ctx.node_policy?.mutation_budget;
+        if (budget === undefined || budget === null)
+            return null;
+        const count = ctx.mutation_count ?? 0;
+        if (count >= budget) {
+            return {
+                allowed: false,
+                gate_required: false,
+                reason: `Mutation budget exhausted: ${count}/${budget}`,
+                rule_id: '__mutation_budget',
+            };
+        }
+        return null;
+    }
+    matches(when, ctx) {
+        if (when.tool && when.tool !== ctx.tool)
+            return false;
+        if (when.env && when.env !== ctx.env)
+            return false;
+        if (when.kind && when.kind !== ctx.kind)
+            return false;
+        if (when.side_effect_class && when.side_effect_class !== ctx.side_effect_class)
+            return false;
+        if (when.autonomy_tier && when.autonomy_tier !== ctx.autonomy_tier)
+            return false;
+        return true;
+    }
+    checkAssert(assert, ctx) {
+        if (assert.diff_within_scope === true) {
+            const scope = ctx.mutation_scope ?? [];
+            const affected = ctx.affected_paths ?? [];
+            if (scope.length === 0)
+                return null;
+            const outsideScope = affected.filter((p) => !scope.some((s) => p.startsWith(s) || s.startsWith(p)));
+            if (outsideScope.length > 0) {
+                return `paths outside mutation scope: ${outsideScope.join(', ')}`;
+            }
+        }
+        return null;
+    }
+    withRule(rule) {
+        return new PolicyEngine([...this.rules, rule], this.guardrail);
+    }
+    withGuardrail(guardrail) {
+        return new PolicyEngine(this.rules, guardrail);
+    }
+    getGuardrail() {
+        return this.guardrail;
+    }
+    static fromConfig(config) {
+        return new PolicyEngine(config.policies ?? [], config.guardrail ?? DEFAULT_GUARDRAIL);
+    }
+    static fromConfigFile(configPath) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const cfg = require(configPath);
+            return PolicyEngine.fromConfig(cfg);
+        }
+        catch {
+            return new PolicyEngine();
+        }
+    }
+    static defaultGuardrail() {
+        return { ...DEFAULT_GUARDRAIL };
+    }
+}
+exports.PolicyEngine = PolicyEngine;

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

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

package/lib/runtime/projection/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("./projection-engine"), exports);

package/lib/runtime/projection/projection-engine.d.ts

@@ -0,0 +1,11 @@
+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';
+export declare class ProjectionEngine {
+    projectPlan(state: RunState, graph: ExecutionGraph): string;
+    projectVerify(state: RunState, results: VerificationResult[], checkResults?: CheckResult[]): string;
+    projectState(state: RunState): string;
+    projectRunSummary(state: RunState): string;
+    projectPRSummary(state: RunState, graph: ExecutionGraph): string;
+}

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';