oxe-cc 1.5.0 → 1.6.0

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

@@ -1,10 +1,11 @@
 'use strict';
 
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const operational = require('./oxe-operational.cjs');
-const azure = require('./oxe-azure.cjs');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const operational = require('./oxe-operational.cjs');
+const azure = require('./oxe-azure.cjs');
+const rationality = require('./oxe-rationality.cjs');
 
 /** @type {string[]} */
 const ALLOWED_CONFIG_KEYS = [
@@ -55,15 +56,75 @@ const INSTALL_REPO_LAYOUTS = ['nested', 'classic'];
 /** @type {string[]} */
 const INSTALL_OBJECT_KEYS = ['profile', 'repo_layout', 'ide_scope', 'vscode', 'include_commands_dir', 'include_agents_md'];
 
-const EXPECTED_CODEBASE_MAPS = [
-  'OVERVIEW.md',
-  'STACK.md',
-  'STRUCTURE.md',
-  'TESTING.md',
-  'INTEGRATIONS.md',
-  'CONVENTIONS.md',
-  'CONCERNS.md',
-];
+const EXPECTED_CODEBASE_MAPS = [
+  'OVERVIEW.md',
+  'STACK.md',
+  'STRUCTURE.md',
+  'TESTING.md',
+  'INTEGRATIONS.md',
+  'CONVENTIONS.md',
+  'CONCERNS.md',
+];
+
+const MIN_EXECUTABLE_PLAN_CONFIDENCE = 90;
+
+/**
+ * @param {unknown} value
+ * @returns {number}
+ */
+function normalizePlanConfidenceThreshold(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return MIN_EXECUTABLE_PLAN_CONFIDENCE;
+  return Math.max(MIN_EXECUTABLE_PLAN_CONFIDENCE, parsed);
+}
+
+/**
+ * @param {number | null | undefined} confidence
+ * @param {number} threshold
+ * @returns {boolean}
+ */
+function isExecutablePlanConfidence(confidence, threshold) {
+  return Number.isFinite(confidence) && Number(confidence) > normalizePlanConfidenceThreshold(threshold);
+}
+
+/**
+ * O gate racional só deve bloquear antes da primeira mutação real.
+ * Depois que a execução entrou em curso ou já foi verificada, os packs
+ * continuam úteis para diagnóstico, mas não podem reescrever o próximo passo.
+ *
+ * @param {string | null} phase
+ * @returns {boolean}
+ */
+function shouldEnforceExecutionRationalityGate(phase) {
+  const low = String(phase || '').trim().toLowerCase();
+  return !new Set([
+    'executing',
+    'verifying',
+    'verify_complete',
+    'verify_failed',
+    'retro_complete',
+  ]).has(low);
+}
+
+/**
+ * @param {{
+ *   hasSection: boolean,
+ *   bestPlan: string | null,
+ *   confidence: number | null,
+ *   warnings: string[],
+ * }} info
+ * @param {number} threshold
+ * @returns {boolean}
+ */
+function hasExecutablePlanSelfEvaluation(info, threshold) {
+  return Boolean(
+    info
+    && info.hasSection
+    && info.bestPlan === 'sim'
+    && !info.warnings.length
+    && isExecutablePlanConfidence(info.confidence, threshold)
+  );
+}
 
 /**
  * @param {string} targetProject
@@ -143,9 +204,9 @@ function loadOxeConfigMerged(targetProject) {
     discuss_before_plan: false,
     after_verify_suggest_pr: true,
     after_verify_draft_commit: true,
-    after_verify_suggest_uat: false,
-    verification_depth: 'standard',
-    plan_confidence_threshold: 70,
+    after_verify_suggest_uat: false,
+    verification_depth: 'standard',
+    plan_confidence_threshold: 90,
     default_verify_command: '',
     scan_max_age_days: 0,
     compact_max_age_days: 0,
@@ -590,10 +651,15 @@ function oxePaths(target) {
     events: path.join(oxe, 'OXE-EVENTS.ndjson'),
     copilotManifest: path.join(oxe, 'install', 'copilot-vscode.json'),
     runtimeSemanticsManifest: path.join(oxe, 'install', 'runtime-semantics.json'),
-    spec: path.join(oxe, 'SPEC.md'),
-    plan: path.join(oxe, 'PLAN.md'),
-    quick: path.join(oxe, 'QUICK.md'),
-    verify: path.join(oxe, 'VERIFY.md'),
+    spec: path.join(oxe, 'SPEC.md'),
+    plan: path.join(oxe, 'PLAN.md'),
+    implementationPackMd: path.join(oxe, 'IMPLEMENTATION-PACK.md'),
+    implementationPackJson: path.join(oxe, 'IMPLEMENTATION-PACK.json'),
+    referenceAnchors: path.join(oxe, 'REFERENCE-ANCHORS.md'),
+    fixturePackMd: path.join(oxe, 'FIXTURE-PACK.md'),
+    fixturePackJson: path.join(oxe, 'FIXTURE-PACK.json'),
+    quick: path.join(oxe, 'QUICK.md'),
+    verify: path.join(oxe, 'VERIFY.md'),
     discuss: path.join(oxe, 'DISCUSS.md'),
     summary: path.join(oxe, 'SUMMARY.md'),
     codebase: path.join(oxe, 'codebase'),
@@ -606,11 +672,11 @@ function oxePaths(target) {
  * @param {string} target
  * @param {string | null} activeSession
  */
-function scopedOxePaths(target, activeSession) {
-  const base = oxePaths(target);
-  if (!activeSession) return { ...base, activeSession: null, scopedRoot: base.oxe };
-  const sessionRoot = path.join(base.oxe, ...activeSession.split('/'));
-  return {
+function scopedOxePaths(target, activeSession) {
+  const base = oxePaths(target);
+  if (!activeSession) return { ...base, activeSession: null, scopedRoot: base.oxe };
+  const sessionRoot = path.join(base.oxe, ...activeSession.split('/'));
+  return {
     ...base,
     activeSession,
     scopedRoot: sessionRoot,
@@ -625,15 +691,105 @@ function scopedOxePaths(target, activeSession) {
     events: path.join(sessionRoot, 'execution', 'OXE-EVENTS.ndjson'),
     investigationsIndex: path.join(sessionRoot, 'research', 'INVESTIGATIONS.md'),
     investigationsDir: path.join(sessionRoot, 'research', 'investigations'),
-    spec: path.join(sessionRoot, 'spec', 'SPEC.md'),
-    discuss: path.join(sessionRoot, 'spec', 'DISCUSS.md'),
-    plan: path.join(sessionRoot, 'plan', 'PLAN.md'),
-    quick: path.join(sessionRoot, 'plan', 'QUICK.md'),
-    verify: path.join(sessionRoot, 'verification', 'VERIFY.md'),
+    spec: path.join(sessionRoot, 'spec', 'SPEC.md'),
+    discuss: path.join(sessionRoot, 'spec', 'DISCUSS.md'),
+    plan: path.join(sessionRoot, 'plan', 'PLAN.md'),
+    planAgents: path.join(sessionRoot, 'plan', 'plan-agents.json'),
+    implementationPackMd: path.join(sessionRoot, 'plan', 'IMPLEMENTATION-PACK.md'),
+    implementationPackJson: path.join(sessionRoot, 'plan', 'IMPLEMENTATION-PACK.json'),
+    referenceAnchors: path.join(sessionRoot, 'plan', 'REFERENCE-ANCHORS.md'),
+    fixturePackMd: path.join(sessionRoot, 'plan', 'FIXTURE-PACK.md'),
+    fixturePackJson: path.join(sessionRoot, 'plan', 'FIXTURE-PACK.json'),
+    quick: path.join(sessionRoot, 'plan', 'QUICK.md'),
+    verify: path.join(sessionRoot, 'verification', 'VERIFY.md'),
     summary: path.join(sessionRoot, 'verification', 'SUMMARY.md'),
-    executionState: path.join(sessionRoot, 'execution', 'STATE.md'),
-  };
-}
+    executionState: path.join(sessionRoot, 'execution', 'STATE.md'),
+  };
+}
+
+/**
+ * Para leitura, preferimos o layout session-scoped quando ele existe.
+ * Enquanto a migração não é total, mantemos fallback explícito para os
+ * artefatos canónicos ainda materializados na raiz `.oxe/`.
+ *
+ * @param {string} target
+ * @param {string | null} activeSession
+ */
+function resolvedReadableOxePaths(target, activeSession) {
+  const base = oxePaths(target);
+  const scoped = scopedOxePaths(target, activeSession);
+  if (!activeSession) return scoped;
+  /**
+   * @param {string} key
+   * @returns {string}
+   */
+  function preferScoped(key) {
+    return fs.existsSync(scoped[key]) ? scoped[key] : base[key];
+  }
+  return {
+    ...scoped,
+    planReview: preferScoped('planReview'),
+    planReviewComments: preferScoped('planReviewComments'),
+    runtime: preferScoped('runtime'),
+    checkpoints: preferScoped('checkpoints'),
+    spec: preferScoped('spec'),
+    discuss: preferScoped('discuss'),
+    plan: preferScoped('plan'),
+    planAgents: preferScoped('planAgents'),
+    implementationPackMd: preferScoped('implementationPackMd'),
+    implementationPackJson: preferScoped('implementationPackJson'),
+    referenceAnchors: preferScoped('referenceAnchors'),
+    fixturePackMd: preferScoped('fixturePackMd'),
+    fixturePackJson: preferScoped('fixturePackJson'),
+    quick: preferScoped('quick'),
+    verify: preferScoped('verify'),
+    summary: preferScoped('summary'),
+  };
+}
+
+/**
+ * @param {string} target
+ * @returns {{ workspaceMode: 'product_package' | 'oxe_project', packageName: string | null, canonicalTreePresent: boolean, commandsTreePresent: boolean }}
+ */
+function detectWorkspaceMode(target) {
+  const packageJsonPath = path.join(target, 'package.json');
+  let packageName = null;
+  try {
+    if (fs.existsSync(packageJsonPath)) {
+      const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      packageName = parsed && typeof parsed.name === 'string' ? parsed.name : null;
+    }
+  } catch {
+    packageName = null;
+  }
+  const canonicalTreePresent = fs.existsSync(path.join(target, 'oxe', 'workflows'));
+  const commandsTreePresent = fs.existsSync(path.join(target, 'commands', 'oxe'));
+  const packageRepo =
+    packageName === 'oxe-cc'
+    && fs.existsSync(path.join(target, 'bin', 'oxe-cc.js'))
+    && fs.existsSync(path.join(target, 'packages', 'runtime', 'package.json'))
+    && canonicalTreePresent;
+  return {
+    workspaceMode: packageRepo ? 'product_package' : 'oxe_project',
+    packageName,
+    canonicalTreePresent,
+    commandsTreePresent,
+  };
+}
+
+/**
+ * @param {'product_package' | 'oxe_project'} workspaceMode
+ * @param {string | null} phase
+ * @param {string | null} activeSession
+ * @param {Record<string, unknown> | null} activeRun
+ * @returns {boolean}
+ */
+function shouldSuppressExecutionWorkspaceGates(workspaceMode, phase, activeSession, activeRun) {
+  if (workspaceMode !== 'product_package') return false;
+  if (activeSession) return false;
+  if (activeRun && typeof activeRun === 'object') return false;
+  return !phase || phase === 'initial';
+}
 
 /**
  * @param {string} target
@@ -1436,10 +1592,10 @@ function planWaveWarningsFixed(planPath, maxPerWave) {
  *   warnings: string[],
  * }}
  */
-function parsePlanSelfEvaluation(planPath) {
-  const empty = { hasSection: false, bestPlan: null, confidence: null, warnings: [] };
-  if (!fs.existsSync(planPath)) return empty;
-  const raw = fs.readFileSync(planPath, 'utf8');
+function parsePlanSelfEvaluation(planPath) {
+  const empty = { hasSection: false, bestPlan: null, confidence: null, warnings: [] };
+  if (!fs.existsSync(planPath)) return empty;
+  const raw = fs.readFileSync(planPath, 'utf8');
   const m = raw.match(/##\s*Autoavaliação do Plano\s*([\s\S]*?)(?=\n## |\n#[^\#]|$)/i);
   if (!m) {
     return {
@@ -1447,27 +1603,60 @@ function parsePlanSelfEvaluation(planPath) {
       warnings: ['PLAN.md sem a seção obrigatória "## Autoavaliação do Plano"'],
     };
   }
-  const body = m[1];
-  const best = body.match(/\*\*Melhor plano atual:\*\*\s*(sim|não|nao)/i);
-  const confidence = body.match(/\*\*Confiança:\*\*\s*(\d{1,3})\s*%/i);
-  /** @type {string[]} */
-  const warnings = [];
-  const rubricLabels = [
-    'Completude dos requisitos',
+  const body = m[1];
+  const best = body.match(/\*\*Melhor plano atual:\*\*\s*(sim|não|nao)/i);
+  const confidence = body.match(/\*\*Confiança:\*\*\s*(\d{1,3})\s*%/i);
+  const confidenceVector = raw.match(/<confidence_vector\b[\s\S]*?<\/confidence_vector>/i);
+  /** @type {string[]} */
+  const warnings = [];
+  const rubricLabels = [
+    'Completude dos requisitos',
     'Dependências conhecidas',
     'Risco técnico',
     'Impacto no código existente',
     'Clareza da validação / testes',
     'Lacunas externas / decisões pendentes',
   ];
-  if (!best) warnings.push('PLAN.md: autoavaliação sem "Melhor plano atual: sim|não"');
-  if (!confidence) warnings.push('PLAN.md: autoavaliação sem "Confiança: NN%"');
-  if (!/\*\*Principais incertezas:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Principais incertezas"');
-  if (!/\*\*Alternativas descartadas:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Alternativas descartadas"');
-  if (!/\*\*Condição para replanejar:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Condição para replanejar"');
-  for (const label of rubricLabels) {
-    if (!body.includes(label)) warnings.push(`PLAN.md: rubrica sem "${label}"`);
-  }
+  if (!best) warnings.push('PLAN.md: autoavaliação sem "Melhor plano atual: sim|não"');
+  if (!confidence) warnings.push('PLAN.md: autoavaliação sem "Confiança: NN%"');
+  if (!/\*\*Principais incertezas:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Principais incertezas"');
+  if (!/\*\*Alternativas descartadas:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Alternativas descartadas"');
+  if (!/\*\*Condição para replanejar:\*\*/i.test(body)) warnings.push('PLAN.md: autoavaliação sem "Condição para replanejar"');
+  if (!confidenceVector) {
+    warnings.push('PLAN.md: autoavaliação sem bloco <confidence_vector>');
+  } else {
+    const vectorBlock = confidenceVector[0];
+    const vectorGlobal = vectorBlock.match(/<global\b[^>]*score="([0-9.]+)"/i);
+    const requiredDims = [
+      'requirements',
+      'dependencies',
+      'technical_risk',
+      'code_impact',
+      'validation',
+      'open_gaps',
+    ];
+    if (!vectorGlobal) warnings.push('PLAN.md: confidence_vector sem nó <global score="...">');
+    for (const dim of requiredDims) {
+      if (!vectorBlock.includes(`name="${dim}"`)) {
+        warnings.push(`PLAN.md: confidence_vector sem dimensão "${dim}"`);
+      }
+    }
+    if (vectorGlobal) {
+      const vectorGlobalScore = Number(vectorGlobal[1]);
+      if (!Number.isFinite(vectorGlobalScore) || vectorGlobalScore < 0 || vectorGlobalScore > 1) {
+        warnings.push('PLAN.md: confidence_vector com <global score> fora do intervalo 0.0–1.0');
+      } else if (confidence) {
+        const confidencePercent = Number(confidence[1]);
+        const vectorPercent = Math.round(vectorGlobalScore * 100);
+        if (Math.abs(vectorPercent - confidencePercent) > 5) {
+          warnings.push(`PLAN.md: confiança declarada (${confidencePercent}%) diverge do confidence_vector (${vectorPercent}%)`);
+        }
+      }
+    }
+  }
+  for (const label of rubricLabels) {
+    if (!body.includes(label)) warnings.push(`PLAN.md: rubrica sem "${label}"`);
+  }
   const parsedConfidence = confidence ? Number(confidence[1]) : null;
   if (parsedConfidence != null && (parsedConfidence < 0 || parsedConfidence > 100)) {
     warnings.push('PLAN.md: confiança fora do intervalo 0–100%');
@@ -1478,23 +1667,70 @@ function parsePlanSelfEvaluation(planPath) {
     confidence: parsedConfidence,
     warnings,
   };
-}
-
-/**
- * @param {string} planPath
- * @param {number} threshold
- * @returns {string[]}
- */
-function planSelfEvaluationWarnings(planPath, threshold) {
-  const info = parsePlanSelfEvaluation(planPath);
-  const warns = [...info.warnings];
-  if (!fs.existsSync(planPath)) return warns;
-  if (info.bestPlan === 'não') warns.push('PLAN.md: autoavaliação declara que este não é o melhor plano atual');
-  if (info.confidence != null && info.confidence < threshold) {
-    warns.push(`PLAN.md: confiança ${info.confidence}% abaixo do limiar executável (${threshold}%)`);
-  }
-  return warns;
-}
+}
+
+/**
+ * @param {{
+ *   hasSection: boolean,
+ *   bestPlan: string | null,
+ *   confidence: number | null,
+ *   warnings: string[],
+ * }} info
+ * @param {number} threshold
+ * @returns {string[]}
+ */
+function planSelfEvaluationWarningsFromInfo(info, threshold) {
+  const warns = [...info.warnings];
+  if (info.bestPlan === 'não') warns.push('PLAN.md: autoavaliação declara que este não é o melhor plano atual');
+  if (info.confidence != null && !isExecutablePlanConfidence(info.confidence, threshold)) {
+    const normalizedThreshold = normalizePlanConfidenceThreshold(threshold);
+    warns.push(`PLAN.md: confiança ${info.confidence}% não supera o limiar executável (>${normalizedThreshold}%)`);
+  }
+  return warns;
+}
+
+/**
+ * @param {string} planPath
+ * @param {number} threshold
+ * @returns {string[]}
+ */
+function planSelfEvaluationWarnings(planPath, threshold) {
+  if (!fs.existsSync(planPath)) return [];
+  return planSelfEvaluationWarningsFromInfo(parsePlanSelfEvaluation(planPath), threshold);
+}
+
+/**
+ * @param {{
+ *   applicable: boolean,
+ *   implementationPackReady: boolean,
+ *   referenceAnchorsReady: boolean,
+ *   fixturePackReady: 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,
+ * }} summary
+ * @returns {string[]}
+ */
+function executionRationalityWarningsFromSummary(summary) {
+  if (!summary || !summary.applicable) return [];
+  /** @type {string[]} */
+  const warns = [];
+  if (!summary.implementationPackReady) {
+    warns.push(`IMPLEMENTATION-PACK não está pronto em ${summary.implementationPack && summary.implementationPack.path ? summary.implementationPack.path : '.oxe/IMPLEMENTATION-PACK.json'}`);
+  }
+  if (!summary.referenceAnchorsReady) {
+    warns.push(`REFERENCE-ANCHORS não está pronto em ${summary.referenceAnchors && summary.referenceAnchors.path ? summary.referenceAnchors.path : '.oxe/REFERENCE-ANCHORS.md'}`);
+  }
+  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 (Array.isArray(summary.criticalExecutionGaps) && summary.criticalExecutionGaps.length) {
+    warns.push(...summary.criticalExecutionGaps);
+  }
+  return Array.from(new Set(warns));
+}
 
 /**
  * @param {string} target
@@ -1648,17 +1884,20 @@ function planReviewWarnings(stateText, p) {
  * @param {string} target
  * @param {{ discuss_before_plan?: boolean }} cfg
  */
-function suggestNextStep(target, cfg = {}) {
-  const base = oxePaths(target);
-  const stateText = fs.existsSync(base.state) ? fs.readFileSync(base.state, 'utf8') : '';
-  const p = scopedOxePaths(target, parseActiveSession(stateText));
-  const discussBefore = Boolean(cfg.discuss_before_plan);
-  const threshold = Number(cfg.plan_confidence_threshold) || 70;
-  const has = (/** @type {string} */ f) => fs.existsSync(f);
-  const mapsComplete = EXPECTED_CODEBASE_MAPS.every((f) => has(path.join(p.codebase, f)));
-  const azureActive = azure.isAzureContextEnabled(target, cfg);
-
-  if (!has(p.oxe) || !has(p.state)) {
+function suggestNextStep(target, cfg = {}) {
+  const base = oxePaths(target);
+  const stateText = fs.existsSync(base.state) ? fs.readFileSync(base.state, 'utf8') : '';
+  const activeSession = parseActiveSession(stateText);
+  const p = resolvedReadableOxePaths(target, activeSession);
+  const discussBefore = Boolean(cfg.discuss_before_plan);
+  const threshold = normalizePlanConfidenceThreshold(cfg.plan_confidence_threshold);
+  const has = (/** @type {string} */ f) => fs.existsSync(f);
+  const mapsComplete = EXPECTED_CODEBASE_MAPS.every((f) => has(path.join(p.codebase, f)));
+  const azureActive = azure.isAzureContextEnabled(target, cfg);
+  const activeRun = operational.readRunState(target, activeSession);
+  const workspaceInfo = detectWorkspaceMode(target);
+
+  if (!has(p.oxe) || !has(p.state)) {
     return {
       step: 'scan',
       cursorCmd: '/oxe-scan',
@@ -1666,10 +1905,27 @@ function suggestNextStep(target, cfg = {}) {
       artifacts: ['.oxe/'],
     };
   }
-
-  const phase = parseStatePhase(stateText);
-
-  if (!mapsComplete && !has(p.quick)) {
+
+  const phase = parseStatePhase(stateText);
+  if (shouldSuppressExecutionWorkspaceGates(workspaceInfo.workspaceMode, phase, activeSession, activeRun)) {
+    const release = require('./oxe-release.cjs');
+    const readiness = release.inspectReleaseReadiness(target, { packageRoot: target });
+    return {
+      step: 'doctor',
+      cursorCmd: 'oxe-cc doctor --release --write-manifest',
+      reason: readiness.ok
+        ? 'Repositório do pacote OXE detectado — o próximo passo operacional é validar/publicar a release, não replanejar um workspace de entrega.'
+        : `Repositório do pacote OXE detectado — trate primeiro os blockers de release (${readiness.blockers[0] || 'release readiness incompleta'}).`,
+      artifacts: [
+        '.oxe/release/release-manifest.json',
+        '.oxe/release/runtime-smoke-report.json',
+        '.oxe/release/recovery-fixture-report.json',
+        '.oxe/release/multi-agent-soak-report.json',
+      ],
+    };
+  }
+
+  if (!mapsComplete && !has(p.quick)) {
     return {
       step: 'scan',
       cursorCmd: '/oxe-scan',
@@ -1752,17 +2008,49 @@ function suggestNextStep(target, cfg = {}) {
     };
   }
 
-  const selfEval = parsePlanSelfEvaluation(p.plan);
-  if (selfEval.bestPlan === 'não' || (selfEval.confidence != null && selfEval.confidence < threshold)) {
-    return {
-      step: 'plan',
-      cursorCmd: '/oxe-plan --replan',
-      reason: `O plano atual ainda não atingiu confiança executável (limiar ${threshold}%)`,
-      artifacts: ['.oxe/PLAN.md', '.oxe/STATE.md'],
-    };
-  }
-
-  const reviewStatus = parsePlanReviewStatus(stateText);
+  const selfEval = parsePlanSelfEvaluation(p.plan);
+  const selfEvalWarnings = planSelfEvaluationWarningsFromInfo(selfEval, threshold);
+  if (!hasExecutablePlanSelfEvaluation(selfEval, threshold)) {
+    return {
+      step: 'plan',
+      cursorCmd: '/oxe-plan --replan',
+      reason: selfEvalWarnings[0]
+        ? `${selfEvalWarnings[0]} — replaneje antes de executar`
+        : `O plano atual ainda não passou no gate executável (> ${threshold}%)`,
+      artifacts: ['.oxe/PLAN.md', '.oxe/STATE.md'],
+    };
+  }
+
+  const executionRationality = rationality.buildExecutionRationality({
+    plan: p.plan,
+    planAgents: p.planAgents,
+    implementationPackJson: p.implementationPackJson,
+    implementationPackMd: p.implementationPackMd,
+    referenceAnchors: p.referenceAnchors,
+    fixturePackJson: p.fixturePackJson,
+    fixturePackMd: p.fixturePackMd,
+  });
+  if (
+    shouldEnforceExecutionRationalityGate(phase)
+    && executionRationality.applicable
+    && !executionRationality.executionRationalityReady
+  ) {
+    const reason = executionRationality.criticalExecutionGaps[0]
+      || 'Artefatos racionais de execução ainda não estão íntegros';
+    return {
+      step: 'plan',
+      cursorCmd: '/oxe-plan --replan',
+      reason: `${reason} — replaneje antes de executar`,
+      artifacts: [
+        '.oxe/PLAN.md',
+        '.oxe/IMPLEMENTATION-PACK.json',
+        '.oxe/REFERENCE-ANCHORS.md',
+        '.oxe/FIXTURE-PACK.json',
+      ],
+    };
+  }
+
+  const reviewStatus = parsePlanReviewStatus(stateText);
   if (phase === 'plan_ready' && (reviewStatus === 'needs_revision' || reviewStatus === 'rejected')) {
     return {
       step: 'plan',
@@ -1779,9 +2067,7 @@ function suggestNextStep(target, cfg = {}) {
       artifacts: ['.oxe/PLAN.md', '.oxe/PLAN-REVIEW.md', '.oxe/STATE.md'],
     };
   }
-
-  const activeRun = operational.readRunState(target, parseActiveSession(stateText));
-  if (activeRun && activeRun.status === 'waiting_approval') {
+  if (activeRun && activeRun.status === 'waiting_approval') {
     return {
       step: 'dashboard',
       cursorCmd: '/oxe-dashboard',
@@ -1878,7 +2164,7 @@ function suggestNextStep(target, cfg = {}) {
 /**
  * @param {string} target
  */
-function buildHealthReport(target) {
+function buildHealthReport(target) {
   const contextEngine = require('./oxe-context-engine.cjs');
   const runtimeSemantics = require('./oxe-runtime-semantics.cjs');
   const { config, path: cfgPath, parseError } = loadOxeConfigMerged(target);
@@ -1892,10 +2178,11 @@ function buildHealthReport(target) {
       stateText = '';
     }
   }
-  const activeSession = parseActiveSession(stateText);
-  const p = scopedOxePaths(target, activeSession);
-  const phase = parseStatePhase(stateText);
-  const scanDate = parseLastScanDate(stateText);
+  const activeSession = parseActiveSession(stateText);
+  const p = resolvedReadableOxePaths(target, activeSession);
+  const phase = parseStatePhase(stateText);
+  const workspaceInfo = detectWorkspaceMode(target);
+  const scanDate = parseLastScanDate(stateText);
   const stale = isStaleScan(scanDate, Number(config.scan_max_age_days) || 0);
   const compactDate = parseLastCompactDate(stateText);
   const staleCompact = isStaleScan(compactDate, Number(config.compact_max_age_days) || 0);
@@ -1904,24 +2191,54 @@ function buildHealthReport(target) {
   const phaseWarn = phase ? phaseCoherenceWarnings(phase, p) : [];
   const runtimeWarn = runtimeWarnings(stateText, p);
   const sumWarn = verifyGapsWithoutSummaryWarning(p.verify, p.summary);
-  const specReq = Array.isArray(config.spec_required_sections) ? config.spec_required_sections : [];
-  const specWarn = specSectionWarnings(p.spec, specReq.map(String));
-  const threshold = Number(config.plan_confidence_threshold) || 70;
-  const capabilityWarn = capabilityWarnings(p);
-  const investigationWarn = investigationWarnings(p);
-  const planWarn = [
-    ...planWaveWarningsFixed(p.plan, Number(config.plan_max_tasks_per_wave) || 0),
-    ...planTaskAceiteWarnings(p.plan),
-    ...planSelfEvaluationWarnings(p.plan, threshold),
-    ...planAgentsWarnings(target),
-  ];
+  const specReq = Array.isArray(config.spec_required_sections) ? config.spec_required_sections : [];
+  const specWarn = specSectionWarnings(p.spec, specReq.map(String));
+  const threshold = normalizePlanConfidenceThreshold(config.plan_confidence_threshold);
+  const capabilityWarn = capabilityWarnings(p);
+  const investigationWarn = investigationWarnings(p);
+  const parsedPlanSelfEvaluation = parsePlanSelfEvaluation(p.plan);
+  const activeRun = operational.readRunState(target, activeSession);
+  const executionRationality = rationality.buildExecutionRationality({
+    plan: p.plan,
+    planAgents: p.planAgents,
+    implementationPackJson: p.implementationPackJson,
+    implementationPackMd: p.implementationPackMd,
+    referenceAnchors: p.referenceAnchors,
+    fixturePackJson: p.fixturePackJson,
+    fixturePackMd: p.fixturePackMd,
+  });
+  const suppressExecutionWorkspaceGates = shouldSuppressExecutionWorkspaceGates(
+    workspaceInfo.workspaceMode,
+    phase,
+    activeSession,
+    activeRun
+  );
+  const executionPlanWarn = [
+    ...planWaveWarningsFixed(p.plan, Number(config.plan_max_tasks_per_wave) || 0),
+    ...planTaskAceiteWarnings(p.plan),
+    ...planSelfEvaluationWarningsFromInfo(parsedPlanSelfEvaluation, threshold),
+    ...executionRationalityWarningsFromSummary(executionRationality),
+    ...planAgentsWarnings(target),
+  ];
+  const planWarn = suppressExecutionWorkspaceGates ? [] : executionPlanWarn;
   const sessionWarn = sessionWarnings(target, activeSession);
-  const installWarn = installationCompletenessWarnings(target);
-  const copilot = copilotIntegrationReport(target);
-  const copilotWarn = copilot.warnings;
-  const reviewWarn = planReviewWarnings(stateText, p);
-  const planSelfEvaluation = parsePlanSelfEvaluation(p.plan);
-  const activeRun = operational.readRunState(target, activeSession);
+  const installWarn = installationCompletenessWarnings(target);
+  const copilot = copilotIntegrationReport(target);
+  const copilotWarn = copilot.warnings;
+  const reviewWarn = suppressExecutionWorkspaceGates ? [] : planReviewWarnings(stateText, p);
+  const planSelfEvaluation = {
+    ...parsedPlanSelfEvaluation,
+    best_plan_current: parsedPlanSelfEvaluation.bestPlan === 'sim'
+      ? true
+      : parsedPlanSelfEvaluation.bestPlan === 'não'
+        ? false
+        : null,
+    threshold,
+    executable: hasExecutablePlanSelfEvaluation(parsedPlanSelfEvaluation, threshold),
+  };
+  const releaseReadiness = workspaceInfo.workspaceMode === 'product_package'
+    ? require('./oxe-release.cjs').inspectReleaseReadiness(target, { packageRoot: target })
+    : null;
   const eventsSummary = operational.summarizeEvents(operational.readEvents(target, activeSession));
   const memoryLayers = operational.buildMemoryLayers(target, activeSession);
   const enterpriseRuntime = summarizeEnterpriseRuntime(target, activeRun, activeSession, config);
@@ -2068,7 +2385,7 @@ function buildHealthReport(target) {
   if (semanticsAudit.mismatches.length) {
     semanticsWarn.push(`${semanticsAudit.mismatches.length} wrapper(s) com drift semântico detectado.`);
   }
-  const semanticsDrift = {
+  const semanticsDrift = {
     ok: semanticsWarn.length === 0 && semanticsAudit.ok,
     contractVersion: runtimeSemantics.CONTRACT_VERSION,
     manifestPath: base.runtimeSemanticsManifest,
@@ -2090,15 +2407,16 @@ function buildHealthReport(target) {
       ),
     },
   };
-  const hardFailure = Boolean(parseError) || sessionWarn.some((w) => /não existe|sem SESSION\.md/i.test(w));
-  const warningCount =
-    phaseWarn.length +
-    runtimeWarn.length +
-    reviewWarn.length +
-    enterpriseRuntime.enterpriseWarnings.length +
-    specWarn.length +
-    planWarn.length +
-    capabilityWarn.length +
+  const hardFailure = Boolean(parseError) || sessionWarn.some((w) => /não existe|sem SESSION\.md/i.test(w));
+  const planWarningCount = suppressExecutionWorkspaceGates ? 0 : planWarn.length;
+  const warningCount =
+    phaseWarn.length +
+    runtimeWarn.length +
+    reviewWarn.length +
+    enterpriseRuntime.enterpriseWarnings.length +
+    specWarn.length +
+    planWarningCount +
+    capabilityWarn.length +
     investigationWarn.length +
     sessionWarn.length +
     installWarn.length +
@@ -2109,8 +2427,9 @@ function buildHealthReport(target) {
     (sumWarn ? 1 : 0);
   const healthStatus = hardFailure ? 'broken' : warningCount > 0 ? 'warning' : 'healthy';
 
-  return {
-    configPath: cfgPath,
+  return {
+    workspaceMode: workspaceInfo.workspaceMode,
+    configPath: cfgPath,
     configParseError: parseError,
     unknownConfigKeys: shape.unknownKeys,
     typeErrors: shape.typeErrors,
@@ -2135,9 +2454,17 @@ function buildHealthReport(target) {
     copilot,
     summaryGapWarn: sumWarn,
     specWarn,
-    planWarn,
-    planSelfEvaluation,
-    planReviewStatus: parsePlanReviewStatus(stateText),
+    planWarn,
+    planSelfEvaluation,
+    implementationPackReady: executionRationality.implementationPackReady,
+    referenceAnchorsReady: executionRationality.referenceAnchorsReady,
+    fixturePackReady: executionRationality.fixturePackReady,
+    executionRationalityReady: executionRationality.executionRationalityReady,
+    criticalExecutionGaps: executionRationality.criticalExecutionGaps,
+    executionRationality,
+    planConfidenceThreshold: threshold,
+    planConfidenceExecutable: planSelfEvaluation.executable,
+    planReviewStatus: parsePlanReviewStatus(stateText),
     activeRun,
     eventsSummary,
     memoryLayers,
@@ -2175,8 +2502,9 @@ function buildHealthReport(target) {
       : null,
     contextPacks,
     contextQuality,
-    semanticsDrift,
-    packFreshness,
+    semanticsDrift,
+    releaseReadiness,
+    packFreshness,
     activeSummaryRefs,
     healthStatus,
     next,
@@ -2206,22 +2534,29 @@ module.exports = {
   isStaleLessons,
   copilotWorkspacePaths,
   copilotLegacyPaths,
-  copilotIntegrationReport,
-  planAgentsWarnings,
+  copilotIntegrationReport,
+  normalizePlanConfidenceThreshold,
+  isExecutablePlanConfidence,
+  hasExecutablePlanSelfEvaluation,
+  planAgentsWarnings,
   installationCompletenessWarnings,
-  parsePlanSelfEvaluation,
-  planSelfEvaluationWarnings,
-  runtimeWarnings,
-  planReviewWarnings,
+  parsePlanSelfEvaluation,
+  planSelfEvaluationWarnings,
+  executionRationalityWarningsFromSummary,
+  runtimeWarnings,
+  planReviewWarnings,
   capabilityWarnings,
   investigationWarnings,
   phaseCoherenceWarnings,
   verifyGapsWithoutSummaryWarning,
   specSectionWarnings,
-  planWaveWarningsFixed,
-  planTaskAceiteWarnings,
-  suggestNextStep,
-  buildHealthReport,
-  oxePaths,
-  scopedOxePaths,
-};
+  planWaveWarningsFixed,
+  planTaskAceiteWarnings,
+  detectWorkspaceMode,
+  shouldSuppressExecutionWorkspaceGates,
+  suggestNextStep,
+  buildHealthReport,
+  buildExecutionRationality: rationality.buildExecutionRationality,
+  oxePaths,
+  scopedOxePaths,
+};