oxe-cc 1.4.1 → 1.5.1

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

@@ -5,12 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiAgentCoordinator = void 0;
 exports.multiAgentStatePath = multiAgentStatePath;
+exports.multiAgentSummaryPath = multiAgentSummaryPath;
 exports.loadMultiAgentState = loadMultiAgentState;
+exports.loadMultiAgentSummary = loadMultiAgentSummary;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const bus_1 = require("../events/bus");
 const scheduler_1 = require("./scheduler");
 const agent_roles_1 = require("./agent-roles");
+const agent_registry_1 = require("./agent-registry");
 function ensureRunDir(projectRoot, runId) {
     const dir = path_1.default.join(projectRoot, '.oxe', 'runs', runId);
     fs_1.default.mkdirSync(dir, { recursive: true });
@@ -21,6 +24,24 @@ function persistMultiAgentArtifacts(projectRoot, runId, state, handoffs = [], ar
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'multi-agent-state.json'), JSON.stringify(state, null, 2), 'utf8');
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'handoffs.json'), JSON.stringify(handoffs, null, 2), 'utf8');
     fs_1.default.writeFileSync(path_1.default.join(runDir, 'arbitration-results.json'), JSON.stringify(arbitrationResults, null, 2), 'utf8');
+    const summary = {
+        run_id: state.run_id,
+        mode: state.mode,
+        workspace_isolation_enforced: state.workspace_isolation_enforced,
+        agent_count: state.agent_count,
+        completed_count: state.completed.length,
+        failed_count: state.failed.length,
+        blocked_count: state.blocked.length,
+        ownership_count: state.ownership.length,
+        handoff_count: handoffs.length,
+        arbitration_count: arbitrationResults.length,
+        orphan_reassignment_count: state.orphan_reassignments.length,
+        timeout_count: state.timed_out_agents.length,
+        participating_agents: state.agent_results.map((entry) => entry.agent_id),
+        health: state.timed_out_agents.length > 0 || state.failed.length > 0 ? 'degraded' : 'healthy',
+        updated_at: state.updated_at,
+    };
+    fs_1.default.writeFileSync(path_1.default.join(runDir, 'multi-agent-summary.json'), JSON.stringify(summary, null, 2), 'utf8');
 }
 function ensureIsolatedAgents(agents) {
     const shared = agents.filter((agent) => agent.workspaceManager.isolation_level !== 'isolated');
@@ -41,7 +62,7 @@ function buildOwnership(agents, partitions) {
     }
     return ownership;
 }
-function makeState(mode, runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments) {
+function makeState(mode, runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents) {
     return {
         run_id: runId,
         mode,
@@ -60,16 +81,82 @@ function makeState(mode, runId, agents, partitions, agentResults, completed, fai
                 assigned_task_ids: partitions[idx] ?? agent.assignedTaskIds ?? [],
                 completed: result?.completed ?? [],
                 failed: result?.failed ?? [],
+                timed_out: Boolean(result?.timed_out),
+                reassigned_task_ids: result?.reassigned_task_ids ?? [],
             };
         }),
         orphan_reassignments: orphanReassignments,
+        timed_out_agents: timedOutAgents,
         updated_at: new Date().toISOString(),
     };
 }
+async function runGraphForAgent(graph, nodeIds, agent, idx, opts, heartbeatTimeoutMs) {
+    const subGraph = subGraphFor(graph, nodeIds);
+    if (subGraph.nodes.size === 0) {
+        return {
+            agent_id: agent.id,
+            completed: [],
+            failed: [],
+            timed_out: false,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    const ctx = {
+        projectRoot: opts.projectRoot,
+        sessionId: opts.sessionId,
+        runId: `${opts.runId}-agent${idx}`,
+        executor: agent.executor,
+        workspaceManager: agent.workspaceManager,
+        onEvent: opts.onEvent,
+    };
+    const scheduler = new scheduler_1.Scheduler();
+    const work = scheduler.run(subGraph, ctx);
+    if (!heartbeatTimeoutMs || heartbeatTimeoutMs <= 0) {
+        const result = await work;
+        return {
+            agent_id: agent.id,
+            completed: result.completed,
+            failed: result.failed,
+            timed_out: false,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    let timer = null;
+    const raced = await Promise.race([
+        work.then((result) => ({ type: 'result', result })),
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ type: 'timeout' }), heartbeatTimeoutMs);
+        }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    if (raced && raced.type === 'timeout') {
+        return {
+            agent_id: agent.id,
+            completed: [],
+            failed: [],
+            timed_out: true,
+            assigned_task_ids: nodeIds,
+            reassigned_task_ids: [],
+        };
+    }
+    const result = raced.result;
+    return {
+        agent_id: agent.id,
+        completed: result.completed,
+        failed: result.failed,
+        timed_out: false,
+        assigned_task_ids: nodeIds,
+        reassigned_task_ids: [],
+    };
+}
 // ─── Parallel mode ───────────────────────────────────────────────────────────
 async function runParallel(graph, opts) {
     const { agents, projectRoot, sessionId, runId } = opts;
     ensureIsolatedAgents(agents);
+    const heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? null;
     const partitions = agents.map((agent) => [...(agent.assignedTaskIds ?? [])]);
     if (partitions.every((partition) => partition.length === 0)) {
         const allIds = [...graph.nodes.keys()];
@@ -77,33 +164,55 @@ async function runParallel(graph, opts) {
             partitions[index % agents.length].push(id);
         });
     }
+    const registry = new agent_registry_1.AgentRegistry(heartbeatTimeoutMs == null ? 30000 : heartbeatTimeoutMs);
+    agents.forEach((agent, idx) => {
+        registry.register(agent.id, agent.executor, agent.workspaceManager, partitions[idx] ?? []);
+    });
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunStarted',
         run_id: runId,
         payload: { mode: 'parallel', agent_count: agents.length, isolation_level: 'isolated' },
     });
-    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 initialResults = await Promise.all(agents.map(async (agent, idx) => {
+        registry.beat(agent.id, partitions[idx][0] || null);
+        const result = await runGraphForAgent(graph, partitions[idx], agent, idx, opts, heartbeatTimeoutMs);
+        registry.setStatus(agent.id, result.timed_out ? 'timeout' : 'idle');
+        return result;
     }));
-    const completed = agentResults.flatMap((result) => result.completed);
-    const failed = agentResults.flatMap((result) => result.failed);
+    const timedOutAgents = [];
     const blocked = [];
     const orphanReassignments = [];
-    const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments);
+    const agentResults = initialResults.map((entry) => ({
+        ...entry,
+        reassigned_task_ids: entry.reassigned_task_ids || [],
+    }));
+    const liveAgents = agentResults.filter((entry) => !entry.timed_out);
+    for (const timedOut of agentResults.filter((entry) => entry.timed_out)) {
+        timedOutAgents.push({
+            agent_id: timedOut.agent_id,
+            work_item_ids: timedOut.assigned_task_ids,
+            detected_at: new Date().toISOString(),
+        });
+        const fallback = liveAgents.find((entry) => entry.agent_id !== timedOut.agent_id);
+        if (!fallback || timedOut.assigned_task_ids.length === 0)
+            continue;
+        const fallbackIdx = agents.findIndex((agent) => agent.id === fallback.agent_id);
+        const timeoutIdx = agents.findIndex((agent) => agent.id === timedOut.agent_id);
+        const rerun = await runGraphForAgent(graph, timedOut.assigned_task_ids, agents[fallbackIdx], fallbackIdx, opts, null);
+        fallback.completed.push(...rerun.completed);
+        fallback.failed.push(...rerun.failed);
+        fallback.reassigned_task_ids.push(...timedOut.assigned_task_ids);
+        partitions[fallbackIdx] = [...partitions[fallbackIdx], ...timedOut.assigned_task_ids];
+        partitions[timeoutIdx] = [];
+        orphanReassignments.push({
+            from_agent_id: timedOut.agent_id,
+            to_agent_id: fallback.agent_id,
+            work_item_ids: timedOut.assigned_task_ids,
+        });
+    }
+    const completed = Array.from(new Set(agentResults.flatMap((result) => result.completed)));
+    const failed = Array.from(new Set(agentResults.flatMap((result) => result.failed)));
+    const state = makeState('parallel', runId, agents, partitions, agentResults, completed, failed, blocked, orphanReassignments, timedOutAgents);
     persistMultiAgentArtifacts(projectRoot, runId, state);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -119,6 +228,7 @@ async function runParallel(graph, opts) {
         agent_results: agentResults,
         arbitration_results: [],
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 // ─── Competitive mode ────────────────────────────────────────────────────────
@@ -154,9 +264,9 @@ async function runCompetitive(graph, opts) {
     }
     const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
     const state = makeState('competitive', runId, opts.agents, partitions, [
-        { agent_id: agentA.id, completed, failed },
-        { agent_id: agentB.id, completed: [], failed: [] },
-    ], completed, failed, blocked, []);
+        { agent_id: agentA.id, completed, failed, timed_out: false, reassigned_task_ids: [] },
+        { agent_id: agentB.id, completed: [], failed: [], timed_out: false, reassigned_task_ids: [] },
+    ], completed, failed, blocked, [], []);
     persistMultiAgentArtifacts(projectRoot, runId, state, [], arbitrationResults);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -175,6 +285,7 @@ async function runCompetitive(graph, opts) {
         ],
         arbitration_results: arbitrationResults,
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 async function competeTwoAgents(nodeId, node, agentA, agentB, opts, arbitrationResults) {
@@ -294,9 +405,9 @@ async function runCooperative(graph, opts) {
     }
     const partitions = [Array.from(graph.nodes.keys()), Array.from(graph.nodes.keys())];
     const state = makeState('cooperative', runId, opts.agents, partitions, [
-        { agent_id: planner.id, completed: [], failed: [] },
-        { agent_id: executor.id, completed, failed },
-    ], completed, failed, blocked, []);
+        { agent_id: planner.id, completed: [], failed: [], timed_out: false, reassigned_task_ids: [] },
+        { agent_id: executor.id, completed, failed, timed_out: false, reassigned_task_ids: [] },
+    ], completed, failed, blocked, [], []);
     persistMultiAgentArtifacts(projectRoot, runId, state, handoffs, []);
     (0, bus_1.appendEvent)(projectRoot, sessionId, {
         type: 'RunCompleted',
@@ -316,6 +427,7 @@ async function runCooperative(graph, opts) {
         handoffs,
         arbitration_results: [],
         state,
+        summary: loadMultiAgentSummary(projectRoot, runId) || undefined,
     };
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -334,6 +446,9 @@ exports.MultiAgentCoordinator = MultiAgentCoordinator;
 function multiAgentStatePath(projectRoot, runId) {
     return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'multi-agent-state.json');
 }
+function multiAgentSummaryPath(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'multi-agent-summary.json');
+}
 function loadMultiAgentState(projectRoot, runId) {
     const statePath = multiAgentStatePath(projectRoot, runId);
     if (!fs_1.default.existsSync(statePath))
@@ -345,6 +460,17 @@ function loadMultiAgentState(projectRoot, runId) {
         return null;
     }
 }
+function loadMultiAgentSummary(projectRoot, runId) {
+    const summaryPath = multiAgentSummaryPath(projectRoot, runId);
+    if (!fs_1.default.existsSync(summaryPath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(summaryPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function subGraphFor(graph, nodeIds) {
     const ids = new Set(nodeIds);

package/lib/sdk/README.md

@@ -76,5 +76,7 @@ O SDK já expõe os helpers usados pela operação enterprise do OXE:
 - `operational.readRuntimeGates(...)` / `operational.resolveRuntimeGate(...)`
 - `operational.recoverRuntimeState(...)` / `operational.replayRuntimeState(...)`
 - `operational.readRuntimeMultiAgentStatus(...)` / `operational.multiAgentStatus(...)`
+- `release.checkReleaseConsistency(...)` / `release.buildReleaseManifest(...)`
+- `release.loadRuntimeSmokeReport(...)` / `release.loadRecoveryFixtureReport(...)` / `release.loadMultiAgentSoakReport(...)`
 
 Use esses helpers quando quiser integrar gates, verify, recovery e multi-agent a scripts de CI, automações internas ou observabilidade.

package/lib/sdk/index.cjs

@@ -17,8 +17,10 @@ const plugins = require('../../bin/lib/oxe-plugins.cjs');
 const dashboard = require('../../bin/lib/oxe-dashboard.cjs');
 const operational = require('../../bin/lib/oxe-operational.cjs');
 const azure = require('../../bin/lib/oxe-azure.cjs');
-const context = require('../../bin/lib/oxe-context-engine.cjs');
-const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
+const context = require('../../bin/lib/oxe-context-engine.cjs');
+const runtimeSemantics = require('../../bin/lib/oxe-runtime-semantics.cjs');
+const release = require('../../bin/lib/oxe-release.cjs');
+const rationality = require('../../bin/lib/oxe-rationality.cjs');
 
 const PACKAGE_ROOT = path.join(__dirname, '..', '..');
 
@@ -540,9 +542,10 @@ module.exports = {
   /** Parsing de artefatos OXE (PLAN, SPEC, STATE, hypotheses, confidence, lessons). */
   parsePlan,
   parseSpec,
-  parseHypotheses: context.parseHypotheses,
-  parseConfidenceVector: context.parseConfidenceVector,
-  parseState,
+  parseHypotheses: context.parseHypotheses,
+  parseConfidenceVector: context.parseConfidenceVector,
+  parseExecutionPlanTasks: rationality.parsePlanTasks,
+  parseState,
   validateDecisionFidelity,
   parseLessonsMetrics,
   updateLessonMetric,
@@ -567,9 +570,11 @@ module.exports = {
     planAgentsWarnings: health.planAgentsWarnings,
     phaseCoherenceWarnings: health.phaseCoherenceWarnings,
     specSectionWarnings: health.specSectionWarnings,
-    planWaveWarningsFixed: health.planWaveWarningsFixed,
-    planTaskAceiteWarnings: health.planTaskAceiteWarnings,
-    verifyGapsWithoutSummaryWarning: health.verifyGapsWithoutSummaryWarning,
+    planWaveWarningsFixed: health.planWaveWarningsFixed,
+    planTaskAceiteWarnings: health.planTaskAceiteWarnings,
+    buildExecutionRationality: health.buildExecutionRationality,
+    executionRationalityWarningsFromSummary: health.executionRationalityWarningsFromSummary,
+    verifyGapsWithoutSummaryWarning: health.verifyGapsWithoutSummaryWarning,
     expandExecutionProfile: health.expandExecutionProfile,
     ALLOWED_CONFIG_KEYS: health.ALLOWED_CONFIG_KEYS,
     EXECUTION_PROFILES: health.EXECUTION_PROFILES,
@@ -636,12 +641,25 @@ module.exports = {
   },
 
   /** Dashboard local: contexto consolidado e persistência de revisão do plano. */
-  dashboard: {
-    loadDashboardContext: dashboard.loadDashboardContext,
-    savePlanReviewStatus: dashboard.savePlanReviewStatus,
-    addPlanReviewComment: dashboard.addPlanReviewComment,
-    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
-  },
+  dashboard: {
+    loadDashboardContext: dashboard.loadDashboardContext,
+    savePlanReviewStatus: dashboard.savePlanReviewStatus,
+    addPlanReviewComment: dashboard.addPlanReviewComment,
+    updatePlanReviewCommentStatus: dashboard.updatePlanReviewCommentStatus,
+  },
+
+  /** Release readiness: manifest, smoke matrix e checks de consistência antes de publicar. */
+  release: {
+    REQUIRED_RUNTIMES: release.REQUIRED_RUNTIMES,
+    WRAPPER_TARGETS: release.WRAPPER_TARGETS,
+    releasePaths: release.releasePaths,
+    collectWrapperHashes: release.collectWrapperHashes,
+    loadRuntimeSmokeReport: release.loadRuntimeSmokeReport,
+    loadRecoveryFixtureReport: release.loadRecoveryFixtureReport,
+    loadMultiAgentSoakReport: release.loadMultiAgentSoakReport,
+    buildReleaseManifest: release.buildReleaseManifest,
+    checkReleaseConsistency: release.checkReleaseConsistency,
+  },
 
   /** Runtime operacional: tracing, active run, catálogo de capabilities e memória em camadas. */
   operational: {

package/lib/sdk/index.d.ts

@@ -146,18 +146,50 @@ export interface GateQueueSnapshot {
   all?: Array<Record<string, unknown>>;
 }
 
-export interface MultiAgentStatusSummary {
-  path: string | null;
-  enabled: boolean;
-  runId: string | null;
-  mode: string | null;
+export interface MultiAgentStatusSummary {
+  path: string | null;
+  enabled: boolean;
+  runId: string | null;
+  mode: string | null;
   workspaceIsolationEnforced: boolean;
   agents: Array<Record<string, unknown>>;
-  ownership: Array<Record<string, unknown>>;
-  orphanReassignments: Array<Record<string, unknown>>;
-  handoffs: Array<Record<string, unknown>>;
-  arbitrationResults: Array<Record<string, unknown>>;
-}
+  ownership: Array<Record<string, unknown>>;
+  orphanReassignments: Array<Record<string, unknown>>;
+  handoffs: Array<Record<string, unknown>>;
+  arbitrationResults: Array<Record<string, unknown>>;
+  summary?: Record<string, unknown> | null;
+}
+
+export interface ReleaseManifest {
+  schema_version: number;
+  generated_at: string;
+  project_root: string;
+  package_root: string;
+  release_contract: Record<string, unknown>;
+  versions: Record<string, unknown>;
+  runtime_compiled: { path: string; ok: boolean };
+  wrappers: Record<string, unknown>;
+  reports: Record<string, unknown>;
+}
+
+export interface ReleaseConsistencyResult {
+  ok: boolean;
+  blockers: string[];
+  warnings: string[];
+  manifest: ReleaseManifest;
+  manifestPath: string;
+}
+
+export interface RuntimeSmokeReport {
+  path: string;
+  present: boolean;
+  ok: boolean;
+  total: number;
+  failures: string[];
+  missingRequired: string[];
+  results: Array<Record<string, unknown>>;
+  raw: Record<string, unknown> | null;
+}
 
 export interface PolicyDecisionSummary {
   total: number;
@@ -193,17 +225,62 @@ export interface AuditSummary {
   actions: Record<string, number>;
 }
 
-export interface PromotionSummary {
-  status: string | null;
-  targetKind: string | null;
-  remote: string | null;
-  targetRef: string | null;
-  prUrl: string | null;
-  prNumber: number | null;
-  coveragePercent: number | null;
-  reasons: string[];
-  path: string;
-}
+export interface PromotionSummary {
+  status: string | null;
+  targetKind: string | null;
+  remote: string | null;
+  targetRef: string | null;
+  prUrl: string | null;
+  prNumber: number | null;
+  coveragePercent: number | null;
+  reasons: string[];
+  path: string;
+}
+
+export interface ExecutionImplementationPackSummary {
+  path: string | null;
+  exists: boolean;
+  parseError: string | null;
+  ready: boolean;
+  tasks: Array<Record<string, unknown>>;
+  taskCount: number;
+  mutatingTasks: number;
+  criticalGaps: string[];
+}
+
+export interface ExecutionReferenceAnchorsSummary {
+  path: string | null;
+  exists: boolean;
+  ready: boolean;
+  anchors: Array<Record<string, unknown>>;
+  missingCriticalCount: number;
+  staleCount: number;
+  criticalGaps: string[];
+}
+
+export interface ExecutionFixturePackSummary {
+  path: string | null;
+  exists: boolean;
+  parseError: string | null;
+  ready: boolean;
+  fixtures: Array<Record<string, unknown>>;
+  fixtureCount: number;
+  criticalGaps: string[];
+}
+
+export interface ExecutionRationalitySummary {
+  applicable: boolean;
+  planTaskCount: number;
+  externalReferenceCount: number;
+  implementationPackReady: boolean;
+  referenceAnchorsReady: boolean;
+  fixturePackReady: boolean;
+  executionRationalityReady: boolean;
+  criticalExecutionGaps: string[];
+  implementationPack: ExecutionImplementationPackSummary;
+  referenceAnchors: ExecutionReferenceAnchorsSummary;
+  fixturePack: ExecutionFixturePackSummary;
+}
 
 /** Relatório retornado por `health.buildHealthReport` e incluído em `runDoctorChecks`.healthReport. */
 export interface OxeHealthReport {
@@ -228,10 +305,16 @@ export interface OxeHealthReport {
   copilotWarn?: string[];
   copilot?: CopilotIntegrationReport | null;
   summaryGapWarn: string | null;
-  specWarn: string[];
-  planWarn: string[];
-  planSelfEvaluation?: Record<string, unknown> | null;
-  planReviewStatus?: string | null;
+  specWarn: string[];
+  planWarn: string[];
+  planSelfEvaluation?: Record<string, unknown> | null;
+  implementationPackReady?: boolean;
+  referenceAnchorsReady?: boolean;
+  fixturePackReady?: boolean;
+  executionRationalityReady?: boolean;
+  criticalExecutionGaps?: string[];
+  executionRationality?: ExecutionRationalitySummary | null;
+  planReviewStatus?: string | null;
   activeRun?: Record<string, unknown> | null;
   eventsSummary?: Record<string, unknown> | null;
   memoryLayers?: Record<string, unknown> | null;
@@ -584,11 +667,12 @@ export interface OxeSdk {
   readMinNode: (packageRoot: string) => number;
 
   /** Parsing de artefatos OXE. */
-  parsePlan: (planMd: string) => ParsedPlan;
-  parseHypotheses: (planText: string) => CriticalHypothesis[];
-  parseConfidenceVector: (planText: string) => ConfidenceVector | null;
-  parseSpec: (specMd: string) => ParsedSpec;
-  parseState: (stateMd: string) => ParsedState;
+  parsePlan: (planMd: string) => ParsedPlan;
+  parseHypotheses: (planText: string) => CriticalHypothesis[];
+  parseConfidenceVector: (planText: string) => ConfidenceVector | null;
+  parseExecutionPlanTasks: (planPath: string | null) => Array<Record<string, unknown>>;
+  parseSpec: (specMd: string) => ParsedSpec;
+  parseState: (stateMd: string) => ParsedState;
   validateDecisionFidelity: (discussMd: string, planMd: string) => DecisionFidelityResult;
   parseLessonsMetrics: (metricsJson: string) => LessonMetric[];
   updateLessonMetric: (metrics: LessonMetric[], lessonId: string, outcome: LessonOutcome) => LessonMetric[];
@@ -622,10 +706,12 @@ export interface OxeSdk {
     copilotIntegrationReport: (target: string) => CopilotIntegrationReport;
     planAgentsWarnings: (target: string) => string[];
     phaseCoherenceWarnings: (phase: string, paths: Record<string, string>) => string[];
-    specSectionWarnings: (specPath: string, requiredHeadings: string[]) => string[];
-    planWaveWarningsFixed: (planPath: string, maxPerWave: number) => string[];
-    planTaskAceiteWarnings: (planPath: string) => string[];
-    verifyGapsWithoutSummaryWarning: (verifyPath: string, summaryPath: string) => string | null;
+    specSectionWarnings: (specPath: string, requiredHeadings: string[]) => string[];
+    planWaveWarningsFixed: (planPath: string, maxPerWave: number) => string[];
+    planTaskAceiteWarnings: (planPath: string) => string[];
+    buildExecutionRationality: (paths?: Record<string, string | null | undefined>) => ExecutionRationalitySummary;
+    executionRationalityWarningsFromSummary: (summary: ExecutionRationalitySummary) => string[];
+    verifyGapsWithoutSummaryWarning: (verifyPath: string, summaryPath: string) => string | null;
     expandExecutionProfile: (profile: string) => Record<string, unknown>;
     ALLOWED_CONFIG_KEYS: string[];
     EXECUTION_PROFILES: string[];
@@ -685,12 +771,24 @@ export interface OxeSdk {
     installNpmPlugin: (projectRoot: string, pkgName: string, version?: string) => { ok: boolean; path: string; error: string };
   };
 
-  dashboard: {
-    loadDashboardContext: (projectRoot: string, opts?: { activeSession?: string | null }) => Record<string, unknown>;
-    savePlanReviewStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
-    addPlanReviewComment: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
-    updatePlanReviewCommentStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown> | null;
-  };
+  dashboard: {
+    loadDashboardContext: (projectRoot: string, opts?: { activeSession?: string | null }) => Record<string, unknown>;
+    savePlanReviewStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
+    addPlanReviewComment: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown>;
+    updatePlanReviewCommentStatus: (projectRoot: string, input?: Record<string, unknown>) => Record<string, unknown> | null;
+  };
+
+  release: {
+    REQUIRED_RUNTIMES: string[];
+    WRAPPER_TARGETS: Array<Record<string, unknown>>;
+    releasePaths: (projectRoot: string) => Record<string, string>;
+    collectWrapperHashes: (projectRoot: string) => Record<string, unknown>;
+    loadRuntimeSmokeReport: (projectRoot: string) => RuntimeSmokeReport;
+    loadRecoveryFixtureReport: (projectRoot: string) => RuntimeSmokeReport;
+    loadMultiAgentSoakReport: (projectRoot: string) => RuntimeSmokeReport;
+    buildReleaseManifest: (projectRoot: string, options?: Record<string, unknown>) => ReleaseManifest;
+    checkReleaseConsistency: (projectRoot: string, options?: Record<string, unknown>) => ReleaseConsistencyResult;
+  };
 
   context: ContextAPI;
   runtimeSemantics: RuntimeSemanticsAPI;

package/oxe/templates/CONFIG.md

@@ -9,7 +9,7 @@ Copie `oxe/templates/config.template.json` para **`.oxe/config.json`** no seu pr
 | `profile` | string | Profile de execução: `balanced` (padrão) \| `strict` \| `fast` \| `legacy`. Expande automaticamente outras keys — keys explícitas prevalecem. Ver tabela abaixo. |
 | `discuss_before_plan` | boolean | Se `true`, o fluxo recomenda **`oxe:discuss`** entre spec e plan. |
 | `verification_depth` | string | Profundidade da verificação: `standard` (padrão) \| `thorough` (ativa Camada 5 — validate-gaps automático) \| `quick` (skip camadas 3–4 e UAT). |
-| `plan_confidence_threshold` | number | Limiar mínimo de confiança para o `execute` aceitar um `PLAN.md`. Padrão: `70`. Abaixo disso, o fluxo deve reduzir incerteza antes de implementar. |
+| `plan_confidence_threshold` | number | Limiar mínimo de confiança para o `execute` aceitar um `PLAN.md`. Padrão canónico: `90`, com gate estrito (`Confiança` precisa ser **maior que** o limiar). Valores menores que 90 não reduzem esse gate. |
 | `security_in_verify` | boolean | Se `true`, executa auditoria OWASP automaticamente no **verify** como **Camada 6** (produz `.oxe/SECURITY.md`). Achados P0 bloqueiam `verify_complete`. Padrão: `false`. |
 | `after_verify_suggest_pr` | boolean | Se `true`, o workflow **verify** inclui checklist de PR no fim. |
 | `after_verify_draft_commit` | boolean | Se `true`, o **verify** propõe rascunho de mensagem de commit alinhado aos critérios de aceite. |

package/oxe/templates/EXECUTION-RUNTIME.template.md

@@ -16,7 +16,7 @@ updated: YYYY-MM-DD
 - **Active run:** `.oxe/ACTIVE-RUN.json` ou artefato equivalente de sessão
 - **Trace log:** `.oxe/OXE-EVENTS.ndjson` ou artefato equivalente de sessão
 - **Autoavaliação do plano:** melhor=`sim|não` | confiança=`NN%`
-- **Limiar de execução:** `70%`
+- **Limiar de execução:** `>90%`
 
 ## Onda atual
 

package/oxe/templates/FIXTURE-PACK.template.json

@@ -0,0 +1,34 @@
+{
+  "schema_version": "1",
+  "generated_at": "YYYY-MM-DDTHH:MM:SSZ",
+  "ready": false,
+  "critical_gaps": [],
+  "fixtures": [
+    {
+      "id": "FX-01",
+      "task_id": "T1",
+      "status": "ready",
+      "inputs": [
+        {
+          "kind": "payload",
+          "ref": ".oxe/investigations/fixtures/example-input.json",
+          "summary": "payload base para validar o fluxo"
+        }
+      ],
+      "expected_outputs": [
+        {
+          "kind": "status",
+          "summary": "deve concluir sem erro e persistir o artefato esperado"
+        }
+      ],
+      "expected_checks": [
+        "npm test -- example"
+      ],
+      "critical_fields": [
+        "id",
+        "status"
+      ],
+      "critical_gaps": []
+    }
+  ]
+}

package/oxe/templates/FIXTURE-PACK.template.md

@@ -0,0 +1,21 @@
+# OXE — Fixture Pack
+
+> Fixtures mínimos para reduzir improviso em parsing, integração, transformação, migração e builders.
+
+## Status
+
+- **Status:** ready | not_ready | not_applicable
+- **Critical gaps abertos:** nenhum | listar
+
+## Fixtures
+
+### FX-01 — T1
+
+- **Task:** T1
+- **Status:** ready | missing | not_applicable
+- **Inputs:** payload, arquivo exemplo, query, blob ou mensagem
+- **Expected outputs:** linha, evento, arquivo, rowset, status etc.
+- **Expected checks:** `...`
+- **Campos críticos / offsets:** ...
+- **Smoke command:** `...`
+- **Critical gaps:** nenhum | listar