oxe-cc 1.2.1 → 1.4.0

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

@@ -6,12 +6,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginRegistry = void 0;
 exports.globalRegistry = globalRegistry;
 exports.resetGlobalRegistry = resetGlobalRegistry;
+exports.registrySummary = registrySummary;
+exports.resolveCapabilityMatrix = resolveCapabilityMatrix;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const plugin_manifest_1 = require("./plugin-manifest");
+const capability_matrix_1 = require("./capability-matrix");
+const capability_adapter_1 = require("./capability-adapter");
 class PluginRegistry {
     constructor() {
         this.plugins = [];
+        this.loadErrors = [];
     }
     register(plugin) {
         if (this.plugins.some((p) => p.name === plugin.name)) {
@@ -43,8 +48,8 @@ class PluginRegistry {
                     loaded.push(plugin.name);
                 }
             }
-            catch {
-                // skip invalid plugin files
+            catch (error) {
+                this.loadErrors.push(`Plugin ${fullPath} falhou ao carregar: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         return loaded;
@@ -106,6 +111,72 @@ class PluginRegistry {
             ],
         }));
     }
+    registerProjectCapabilities(projectRoot) {
+        const loaded = [];
+        for (const plugin of (0, capability_adapter_1.loadCapabilityPlugins)(projectRoot)) {
+            try {
+                this.register(plugin);
+                loaded.push(plugin.name);
+            }
+            catch (error) {
+                this.loadErrors.push(`Capability plugin ${plugin.name} falhou ao registrar: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return loaded;
+    }
+    loadErrorsSnapshot() {
+        return [...this.loadErrors];
+    }
+    clearLoadErrors() {
+        this.loadErrors = [];
+    }
+    snapshot() {
+        return this.plugins.map((plugin) => ({
+            name: plugin.name,
+            version: plugin.version,
+            abi_version: plugin.abi_version,
+            toolProviders: (plugin.toolProviders ?? []).map((provider) => ({
+                name: provider.name,
+                kind: provider.kind,
+                idempotent: provider.idempotent,
+            })),
+            workspaceProviders: (plugin.workspaceProviders ?? []).map((provider) => ({
+                name: provider.name,
+            })),
+            verifierProviders: (plugin.verifierProviders ?? []).map((provider) => ({
+                name: provider.name,
+            })),
+            contextProviders: (plugin.contextProviders ?? []).map((provider) => ({
+                name: provider.name,
+            })),
+        }));
+    }
+    summary() {
+        const plugins = this.list();
+        const toolProviders = plugins.reduce((sum, plugin) => sum + plugin.providers.filter((provider) => provider.startsWith('tool:')).length, 0);
+        const workspaceProviders = plugins.reduce((sum, plugin) => sum + plugin.providers.filter((provider) => provider.startsWith('workspace:')).length, 0);
+        const verifierProviders = plugins.reduce((sum, plugin) => sum + plugin.providers.filter((provider) => provider.startsWith('verifier:')).length, 0);
+        const contextProviders = plugins.reduce((sum, plugin) => sum + plugin.providers.filter((provider) => provider.startsWith('context:')).length, 0);
+        const loadErrors = this.loadErrors.length;
+        return {
+            total_plugins: plugins.length,
+            tool_providers: toolProviders,
+            workspace_providers: workspaceProviders,
+            verifier_providers: verifierProviders,
+            context_providers: contextProviders,
+            load_errors: loadErrors,
+            pluginsCount: plugins.length,
+            toolProviders,
+            workspaceProviders,
+            verifierProviders,
+            contextProviders,
+            loadErrors,
+            plugins,
+        };
+    }
+    capabilityMatrix() {
+        return (0, capability_matrix_1.buildMatrix)(this);
+    }
 }
 exports.PluginRegistry = PluginRegistry;
 let _globalRegistry = null;
@@ -117,3 +188,9 @@ function globalRegistry() {
 function resetGlobalRegistry() {
     _globalRegistry = null;
 }
+function registrySummary(registry) {
+    return registry.summary();
+}
+function resolveCapabilityMatrix(registry) {
+    return registry.capabilityMatrix();
+}

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

@@ -40,10 +40,21 @@ export interface PolicyContext {
     node_policy?: NodePolicyConfig;
 }
 export interface PolicyDecision {
+    decision_id: string;
     allowed: boolean;
     gate_required: boolean;
     reason: string;
     rule_id: string | null;
+    timestamp: string;
+}
+export interface PersistedPolicyDecision extends PolicyDecision {
+    run_id: string;
+    work_item_id: string | null;
+    action: string;
+    actor: string;
+    override: boolean;
+    rationale: string | null;
+    context: PolicyContext;
 }
 export declare class PolicyEngine {
     private readonly rules;
@@ -65,3 +76,11 @@ export declare class PolicyEngine {
     static fromConfigFile(configPath: string): PolicyEngine;
     static defaultGuardrail(): EnvironmentGuardrail;
 }
+export declare function savePolicyDecision(projectRoot: string, decision: PersistedPolicyDecision): PersistedPolicyDecision;
+export declare function loadPolicyDecisions(projectRoot: string, runId: string): PersistedPolicyDecision[];
+export declare function summarizePolicyDecisions(decisions: PersistedPolicyDecision[]): {
+    total: number;
+    denied: number;
+    gated: number;
+    overridesWithoutRationale: number;
+};

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

@@ -1,11 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolicyEngine = void 0;
+exports.savePolicyDecision = savePolicyDecision;
+exports.loadPolicyDecisions = loadPolicyDecisions;
+exports.summarizePolicyDecisions = summarizePolicyDecisions;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const ALLOW_ALL = {
+    decision_id: '__default_allow',
     allowed: true,
     gate_required: false,
     reason: 'no matching policy — default allow',
     rule_id: null,
+    timestamp: new Date().toISOString(),
 };
 const DEFAULT_GUARDRAIL = {
     protected_paths: ['.oxe/config.json', '.env', 'package.json'],
@@ -45,23 +55,46 @@ class PolicyEngine {
                 const assertFailed = this.checkAssert(rule.assert, ctx);
                 if (assertFailed) {
                     return {
+                        decision_id: rule.id,
                         allowed: false,
                         gate_required: false,
                         reason: `Assert failed for rule ${rule.id}: ${assertFailed}`,
                         rule_id: rule.id,
+                        timestamp: new Date().toISOString(),
                     };
                 }
             }
             switch (rule.action) {
                 case 'allow':
-                    return { allowed: true, gate_required: false, reason: `Allowed by rule ${rule.id}`, rule_id: rule.id };
+                    return {
+                        decision_id: rule.id,
+                        allowed: true,
+                        gate_required: false,
+                        reason: `Allowed by rule ${rule.id}`,
+                        rule_id: rule.id,
+                        timestamp: new Date().toISOString(),
+                    };
                 case 'deny':
-                    return { allowed: false, gate_required: false, reason: `Denied by rule ${rule.id}`, rule_id: rule.id };
+                    return {
+                        decision_id: rule.id,
+                        allowed: false,
+                        gate_required: false,
+                        reason: `Denied by rule ${rule.id}`,
+                        rule_id: rule.id,
+                        timestamp: new Date().toISOString(),
+                    };
                 case 'require_human_gate':
-                    return { allowed: true, gate_required: true, reason: `Gate required by rule ${rule.id}`, rule_id: rule.id };
+                    return {
+                        decision_id: rule.id,
+                        allowed: true,
+                        gate_required: true,
+                        reason: `Gate required by rule ${rule.id}`,
+                        rule_id: rule.id,
+                        timestamp: new Date().toISOString(),
+                    };
             }
         }
-        return ALLOW_ALL;
+        return { ...ALLOW_ALL, timestamp: new Date().toISOString() };
     }
     checkGuardrails(ctx) {
         // Protected path check
@@ -69,20 +102,24 @@ class PolicyEngine {
         for (const p of affected) {
             if (this.guardrail.protected_paths.some((pp) => p === pp || p.startsWith(pp + '/'))) {
                 return {
+                    decision_id: '__guardrail_path',
                     allowed: true,
                     gate_required: true,
                     reason: `Protected path affected: ${p}`,
                     rule_id: '__guardrail_path',
+                    timestamp: new Date().toISOString(),
                 };
             }
         }
         // Side effect class requiring gate
         if (ctx.side_effect_class && this.guardrail.require_human_gate_on.includes(ctx.side_effect_class)) {
             return {
+                decision_id: '__guardrail_side_effect',
                 allowed: true,
                 gate_required: true,
                 reason: `Side effect class '${ctx.side_effect_class}' requires human gate`,
                 rule_id: '__guardrail_side_effect',
+                timestamp: new Date().toISOString(),
             };
         }
         return null;
@@ -93,10 +130,12 @@ class PolicyEngine {
         const allowed = TIER_SIDE_EFFECT_MAP[ctx.autonomy_tier] ?? [];
         if (!allowed.includes(ctx.side_effect_class)) {
             return {
+                decision_id: '__autonomy_tier',
                 allowed: false,
                 gate_required: false,
                 reason: `Autonomy tier ${ctx.autonomy_tier} does not permit side effect '${ctx.side_effect_class}'`,
                 rule_id: '__autonomy_tier',
+                timestamp: new Date().toISOString(),
             };
         }
         return null;
@@ -108,10 +147,12 @@ class PolicyEngine {
         const count = ctx.mutation_count ?? 0;
         if (count >= budget) {
             return {
+                decision_id: '__mutation_budget',
                 allowed: false,
                 gate_required: false,
                 reason: `Mutation budget exhausted: ${count}/${budget}`,
                 rule_id: '__mutation_budget',
+                timestamp: new Date().toISOString(),
             };
         }
         return null;
@@ -169,3 +210,34 @@ class PolicyEngine {
     }
 }
 exports.PolicyEngine = PolicyEngine;
+function policyDecisionPath(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'policy-decisions.json');
+}
+function savePolicyDecision(projectRoot, decision) {
+    const target = policyDecisionPath(projectRoot, decision.run_id);
+    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+    const existing = loadPolicyDecisions(projectRoot, decision.run_id);
+    const next = [...existing.filter((item) => item.decision_id !== decision.decision_id), decision];
+    fs_1.default.writeFileSync(target, JSON.stringify(next, null, 2), 'utf8');
+    return decision;
+}
+function loadPolicyDecisions(projectRoot, runId) {
+    const target = policyDecisionPath(projectRoot, runId);
+    if (!fs_1.default.existsSync(target))
+        return [];
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(target, 'utf8'));
+        return Array.isArray(raw) ? raw : [];
+    }
+    catch {
+        return [];
+    }
+}
+function summarizePolicyDecisions(decisions) {
+    return {
+        total: decisions.length,
+        denied: decisions.filter((decision) => !decision.allowed).length,
+        gated: decisions.filter((decision) => decision.gate_required).length,
+        overridesWithoutRationale: decisions.filter((decision) => decision.override && !decision.rationale).length,
+    };
+}

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

@@ -2,10 +2,18 @@ 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';
+import type { VerificationManifest, ResidualRiskLedger } from '../verification/verification-manifest';
 export declare class ProjectionEngine {
     projectPlan(state: RunState, graph: ExecutionGraph): string;
-    projectVerify(state: RunState, results: VerificationResult[], checkResults?: CheckResult[]): string;
+    projectVerify(state: RunState, results: VerificationResult[], checkResults?: CheckResult[], manifest?: VerificationManifest | null, riskLedger?: ResidualRiskLedger | null, evidenceCoverage?: {
+        total_checks: number;
+        checks_with_evidence: number;
+        total_evidence_refs: number;
+        coverage_percent: number;
+    } | null): string;
     projectState(state: RunState): string;
     projectRunSummary(state: RunState): string;
     projectPRSummary(state: RunState, graph: ExecutionGraph): string;
+    projectCommitSummary(state: RunState, graph: ExecutionGraph): string;
+    projectPromotionSummary(state: RunState, graph: ExecutionGraph): string;
 }

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

@@ -66,7 +66,7 @@ class ProjectionEngine {
         }
         return lines.join('\n');
     }
-    projectVerify(state, results, checkResults) {
+    projectVerify(state, results, checkResults, manifest, riskLedger, evidenceCoverage) {
         const run = state.run;
         const lines = [
             '# OXE — Verificação',
@@ -92,6 +92,33 @@ class ProjectionEngine {
             }
             lines.push('');
         }
+        if (manifest) {
+            lines.push('## Verification Manifest');
+            lines.push('');
+            lines.push(`- **Checks:** ${manifest.summary.total}`);
+            lines.push(`- **Pass:** ${manifest.summary.pass}`);
+            lines.push(`- **Fail:** ${manifest.summary.fail}`);
+            lines.push(`- **Skip:** ${manifest.summary.skip}`);
+            lines.push(`- **Errors:** ${manifest.summary.error}`);
+            lines.push(`- **All passed:** ${manifest.summary.all_passed ? 'sim' : 'não'}`);
+            lines.push('');
+        }
+        if (evidenceCoverage) {
+            lines.push('## Evidence Coverage');
+            lines.push('');
+            lines.push(`- **Checks com evidência:** ${evidenceCoverage.checks_with_evidence}/${evidenceCoverage.total_checks}`);
+            lines.push(`- **Refs totais:** ${evidenceCoverage.total_evidence_refs}`);
+            lines.push(`- **Cobertura:** ${evidenceCoverage.coverage_percent}%`);
+            lines.push('');
+        }
+        if (riskLedger && riskLedger.risks.length > 0) {
+            lines.push('## Residual Risks');
+            lines.push('');
+            for (const risk of riskLedger.risks) {
+                lines.push(`- [${risk.severity.toUpperCase()}] ${risk.description}`);
+            }
+            lines.push('');
+        }
         if (checkResults && checkResults.length > 0) {
             lines.push('## Resultados dos checks executados');
             lines.push('');
@@ -181,11 +208,50 @@ class ProjectionEngine {
         return lines.join('\n');
     }
     projectPRSummary(state, graph) {
+        return this.projectPromotionSummary(state, graph);
+    }
+    projectCommitSummary(state, graph) {
         const run = state.run;
         const completed = [...state.completedWorkItems];
         const failed = [...state.failedWorkItems];
+        const blocked = [...state.blockedWorkItems];
         const lines = [
-            '## Summary',
+            '## Commit Summary',
+            '',
+            `**Run:** \`${run?.run_id ?? '—'}\``,
+            `**Status:** ${run?.status ?? '—'}`,
+            '',
+            '### Included work items',
+            '',
+        ];
+        for (const id of completed) {
+            const node = graph.nodes.get(id);
+            lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
+        }
+        if (failed.length || blocked.length) {
+            lines.push('');
+            lines.push('### Attention points');
+            lines.push('');
+            for (const id of failed) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ✗ ${node?.title ?? id} (\`${id}\`)`);
+            }
+            for (const id of blocked) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ⊘ ${node?.title ?? id} (\`${id}\`)`);
+            }
+        }
+        lines.push('');
+        lines.push('Generated by OXE Runtime.');
+        return lines.join('\n');
+    }
+    projectPromotionSummary(state, graph) {
+        const run = state.run;
+        const completed = [...state.completedWorkItems];
+        const failed = [...state.failedWorkItems];
+        const blocked = [...state.blockedWorkItems];
+        const lines = [
+            '## Promotion Summary',
             '',
         ];
         if (completed.length > 0) {
@@ -194,13 +260,17 @@ class ProjectionEngine {
                 lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
             }
         }
-        if (failed.length > 0) {
+        if (failed.length > 0 || blocked.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}\`)`);
             }
+            for (const id of blocked) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ⊘ ${node?.title ?? id} (\`${id}\`)`);
+            }
         }
         lines.push('');
         lines.push('## Test plan');

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

@@ -1,6 +1,6 @@
 import type { ExecutionGraph } from '../compiler/graph-compiler';
 import type { WorkspaceManager } from '../workspace/workspace-manager';
-import type { TaskExecutor, SchedulerContext } from './scheduler';
+import type { TaskExecutor, TaskResult, SchedulerContext } from './scheduler';
 import type { CooperativeHandoff } from './agent-roles';
 export type CoordinationMode = 'parallel' | 'competitive' | 'cooperative';
 export interface AgentSpec {
@@ -18,6 +18,44 @@ export interface CoordinationOptions {
     runId: string;
     onEvent?: SchedulerContext['onEvent'];
 }
+export interface ArbitrationRecord {
+    work_item_id: string;
+    mode: CoordinationMode;
+    winner_agent_id: string | null;
+    participant_agent_ids: string[];
+    success: boolean;
+    failure_class: TaskResult['failure_class'];
+    evidence_count: number;
+    recorded_at: string;
+}
+export interface MultiAgentOwnership {
+    work_item_id: string;
+    owner_agent_id: string;
+}
+export interface MultiAgentStatusSnapshot {
+    run_id: string;
+    mode: CoordinationMode;
+    workspace_isolation_required: 'isolated';
+    workspace_isolation_enforced: boolean;
+    agent_count: number;
+    ownership: MultiAgentOwnership[];
+    completed: string[];
+    failed: string[];
+    blocked: string[];
+    agent_results: Array<{
+        agent_id: string;
+        isolation_level: 'shared' | 'isolated';
+        assigned_task_ids: string[];
+        completed: string[];
+        failed: string[];
+    }>;
+    orphan_reassignments: Array<{
+        from_agent_id: string;
+        to_agent_id: string;
+        work_item_ids: string[];
+    }>;
+    updated_at: string;
+}
 export interface CoordinationResult {
     mode: CoordinationMode;
     run_id: string;
@@ -30,7 +68,11 @@ export interface CoordinationResult {
         failed: string[];
     }>;
     handoffs?: CooperativeHandoff[];
+    arbitration_results?: ArbitrationRecord[];
+    state?: MultiAgentStatusSnapshot;
 }
 export declare class MultiAgentCoordinator {
     run(graph: ExecutionGraph, opts: CoordinationOptions): Promise<CoordinationResult>;
 }
+export declare function multiAgentStatePath(projectRoot: string, runId: string): string;
+export declare function loadMultiAgentState(projectRoot: string, runId: string): MultiAgentStatusSnapshot | null;