oxe-cc 1.8.3 → 1.9.1

package/AGENTS.md

@@ -99,4 +99,4 @@ Os wrappers por runtime podem carregar metadata cognitiva (`oxe_reasoning_mode`,
 
 Para `execute` e `verify`, o comportamento atual esperado é **runtime-first**: se `oxe-cc runtime` estiver disponível, preferir `runtime compile/project/verify/gates` e tratar markdown como projeção derivada; se o runtime não puder ser executado, declarar `fallback legado` explicitamente.
 
-Para publicação, o gate local esperado passa por `oxe-cc doctor --release --write-manifest`. Essa verificação deve falhar se houver drift de versão, topo inválido no `CHANGELOG`, ausência da árvore canónica `oxe/`, `workflow-runtime-contracts.json` inválido, wrapper dirty após sync, runtime não compilado ou ausência dos relatórios `.oxe/release/*.json` exigidos pela release.
+Para publicação, o gate local esperado passa por `npm test`, `npm run release:pack-check` e `oxe-cc doctor --release --write-manifest`. Essa verificação deve falhar se houver drift de versão, topo inválido no `CHANGELOG`, ausência da árvore canónica `oxe/`, `workflow-runtime-contracts.json` inválido, wrapper dirty após sync, runtime não compilado, pacote npm com artefatos indevidos ou ausência dos relatórios `.oxe/release/*.json` exigidos pela release, incluindo `runtime-real-report.json` e, a partir da `1.9.1`, `multi-agent-real-report.json`.

package/CHANGELOG.md

@@ -4,6 +4,37 @@ Todas as versões seguem [Semantic Versioning](https://semver.org/). As mudança
 
 ---
 
+## [1.9.1] — 2026-05-04
+
+### Multi-Agent Real
+
+Esta release endurece a coordenação multi-agent sobre workspaces reais, sem abrir novos comandos públicos.
+
+- multi-agent real passa a exigir workspaces isolados `git_worktree` para modos `parallel`, `competitive` e `cooperative`
+- `runtime execute` valida `plan-agents.json` antes de iniciar agentes e usa `GitWorktreeManager` por padrão no caminho multi-agent
+- novo artefato por run `.oxe/runs/<run_id>/workspace-merge-report.json` com worktrees, ownership, merge blockers e readiness
+- `runtime agents status --json`, `status --json` e recovery passam a expor merge readiness, blockers, arbitration e worktrees órfãos
+- novo `npm run test:multi-agent-real` gera `.oxe/release/multi-agent-real-report.json` usando repositório git temporário com worktrees reais
+- `doctor --release` passa a exigir `multi-agent-real-report.json` em versões `>=1.9.1`
+
+## [1.9.0] — 2026-05-04
+
+### Runtime Real Maturity
+
+Esta release eleva a maturidade prática do OXE com foco em prova determinística do ciclo real `spec -> plan -> execute -> verify -> status/doctor`, sem abrir novos comandos públicos.
+
+#### Runtime real
+
+- nova suíte `test:runtime-real` valida projetos representativos com executor mockado e sem chamada a LLM/API externa
+- `runtime execute` passa a bloquear antes da mutação quando confiança, rationality packs ou gates não estão prontos
+- `runtime verify` continua evidence-first e passa a ser validado dentro do fluxo real de execução
+
+#### Release proof
+
+- novo relatório obrigatório `.oxe/release/runtime-real-report.json`
+- `doctor --release` passa a bloquear publicação quando a prova de runtime real estiver ausente ou falha
+- novo `release:pack-check` valida o tarball npm em dry-run contra artefatos indevidos
+
 ## [1.8.3] — 2026-05-04
 
 ### Release readiness e higiene de publicação

package/README.md

@@ -7,7 +7,7 @@
 [![npm](https://img.shields.io/npm/v/oxe-cc.svg?style=flat-square)](https://www.npmjs.com/package/oxe-cc)
 [![license](https://img.shields.io/npm/l/oxe-cc.svg?style=flat-square)](LICENSE)
 
-**Versão:** `1.8.3` · [package.json](package.json)
+**Versão:** `1.9.1` · [package.json](package.json)
 
 **Framework OXE — Orchestrated eXperience Engineering**
 
@@ -459,20 +459,23 @@ O `status --full` mostra em ANSI: readiness do ciclo, autoavaliação do plano,
 
 O pacote está pronto para uma publicação robusta quando estes sinais estiverem verdes no repositório da release:
 
-- `npm test`
-- `npm run scan:assets`
-- `npm run build:vscode-ext`
-- `node bin/oxe-cc.js doctor --release --write-manifest`
-- `node bin/oxe-cc.js status --full`
+- `npm test`
+- `npm run scan:assets`
+- `npm run build:vscode-ext`
+- `node bin/oxe-cc.js doctor --release --write-manifest`
+- `npm run release:pack-check`
+- `node bin/oxe-cc.js status --full`
 
 Artefatos obrigatórios desta fase:
 
-- `.oxe/release/release-manifest.json`
-- `.oxe/release/runtime-smoke-report.json`
-- `.oxe/release/recovery-fixture-report.json`
-- `.oxe/release/multi-agent-soak-report.json`
-
-Não há outro bloqueador funcional do plano runtime core para esta publicação. O que sobra depois dela é evolução de ergonomia e expansão de targets, não correção estrutural do contrato atual.
+- `.oxe/release/release-manifest.json`
+- `.oxe/release/runtime-smoke-report.json`
+- `.oxe/release/runtime-real-report.json`
+- `.oxe/release/recovery-fixture-report.json`
+- `.oxe/release/multi-agent-soak-report.json`
+- `.oxe/release/multi-agent-real-report.json`
+
+Na linha `1.9.1`, `runtime-real-report.json` prova o ciclo real `compile -> execute mockado -> verify -> project -> status --json`, e `multi-agent-real-report.json` prova coordenação com `git_worktree`, ownership, arbitragem e merge readiness antes da publicação.
 
 ### `/oxe-retro` — loop de aprendizado
 

package/bin/lib/oxe-operational.cjs

@@ -722,10 +722,52 @@ async function resolveRuntimeGate(projectRoot, activeSession, options = {}) {
   };
 }
 
-// Gap 5: route execution to MultiAgentCoordinator when plan-agents.json exists
-async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
-  const runtime = loadRuntimeModule();
-  if (!runtime) throw new Error('Runtime package não está disponível. Rode npm run build:runtime.');
+  // Gap 5: route execution to MultiAgentCoordinator when plan-agents.json exists
+function buildRuntimeExecutePreflight(projectRoot, activeSession, runState) {
+    const health = loadProjectHealth();
+    const blockers = [];
+    const warnings = [];
+    let report = null;
+    if (health && typeof health.buildHealthReport === 'function') {
+      report = health.buildHealthReport(projectRoot);
+      if (report.planSelfEvaluation && report.planSelfEvaluation.executable === false) {
+        const confidence = report.planSelfEvaluation.confidence;
+        const threshold = report.planConfidenceThreshold || 90;
+        blockers.push(`plan_confidence:${confidence == null ? 'missing' : `${confidence}%`}<=${threshold}%`);
+      }
+      if (report.executionRationality && report.executionRationality.applicable && !report.executionRationalityReady) {
+        const gaps = Array.isArray(report.criticalExecutionGaps) ? report.criticalExecutionGaps : [];
+        blockers.push(`execution_rationality:${gaps[0] || 'not_ready'}`);
+      }
+      if (report.fallbackMode && report.fallbackMode !== 'none') {
+        warnings.push(`fallback_mode:${report.fallbackMode}`);
+      }
+    } else {
+      warnings.push('health_report_unavailable');
+    }
+    const runId = runState && runState.run_id ? runState.run_id : null;
+    const queue = readRuntimeGates(projectRoot, activeSession, { runId });
+    if (queue.pending.length > 0) {
+      blockers.push(`pending_gates:${queue.pending.length}`);
+    }
+    return {
+      ok: blockers.length === 0,
+      blockers,
+      warnings,
+      runId,
+      gateQueue: {
+        pending: queue.pending.length,
+        stale: queue.staleCount || 0,
+      },
+      confidence: report && report.planSelfEvaluation ? report.planSelfEvaluation.confidence : null,
+      confidenceThreshold: report ? report.planConfidenceThreshold || 90 : 90,
+      executionRationalityReady: report ? Boolean(report.executionRationalityReady) : false,
+    };
+  }
+
+  async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
+    const runtime = loadRuntimeModule();
+    if (!runtime) throw new Error('Runtime package não está disponível. Rode npm run build:runtime.');
   const parsers = loadSdkParsers();
   if (!parsers) throw new Error('SDK parsers não disponíveis.');
 
@@ -745,15 +787,41 @@ async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
 
   // Resolve compiled graph from run state or compile on demand
   let current = options.runState || readRunState(projectRoot, activeSession);
-  if (!current || !current.compiled_graph) {
-    current = compileExecutionGraphFromArtifacts(projectRoot, activeSession, { runState: current }).run;
-  }
-  if (!current || !current.compiled_graph) {
-    throw new Error('Nenhum grafo compilado encontrado. Execute oxe-cc runtime compile primeiro.');
-  }
-  const graph = runtime.fromSerializable
-    ? runtime.fromSerializable(current.compiled_graph)
-    : current.compiled_graph;
+    if (!current || !current.compiled_graph) {
+      current = compileExecutionGraphFromArtifacts(projectRoot, activeSession, { runState: current }).run;
+    }
+    if (!current || !current.compiled_graph) {
+      throw new Error('Nenhum grafo compilado encontrado. Execute oxe-cc runtime compile primeiro.');
+    }
+    const preflight = buildRuntimeExecutePreflight(projectRoot, activeSession, current);
+    if (!preflight.ok && !options.skipPreflight) {
+      const reason = preflight.blockers[0] || 'runtime_execute_preflight_failed';
+      appendEvent(projectRoot, activeSession, {
+        type: 'WorkItemBlocked',
+        run_id: current.run_id,
+        payload: {
+          reason: 'runtime_execute_preflight_failed',
+          blockers: preflight.blockers,
+        },
+      });
+      return {
+        mode: 'preflight',
+        agentPlan: null,
+        result: {
+          run_id: current.run_id,
+          status: 'blocked',
+          completed: [],
+          failed: [],
+          blocked: ['runtime_execute_preflight'],
+          reason,
+        },
+        run: current,
+        preflight,
+      };
+    }
+    const graph = runtime.fromSerializable
+      ? runtime.fromSerializable(current.compiled_graph)
+      : current.compiled_graph;
 
   // Detect plan-agents.json (session path takes priority over root)
   const rootAgentPlan = path.join(projectRoot, '.oxe', 'plan-agents.json');
@@ -780,35 +848,40 @@ async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
   // Gap 5: multi-agent path if plan-agents.json exists
   if (agentPlanPath) {
     let agentPlan;
-    try {
-      agentPlan = JSON.parse(fs.readFileSync(agentPlanPath, 'utf8'));
-    } catch (err) {
-      throw new Error(`plan-agents.json inválido: ${err.message}`);
-    }
-    if (!Array.isArray(agentPlan.agents) || agentPlan.agents.length === 0) {
-      throw new Error('plan-agents.json não contém agentes válidos (campo "agents" vazio ou ausente).');
-    }
-    if (typeof runtime.MultiAgentCoordinator !== 'function') {
-      throw new Error('Runtime não exporta MultiAgentCoordinator. Verifique a versão do runtime.');
-    }
-    const agents = agentPlan.agents.map((spec) => ({
-      id: spec.id,
-      executor: options.executorFactory ? options.executorFactory(spec) : (options.executor || null),
-      workspaceManager: options.workspaceManager || null,
-      assignedTaskIds: Array.isArray(spec.tasks) ? spec.tasks : [],
-    }));
+    try {
+      agentPlan = JSON.parse(fs.readFileSync(agentPlanPath, 'utf8'));
+    } catch (err) {
+      throw new Error(`plan-agents.json inválido: ${err.message}`);
+    }
+    const planErrors = validateMultiAgentPlan(agentPlan);
+    if (planErrors.length > 0) {
+      throw new Error(`plan-agents.json inválido: ${planErrors.join('; ')}`);
+    }
+    if (typeof runtime.MultiAgentCoordinator !== 'function') {
+      throw new Error('Runtime não exporta MultiAgentCoordinator. Verifique a versão do runtime.');
+    }
+    if (typeof runtime.GitWorktreeManager !== 'function' && !options.workspaceManager) {
+      throw new Error('Runtime não exporta GitWorktreeManager. Multi-agent real exige backend git_worktree.');
+    }
+    const agents = agentPlan.agents.map((spec) => ({
+      id: spec.id,
+      executor: options.executorFactory ? options.executorFactory(spec) : (options.executor || executor),
+      workspaceManager: options.workspaceManager || new runtime.GitWorktreeManager(projectRoot),
+      assignedTaskIds: Array.isArray(spec.tasks) ? spec.tasks : [],
+    }));
     const coordinator = new runtime.MultiAgentCoordinator();
     const result = await coordinator.run(graph, {
       mode: agentPlan.mode || 'parallel',
       agents,
       projectRoot,
       sessionId: activeSession || null,
-      runId: current.run_id,
-      heartbeatTimeoutMs: options.heartbeatTimeoutMs ?? 120000,
-      onEvent: ctx.onEvent,
-    });
-    return { mode: agentPlan.mode || 'parallel', agentPlan, result, run: current };
-  }
+      runId: current.run_id,
+      heartbeatTimeoutMs: options.heartbeatTimeoutMs ?? 120000,
+      applyWorkspaceMerges: true,
+      onEvent: ctx.onEvent,
+    });
+      return { mode: agentPlan.mode || 'parallel', agentPlan, result, run: current, preflight };
+    }
 
   // Single-agent fallback
   if (typeof runtime.Scheduler !== 'function') {
@@ -816,8 +889,8 @@ async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
   }
   const scheduler = new runtime.Scheduler();
   const result = await scheduler.run(graph, ctx);
-  return { mode: 'single', agentPlan: null, result, run: current };
-}
+    return { mode: 'single', agentPlan: null, result, run: current, preflight };
+  }
 
 function readRuntimeMultiAgentStatus(projectRoot, activeSession, options = {}) {
   const runtime = loadRuntimeModule();
@@ -832,23 +905,32 @@ function readRuntimeMultiAgentStatus(projectRoot, activeSession, options = {}) {
       workspaceIsolationEnforced: false,
       agents: [],
       ownership: [],
-      orphanReassignments: [],
-      handoffs: [],
-      arbitrationResults: [],
-      summary: null,
-    };
+      orphanReassignments: [],
+      handoffs: [],
+      arbitrationResults: [],
+      workspaceMergeReport: null,
+      worktrees: [],
+      mergeBlockers: [],
+      mergeReadiness: null,
+      arbitrationRequired: false,
+      summary: null,
+    };
   }
   const runDir = path.join(projectRoot, '.oxe', 'runs', runId);
   const statePath = path.join(runDir, 'multi-agent-state.json');
-  const summaryPath = path.join(runDir, 'multi-agent-summary.json');
-  const handoffsPath = path.join(runDir, 'handoffs.json');
-  const arbitrationPath = path.join(runDir, 'arbitration-results.json');
+  const summaryPath = path.join(runDir, 'multi-agent-summary.json');
+  const handoffsPath = path.join(runDir, 'handoffs.json');
+  const arbitrationPath = path.join(runDir, 'arbitration-results.json');
+  const workspaceMergePath = path.join(runDir, 'workspace-merge-report.json');
   const state = runtime && typeof runtime.loadMultiAgentState === 'function'
     ? runtime.loadMultiAgentState(projectRoot, runId)
     : readJsonIfExists(statePath);
-  const summary = runtime && typeof runtime.loadMultiAgentSummary === 'function'
-    ? runtime.loadMultiAgentSummary(projectRoot, runId)
-    : readJsonIfExists(summaryPath);
+  const summary = runtime && typeof runtime.loadMultiAgentSummary === 'function'
+    ? runtime.loadMultiAgentSummary(projectRoot, runId)
+    : readJsonIfExists(summaryPath);
+  const workspaceMergeReport = runtime && typeof runtime.loadWorkspaceMergeReport === 'function'
+    ? runtime.loadWorkspaceMergeReport(projectRoot, runId)
+    : readJsonIfExists(workspaceMergePath);
   const handoffs = readJsonIfExists(handoffsPath);
   const arbitrationResults = readJsonIfExists(arbitrationPath);
   return {
@@ -861,10 +943,41 @@ function readRuntimeMultiAgentStatus(projectRoot, activeSession, options = {}) {
     ownership: state && Array.isArray(state.ownership) ? state.ownership : [],
     orphanReassignments: state && Array.isArray(state.orphan_reassignments) ? state.orphan_reassignments : [],
     handoffs: Array.isArray(handoffs) ? handoffs : [],
-    arbitrationResults: Array.isArray(arbitrationResults) ? arbitrationResults : [],
-    summary: summary || null,
-  };
-}
+    arbitrationResults: Array.isArray(arbitrationResults) ? arbitrationResults : [],
+    workspaceMergeReport: workspaceMergeReport || null,
+    worktrees: workspaceMergeReport && Array.isArray(workspaceMergeReport.records) ? workspaceMergeReport.records : [],
+    mergeBlockers: workspaceMergeReport && Array.isArray(workspaceMergeReport.blockers) ? workspaceMergeReport.blockers : [],
+    mergeReadiness: workspaceMergeReport && workspaceMergeReport.merge_readiness ? workspaceMergeReport.merge_readiness : null,
+    arbitrationRequired: Boolean(workspaceMergeReport && workspaceMergeReport.arbitration_required),
+    summary: summary || null,
+  };
+}
+
+function validateMultiAgentPlan(agentPlan) {
+  const errors = [];
+  const allowedModes = new Set(['parallel', 'competitive', 'cooperative']);
+  const mode = agentPlan && agentPlan.mode ? String(agentPlan.mode) : 'parallel';
+  if (!allowedModes.has(mode)) errors.push(`mode inválido: ${mode}`);
+  if (!Array.isArray(agentPlan && agentPlan.agents) || agentPlan.agents.length === 0) {
+    errors.push('campo "agents" vazio ou ausente');
+    return errors;
+  }
+  const schemaVersion = Number(agentPlan.schema_version || agentPlan.schema || 0);
+  const seen = new Set();
+  for (const [idx, spec] of agentPlan.agents.entries()) {
+    const id = spec && spec.id ? String(spec.id) : '';
+    if (!id) errors.push(`agents[${idx}].id ausente`);
+    if (id && seen.has(id)) errors.push(`agent duplicado: ${id}`);
+    if (id) seen.add(id);
+    if (schemaVersion >= 3 && !spec.persona) errors.push(`${id || `agents[${idx}]`}.persona ausente`);
+    if (schemaVersion >= 3 && !spec.model_hint) errors.push(`${id || `agents[${idx}]`}.model_hint ausente`);
+    if (spec.tasks != null && !Array.isArray(spec.tasks)) errors.push(`${id || `agents[${idx}]`}.tasks deve ser array`);
+  }
+  if ((mode === 'competitive' || mode === 'cooperative') && agentPlan.agents.length < 2) {
+    errors.push(`${mode} exige pelo menos 2 agentes`);
+  }
+  return errors;
+}
 
 function loadRuntimeVerificationArtifacts(projectRoot, runState) {
   const runtime = loadRuntimeModule();
@@ -890,7 +1003,7 @@ function loadRuntimeVerificationArtifacts(projectRoot, runState) {
   return { manifest, residualRisks, evidenceCoverage };
 }
 
-function countVerificationEvidenceRefs(runState, verificationArtifacts) {
+function countVerificationEvidenceRefs(runState, verificationArtifacts) {
   if (verificationArtifacts && verificationArtifacts.manifest && Array.isArray(verificationArtifacts.manifest.checks)) {
     return verificationArtifacts.manifest.checks.reduce((sum, check) => {
       return sum + (Array.isArray(check.evidence_refs) ? check.evidence_refs.length : 0);
@@ -902,7 +1015,26 @@ function countVerificationEvidenceRefs(runState, verificationArtifacts) {
     }, 0);
   }
   return 0;
-}
+}
+
+function detectOrphanWorktrees(projectRoot, runId) {
+  const workspacesDir = path.join(projectRoot, '.oxe', 'workspaces');
+  if (!fs.existsSync(workspacesDir)) return [];
+  const active = new Set();
+  const mergeReport = readJsonIfExists(path.join(projectRoot, '.oxe', 'runs', runId, 'workspace-merge-report.json'));
+  for (const record of (mergeReport && Array.isArray(mergeReport.records) ? mergeReport.records : [])) {
+    if (record && record.workspace_id) active.add(String(record.workspace_id));
+  }
+  return fs.readdirSync(workspacesDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter((name) => !active.has(name))
+    .map((name) => ({
+      workspace_id: name,
+      path: path.join(workspacesDir, name),
+      next_action: 'inspecione o worktree órfão; depois remova com git worktree remove --force se não houver diffs úteis',
+    }));
+}
 
 function buildRuntimeModeStatus(runState) {
   if (!runState) {
@@ -1074,11 +1206,17 @@ function writeRecoverySummaryMarkdown(projectRoot, activeSession, runState, reco
     '',
     '## Work items órfãos',
     '',
-    ...(Array.isArray(recoverySummary.orphan_work_items) && recoverySummary.orphan_work_items.length
-      ? recoverySummary.orphan_work_items.map((item) => `- ${item}`)
-      : ['- Nenhum']),
-    '',
-    '## Tentativas incompletas',
+    ...(Array.isArray(recoverySummary.orphan_work_items) && recoverySummary.orphan_work_items.length
+      ? recoverySummary.orphan_work_items.map((item) => `- ${item}`)
+      : ['- Nenhum']),
+    '',
+    '## Worktrees órfãos',
+    '',
+    ...(Array.isArray(recoverySummary.orphan_worktrees) && recoverySummary.orphan_worktrees.length
+      ? recoverySummary.orphan_worktrees.map((item) => `- ${item.workspace_id} · ${item.next_action}`)
+      : ['- Nenhum']),
+    '',
+    '## Tentativas incompletas',
     '',
     ...(recoverySummary.consistency && Array.isArray(recoverySummary.consistency.incomplete_attempts) && recoverySummary.consistency.incomplete_attempts.length
       ? recoverySummary.consistency.incomplete_attempts.map((item) => `- ${item.work_item_id} · ${item.attempt_id || 'attempt'} · ${item.outcome || 'unknown'}`)
@@ -1441,13 +1579,14 @@ function recoverRuntimeState(projectRoot, activeSession, options = {}) {
     journal,
     verificationArtifacts
   );
-  const recoverySummary = {
-    recovered_at: new Date().toISOString(),
-    journal_state: journal.scheduler_state,
-    orphan_work_items: orphanWorkItems,
-    pending_gates: readRuntimeGates(projectRoot, activeSession, { runId: current.run_id }).pending.map((gate) => gate.gate_id),
-    consistency,
-  };
+  const recoverySummary = {
+    recovered_at: new Date().toISOString(),
+    journal_state: journal.scheduler_state,
+    orphan_work_items: orphanWorkItems,
+    orphan_worktrees: detectOrphanWorktrees(projectRoot, current.run_id),
+    pending_gates: readRuntimeGates(projectRoot, activeSession, { runId: current.run_id }).pending.map((gate) => gate.gate_id),
+    consistency,
+  };
   const runDir = path.join(projectRoot, '.oxe', 'runs', current.run_id);
   ensureDir(runDir);
   const recoverySummaryPath = path.join(runDir, 'recovery-summary.json');
@@ -2329,8 +2468,9 @@ module.exports = {
   buildRecoveryConsistency,
   readRuntimeGates,
   resolveRuntimeGate,
-  createExecutionContext,
-  runRuntimeExecute,
+  createExecutionContext,
+  buildRuntimeExecutePreflight,
+  runRuntimeExecute,
   runRuntimeVerify,
   projectRuntimeArtifacts,
   runRuntimeCiChecks,

package/bin/lib/oxe-project-health.cjs

@@ -2070,8 +2070,10 @@ function suggestNextStep(target, cfg = {}) {
       artifacts: [
         '.oxe/release/release-manifest.json',
         '.oxe/release/runtime-smoke-report.json',
+        '.oxe/release/runtime-real-report.json',
         '.oxe/release/recovery-fixture-report.json',
         '.oxe/release/multi-agent-soak-report.json',
+        '.oxe/release/multi-agent-real-report.json',
       ],
     };
   }

package/bin/lib/oxe-release.cjs

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const semver = require('semver');
 
 const oxeManifest = require('./oxe-manifest.cjs');
 const runtimeSemantics = require('./oxe-runtime-semantics.cjs');
@@ -42,8 +43,10 @@ function releasePaths(projectRoot) {
     releaseDir,
     manifest: path.join(releaseDir, 'release-manifest.json'),
     smokeReport: path.join(releaseDir, 'runtime-smoke-report.json'),
+    runtimeRealReport: path.join(releaseDir, 'runtime-real-report.json'),
     recoveryFixtureReport: path.join(releaseDir, 'recovery-fixture-report.json'),
     multiAgentSoakReport: path.join(releaseDir, 'multi-agent-soak-report.json'),
+    multiAgentRealReport: path.join(releaseDir, 'multi-agent-real-report.json'),
   };
 }
 
@@ -277,6 +280,10 @@ function loadRuntimeSmokeReport(projectRoot) {
   });
 }
 
+function loadRuntimeRealReport(projectRoot) {
+  return readReportSummary(releasePaths(projectRoot).runtimeRealReport, null, (item) => Boolean(item && item.ok));
+}
+
 function loadRecoveryFixtureReport(projectRoot) {
   return readReportSummary(releasePaths(projectRoot).recoveryFixtureReport, null, (item) => Boolean(item && item.ok));
 }
@@ -285,6 +292,10 @@ function loadMultiAgentSoakReport(projectRoot) {
   return readReportSummary(releasePaths(projectRoot).multiAgentSoakReport, null, (item) => Boolean(item && item.ok));
 }
 
+function loadMultiAgentRealReport(projectRoot) {
+  return readReportSummary(releasePaths(projectRoot).multiAgentRealReport, null, (item) => Boolean(item && item.ok));
+}
+
 function readVersionSnapshot(projectRoot) {
   const packageJsonPath = path.join(projectRoot, 'package.json');
   const runtimePackagePath = path.join(projectRoot, 'packages', 'runtime', 'package.json');
@@ -349,8 +360,10 @@ function buildReleaseManifest(projectRoot, options = {}) {
   } : syncWrappers(projectRoot, packageRoot);
   const semanticsAudit = runtimeSemantics.auditRuntimeTargets(projectRoot);
   const smoke = loadRuntimeSmokeReport(projectRoot);
+  const runtimeReal = loadRuntimeRealReport(projectRoot);
   const recovery = loadRecoveryFixtureReport(projectRoot);
   const multiAgent = loadMultiAgentSoakReport(projectRoot);
+  const multiAgentReal = loadMultiAgentRealReport(projectRoot);
   const manifest = {
     schema_version: 1,
     generated_at: new Date().toISOString(),
@@ -384,8 +397,10 @@ function buildReleaseManifest(projectRoot, options = {}) {
     },
     reports: {
       runtime_smoke: smoke,
+      runtime_real: runtimeReal,
       recovery_fixtures: recovery,
       multi_agent_soak: multiAgent,
+      multi_agent_real: multiAgentReal,
     },
   };
   if (options.writeManifest) {
@@ -449,12 +464,21 @@ function evaluateReleaseManifest(manifest, options = {}) {
   if (!manifest.reports.runtime_smoke.present || !manifest.reports.runtime_smoke.ok) {
     blockers.push('runtime smoke matrix incompleta ou com falhas');
   }
+  if (!manifest.reports.runtime_real.present || !manifest.reports.runtime_real.ok) {
+    blockers.push('runtime real report incompleto ou com falhas');
+  }
   if (!manifest.reports.recovery_fixtures.present || !manifest.reports.recovery_fixtures.ok) {
     blockers.push('recovery fixture report incompleto ou com falhas');
   }
   if (!manifest.reports.multi_agent_soak.present || !manifest.reports.multi_agent_soak.ok) {
     blockers.push('multi-agent soak report incompleto ou com falhas');
   }
+  const releaseVersion = semver.valid(versions.root) ? versions.root : null;
+  if (releaseVersion && semver.gte(releaseVersion, '1.9.1')) {
+    if (!manifest.reports.multi_agent_real.present || !manifest.reports.multi_agent_real.ok) {
+      blockers.push('multi-agent real report incompleto ou com falhas');
+    }
+  }
   if (versions.banner.mode === 'unknown') {
     warnings.push('banner.txt sem placeholder v{version} nem versão fixa detectável');
   }
@@ -486,8 +510,10 @@ module.exports = {
   releasePaths,
   collectWrapperHashes,
   loadRuntimeSmokeReport,
+  loadRuntimeRealReport,
   loadRecoveryFixtureReport,
   loadMultiAgentSoakReport,
+  loadMultiAgentRealReport,
   buildReleaseManifest,
   inspectCanonicalSource,
   evaluateReleaseManifest,

package/bin/oxe-cc.js

@@ -4764,23 +4764,32 @@ async function runRuntime(opts) {
           }
         },
       });
-      if (opts.jsonOutput) {
-        console.log(JSON.stringify(result, null, 2));
-        if (result.result && result.result.failed && result.result.failed.length > 0) process.exitCode = 1;
-        return;
-      }
-      const r = result.result || {};
-      const completed = Array.isArray(r.completed) ? r.completed : [];
-      const failed = Array.isArray(r.failed) ? r.failed : [];
-      const blocked = Array.isArray(r.blocked) ? r.blocked : [];
-      console.log(`  ${c ? green : ''}✓${c ? reset : ''} Runtime execute concluído (modo: ${result.mode})`);
-      console.log(`  ${c ? green : ''}Completados:${c ? reset : ''} ${completed.length}`);
+      if (opts.jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        if (result.result && ((result.result.failed && result.result.failed.length > 0) || result.result.status === 'blocked')) process.exitCode = 1;
+        return;
+      }
+      const r = result.result || {};
+      const completed = Array.isArray(r.completed) ? r.completed : [];
+      const failed = Array.isArray(r.failed) ? r.failed : [];
+      const blocked = Array.isArray(r.blocked) ? r.blocked : [];
+      const okColor = r.status === 'blocked' ? yellow : green;
+      console.log(`  ${c ? okColor : ''}${r.status === 'blocked' ? '!' : '✓'}${c ? reset : ''} Runtime execute concluído (modo: ${result.mode})`);
+      if (result.preflight) {
+        console.log(`  ${c ? green : ''}Preflight:${c ? reset : ''} ${result.preflight.ok ? 'ready' : 'blocked'}`);
+        if (Array.isArray(result.preflight.blockers) && result.preflight.blockers.length) {
+          for (const blocker of result.preflight.blockers) {
+            console.log(`  ${yellow}BLOCKER${reset} ${blocker}`);
+          }
+        }
+      }
+      console.log(`  ${c ? green : ''}Completados:${c ? reset : ''} ${completed.length}`);
       if (failed.length > 0)
         console.log(`  ${c ? red : ''}Falhos:${c ? reset : ''} ${failed.length} — ${failed.join(', ')}`);
       if (blocked.length > 0)
         console.log(`  ${c ? '\x1b[33m' : ''}Bloqueados:${c ? reset : ''} ${blocked.length} — ${blocked.join(', ')}`);
-      if (failed.length > 0) process.exitCode = 1;
-      return;
+      if (failed.length > 0 || r.status === 'blocked') process.exitCode = 1;
+      return;
     } catch (err) {
       console.error(`${red}${err && err.message ? err.message : 'Falha ao executar runtime.'}${reset}`);
       process.exit(1);

package/docs/RELEASE-READINESS.md

@@ -8,6 +8,7 @@ Este é o contrato mínimo para publicar uma versão estável do OXE sem drift e
 npm test
 npm run scan:assets
 npm run build:vscode-ext
+npm run release:pack-check
 npx oxe-cc doctor --release --write-manifest
 ```
 
@@ -21,6 +22,7 @@ O `doctor --release` deve bloquear a publicação quando encontrar:
 - wrappers dirty após `sync-runtime-metadata` e `sync:cursor`
 - drift semântico entre workflows canónicos e superfícies geradas
 - ausência ou falha dos relatórios obrigatórios da release
+- tarball npm contendo `.tgz`, `.vsix`, `.oxe/` ou sem arquivos obrigatórios do pacote
 
 ## Relatórios obrigatórios
 
@@ -28,8 +30,10 @@ Todos os artefatos abaixo devem existir em `.oxe/release/`:
 
 - `release-manifest.json`
 - `runtime-smoke-report.json`
+- `runtime-real-report.json`
 - `recovery-fixture-report.json`
 - `multi-agent-soak-report.json`
+- `multi-agent-real-report.json` para versões `>=1.9.1`
 
 ## Defaults estáveis desta publicação
 
@@ -44,7 +48,8 @@ O pipeline de CI e o pipeline de release devem rodar o mesmo gate:
 
 1. `npm test`
 2. `npm run scan:assets`
-3. `npm run release:doctor`
+3. `npm run release:pack-check`
+4. `npm run release:doctor`
 
 Se qualquer etapa falhar, a release não está pronta.