oxe-cc 1.8.3 → 1.10.0

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,26 +905,49 @@ 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,
+      health: 'unknown',
+      nextAction: 'Execute ou compile uma run antes de inspecionar status multi-agent.',
+      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 handoffs = readJsonIfExists(handoffsPath);
-  const arbitrationResults = readJsonIfExists(arbitrationPath);
-  return {
+  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);
+  const mergeBlockers = workspaceMergeReport && Array.isArray(workspaceMergeReport.blockers) ? workspaceMergeReport.blockers : [];
+  const mergeReadiness = workspaceMergeReport && workspaceMergeReport.merge_readiness ? workspaceMergeReport.merge_readiness : null;
+  let nextAction = null;
+  if (!state) {
+    nextAction = 'Execute runtime com plan-agents.json válido para materializar o estado multi-agent.';
+  } else if (mergeBlockers.length > 0) {
+    nextAction = 'Resolva os merge blockers do workspace antes de promover ou aplicar novos resultados.';
+  } else if (mergeReadiness === 'partial') {
+    nextAction = 'Conclua verify/evidence pós-merge ou aplique os worktrees pendentes antes de fechar a run.';
+  } else if (mergeReadiness === 'ready') {
+    nextAction = 'Multi-agent merge pronto; avance para runtime verify ou promotion conforme o ciclo.';
+  }
+  return {
     path: statePath,
     enabled: Boolean(state),
     runId,
@@ -860,11 +956,44 @@ function readRuntimeMultiAgentStatus(projectRoot, activeSession, options = {}) {
     agents: state && Array.isArray(state.agent_results) ? state.agent_results : [],
     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,
-  };
-}
+    handoffs: Array.isArray(handoffs) ? handoffs : [],
+    arbitrationResults: Array.isArray(arbitrationResults) ? arbitrationResults : [],
+    workspaceMergeReport: workspaceMergeReport || null,
+    worktrees: workspaceMergeReport && Array.isArray(workspaceMergeReport.records) ? workspaceMergeReport.records : [],
+    mergeBlockers,
+    mergeReadiness,
+    arbitrationRequired: Boolean(workspaceMergeReport && workspaceMergeReport.arbitration_required),
+    health: summary && summary.health ? summary.health : (mergeBlockers.length > 0 ? 'degraded' : 'unknown'),
+    nextAction,
+    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 +1019,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 +1031,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 +1222,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 +1595,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 +2484,9 @@ module.exports = {
   buildRecoveryConsistency,
   readRuntimeGates,
   resolveRuntimeGate,
-  createExecutionContext,
-  runRuntimeExecute,
+  createExecutionContext,
+  buildRuntimeExecutePreflight,
+  runRuntimeExecute,
   runRuntimeVerify,
   projectRuntimeArtifacts,
   runRuntimeCiChecks,

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

@@ -658,6 +658,8 @@ function oxePaths(target) {
     referenceAnchors: path.join(oxe, 'REFERENCE-ANCHORS.md'),
     fixturePackMd: path.join(oxe, 'FIXTURE-PACK.md'),
     fixturePackJson: path.join(oxe, 'FIXTURE-PACK.json'),
+    visualInputsMd: path.join(oxe, 'investigations', 'visual', 'VISUAL-INPUTS.md'),
+    visualInputsJson: path.join(oxe, 'investigations', 'visual', 'VISUAL-INPUTS.json'),
     quick: path.join(oxe, 'QUICK.md'),
     verify: path.join(oxe, 'VERIFY.md'),
     discuss: path.join(oxe, 'DISCUSS.md'),
@@ -700,6 +702,8 @@ function scopedOxePaths(target, activeSession) {
     referenceAnchors: path.join(sessionRoot, 'plan', 'REFERENCE-ANCHORS.md'),
     fixturePackMd: path.join(sessionRoot, 'plan', 'FIXTURE-PACK.md'),
     fixturePackJson: path.join(sessionRoot, 'plan', 'FIXTURE-PACK.json'),
+    visualInputsMd: path.join(sessionRoot, 'research', 'investigations', 'visual', 'VISUAL-INPUTS.md'),
+    visualInputsJson: path.join(sessionRoot, 'research', 'investigations', 'visual', 'VISUAL-INPUTS.json'),
     quick: path.join(sessionRoot, 'plan', 'QUICK.md'),
     verify: path.join(sessionRoot, 'verification', 'VERIFY.md'),
     summary: path.join(sessionRoot, 'verification', 'SUMMARY.md'),
@@ -741,6 +745,8 @@ function resolvedReadableOxePaths(target, activeSession) {
     referenceAnchors: preferScoped('referenceAnchors'),
     fixturePackMd: preferScoped('fixturePackMd'),
     fixturePackJson: preferScoped('fixturePackJson'),
+    visualInputsMd: preferScoped('visualInputsMd'),
+    visualInputsJson: preferScoped('visualInputsJson'),
     quick: preferScoped('quick'),
     verify: preferScoped('verify'),
     summary: preferScoped('summary'),
@@ -1317,8 +1323,8 @@ function listOxePromptFiles(dir) {
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && /^oxe-.*\.prompt\.md$/i.test(entry.name))
-    .map((entry) => path.join(dir, entry.name))
+    .filter((entry) => entry.isFile() && (entry.name === 'oxe.prompt.md' || /^oxe-.*\.prompt\.md$/i.test(entry.name)))
+    .map((entry) => path.join(dir, entry.name))
     .sort();
 }
 
@@ -1439,9 +1445,9 @@ function copilotIntegrationReport(target) {
   if (legacyHasOxeBlock) {
     warnings.push('Bloco OXE legado detectado em ~/.copilot/copilot-instructions.md');
   }
-  if (legacyHasOtherManagedBlocks) {
-    warnings.push('copilot-instructions global contém blocos geridos por outro framework; isso pode contaminar respostas do Copilot');
-  }
+  if (legacyHasOtherManagedBlocks) {
+    warnings.push('copilot-instructions global contém blocos geridos por outro framework; isso pode contaminar respostas do Copilot — execute `oxe-cc uninstall --copilot-legacy-clean` se quiser limpar o legado global.');
+  }
   if (!manifestRaw.ok && fs.existsSync(workspace.manifest)) {
     warnings.push(`Manifesto Copilot VS Code inválido: ${manifestRaw.error}`);
   } else if (!fs.existsSync(workspace.manifest) && workspacePromptFiles.length > 0) {
@@ -1856,11 +1862,14 @@ function planSelfEvaluationWarnings(planPath, threshold) {
  *   implementationPackReady: boolean,
  *   referenceAnchorsReady: boolean,
  *   fixturePackReady: boolean,
+ *   visualInputReadiness?: string,
+ *   visualInputsReady?: boolean,
  *   executionRationalityReady: boolean,
  *   criticalExecutionGaps: string[],
  *   implementationPack: { path?: string | null, tasks?: unknown[] } | null,
  *   referenceAnchors: { path?: string | null, anchors?: unknown[], missingCriticalCount?: number } | null,
  *   fixturePack: { path?: string | null, fixtures?: unknown[] } | null,
+ *   visualInputs?: { path?: string | null, inputCount?: number, criticalInputCount?: number } | null,
  * }} summary
  * @returns {string[]}
  */
@@ -1877,6 +1886,9 @@ function executionRationalityWarningsFromSummary(summary) {
   if (!summary.fixturePackReady) {
     warns.push(`FIXTURE-PACK não está pronto em ${summary.fixturePack && summary.fixturePack.path ? summary.fixturePack.path : '.oxe/FIXTURE-PACK.json'}`);
   }
+  if (summary.visualInputReadiness === 'blocked') {
+    warns.push(`VISUAL-INPUTS bloqueado em ${summary.visualInputs && summary.visualInputs.path ? summary.visualInputs.path : '.oxe/investigations/visual/VISUAL-INPUTS.json'}`);
+  }
   if (Array.isArray(summary.criticalExecutionGaps) && summary.criticalExecutionGaps.length) {
     warns.push(...summary.criticalExecutionGaps);
   }
@@ -2070,8 +2082,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',
       ],
     };
   }
@@ -2189,6 +2203,9 @@ function suggestNextStep(target, cfg = {}) {
     referenceAnchors: p.referenceAnchors,
     fixturePackJson: p.fixturePackJson,
     fixturePackMd: p.fixturePackMd,
+    spec: p.spec,
+    visualInputsJson: p.visualInputsJson,
+    visualInputsMd: p.visualInputsMd,
   });
   if (
     shouldEnforceExecutionRationalityGate(phase)
@@ -2366,6 +2383,9 @@ function buildHealthReport(target) {
     referenceAnchors: p.referenceAnchors,
     fixturePackJson: p.fixturePackJson,
     fixturePackMd: p.fixturePackMd,
+    spec: p.spec,
+    visualInputsJson: p.visualInputsJson,
+    visualInputsMd: p.visualInputsMd,
   });
   const suppressExecutionWorkspaceGates = shouldSuppressExecutionWorkspaceGates(
     workspaceInfo.workspaceMode,
@@ -2518,10 +2538,22 @@ function buildHealthReport(target) {
         contextQuality.primaryStatus = contextPacks[firstWorkflow].context_quality.status;
       }
     }
-  } catch (err) {
-    contextWarn.push(`Contexto — falha ao inspecionar context packs: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const semanticsManifest = readJsonFileSafe(base.runtimeSemanticsManifest);
+  } catch (err) {
+    contextWarn.push(`Contexto — falha ao inspecionar context packs: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (suppressExecutionWorkspaceGates) {
+    for (const key of Object.keys(contextPacks)) delete contextPacks[key];
+    for (const key of Object.keys(packFreshness)) delete packFreshness[key];
+    contextWarn.length = 0;
+    activeSummaryRefs = { project: null, session: null, phase: null };
+    contextQuality = {
+      primaryWorkflow: 'release',
+      primaryScore: null,
+      primaryStatus: 'not_applicable',
+      byWorkflow: {},
+    };
+  }
+  const semanticsManifest = readJsonFileSafe(base.runtimeSemanticsManifest);
   const semanticsAudit = runtimeSemantics.auditRuntimeTargets(target);
   /** @type {string[]} */
   const semanticsWarn = [];
@@ -2624,6 +2656,8 @@ function buildHealthReport(target) {
     implementationPackReady: executionRationality.implementationPackReady,
     referenceAnchorsReady: executionRationality.referenceAnchorsReady,
     fixturePackReady: executionRationality.fixturePackReady,
+    visualInputReadiness: executionRationality.visualInputReadiness,
+    visualInputsReady: executionRationality.visualInputsReady,
     executionRationalityReady: executionRationality.executionRationalityReady,
     criticalExecutionGaps: executionRationality.criticalExecutionGaps,
     executionRationality,