oxe-cc 0.6.5 → 0.7.0

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

@@ -1,7 +1,9 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs');
+const path = require('path');
+const operational = require('./oxe-operational.cjs');
+const azure = require('./oxe-azure.cjs');
 
 /** @type {string[]} */
 const ALLOWED_CONFIG_KEYS = [
@@ -17,15 +19,17 @@ const ALLOWED_CONFIG_KEYS = [
   'scan_ignore_globs',
   'spec_required_sections',
   'plan_max_tasks_per_wave',
-  'profile',
-  'verification_depth',
-  'security_in_verify',
+  'profile',
+  'verification_depth',
+  'plan_confidence_threshold',
+  'security_in_verify',
   'install',
   'plugins',
-  'workstreams',
-  'milestones',
-  'scale_adaptive',
-];
+  'workstreams',
+  'milestones',
+  'scale_adaptive',
+  'azure',
+];
 
 /**
  * Profiles de execução OXE que controlam rigor do workflow.
@@ -116,16 +120,25 @@ 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',
-    default_verify_command: '',
+    after_verify_suggest_uat: false,
+    verification_depth: 'standard',
+    plan_confidence_threshold: 70,
+    default_verify_command: '',
     scan_max_age_days: 0,
     compact_max_age_days: 0,
     scan_focus_globs: [],
     scan_ignore_globs: [],
-    spec_required_sections: [],
-    plan_max_tasks_per_wave: 0,
-  };
+    spec_required_sections: [],
+    plan_max_tasks_per_wave: 0,
+    azure: {
+      enabled: false,
+      default_resource_group: '',
+      preferred_locations: [],
+      inventory_max_age_hours: 24,
+      resource_graph_auto_install: true,
+      vpn_required: false,
+    },
+  };
   const p = path.join(targetProject, '.oxe', 'config.json');
   if (!fs.existsSync(p)) return { config: defaults, path: null, parseError: null };
   try {
@@ -211,21 +224,62 @@ function validateConfigShape(cfg) {
       typeErrors.push(`profile deve ser um de: ${EXECUTION_PROFILES.join(', ')}`);
     }
   }
-  if (cfg.verification_depth != null) {
-    if (typeof cfg.verification_depth !== 'string') {
-      typeErrors.push('verification_depth deve ser string');
-    } else if (!VERIFICATION_DEPTHS.includes(cfg.verification_depth)) {
-      typeErrors.push(`verification_depth deve ser um de: ${VERIFICATION_DEPTHS.join(', ')}`);
-    }
-  }
+  if (cfg.verification_depth != null) {
+    if (typeof cfg.verification_depth !== 'string') {
+      typeErrors.push('verification_depth deve ser string');
+    } else if (!VERIFICATION_DEPTHS.includes(cfg.verification_depth)) {
+      typeErrors.push(`verification_depth deve ser um de: ${VERIFICATION_DEPTHS.join(', ')}`);
+    }
+  }
+  if (cfg.plan_confidence_threshold != null && typeof cfg.plan_confidence_threshold !== 'number') {
+    typeErrors.push('plan_confidence_threshold deve ser número (percentual de 0 a 100)');
+  }
   if (cfg.after_verify_suggest_uat != null && typeof cfg.after_verify_suggest_uat !== 'boolean') {
     typeErrors.push('after_verify_suggest_uat deve ser boolean');
   }
-  if (cfg.scale_adaptive != null && typeof cfg.scale_adaptive !== 'boolean') {
-    typeErrors.push('scale_adaptive deve ser boolean');
-  }
-  return { unknownKeys, typeErrors };
-}
+  if (cfg.scale_adaptive != null && typeof cfg.scale_adaptive !== 'boolean') {
+    typeErrors.push('scale_adaptive deve ser boolean');
+  }
+  if (cfg.azure != null) {
+    if (typeof cfg.azure !== 'object' || Array.isArray(cfg.azure)) {
+      typeErrors.push('azure deve ser um objeto');
+    } else {
+      const azureCfg = /** @type {Record<string, unknown>} */ (cfg.azure);
+      const allowedAzureKeys = [
+        'enabled',
+        'default_resource_group',
+        'preferred_locations',
+        'inventory_max_age_hours',
+        'resource_graph_auto_install',
+        'vpn_required',
+      ];
+      for (const key of Object.keys(azureCfg)) {
+        if (!allowedAzureKeys.includes(key)) {
+          typeErrors.push(`azure: chave desconhecida "${key}"`);
+        }
+      }
+      if (azureCfg.enabled != null && typeof azureCfg.enabled !== 'boolean') {
+        typeErrors.push('azure.enabled deve ser boolean');
+      }
+      if (azureCfg.default_resource_group != null && typeof azureCfg.default_resource_group !== 'string') {
+        typeErrors.push('azure.default_resource_group deve ser string');
+      }
+      if (azureCfg.preferred_locations != null && !Array.isArray(azureCfg.preferred_locations)) {
+        typeErrors.push('azure.preferred_locations deve ser array de strings');
+      }
+      if (azureCfg.inventory_max_age_hours != null && typeof azureCfg.inventory_max_age_hours !== 'number') {
+        typeErrors.push('azure.inventory_max_age_hours deve ser número');
+      }
+      if (azureCfg.resource_graph_auto_install != null && typeof azureCfg.resource_graph_auto_install !== 'boolean') {
+        typeErrors.push('azure.resource_graph_auto_install deve ser boolean');
+      }
+      if (azureCfg.vpn_required != null && typeof azureCfg.vpn_required !== 'boolean') {
+        typeErrors.push('azure.vpn_required deve ser boolean');
+      }
+    }
+  }
+  return { unknownKeys, typeErrors };
+}
 
 /**
  * @param {string} stateText
@@ -286,12 +340,38 @@ function parseLastCompactDate(stateText) {
  * @param {string} stateText
  * @returns {Date | null}
  */
-function parseLastRetroDate(stateText) {
-  const m = stateText.match(/\blast_retro\s*:\s*(\d{4}-\d{2}-\d{2})/i);
-  if (!m) return null;
-  const iso = Date.parse(m[1]);
-  return Number.isNaN(iso) ? null : new Date(iso);
-}
+function parseLastRetroDate(stateText) {
+  const m = stateText.match(/\blast_retro\s*:\s*(\d{4}-\d{2}-\d{2})/i);
+  if (!m) return null;
+  const iso = Date.parse(m[1]);
+  return Number.isNaN(iso) ? null : new Date(iso);
+}
+
+/**
+ * @param {string} stateText
+ * @returns {string | null}
+ */
+function parseActiveSession(stateText) {
+  if (!stateText) return null;
+  const m = stateText.match(/\*\*active_session:\*\*\s*`?([^\n`]+?)`?\s*(?:\n|$)/i);
+  if (!m) return null;
+  const raw = m[1].trim();
+  if (!raw || raw === '—' || /^none$/i.test(raw)) return null;
+  return raw.replace(/\\/g, '/');
+}
+
+/**
+ * @param {string} stateText
+ * @returns {string | null}
+ */
+function parsePlanReviewStatus(stateText) {
+  if (!stateText) return null;
+  const m = stateText.match(/\*\*plan_review_status:\*\*\s*`?([^\n`]+?)`?\s*(?:\n|$)/i);
+  if (!m) return null;
+  const raw = m[1].trim();
+  if (!raw || raw === '—' || /^none$/i.test(raw)) return null;
+  return raw;
+}
 
 /**
  * @param {Date | null} scanDate
@@ -316,13 +396,31 @@ function isStaleLessons(retroDate, maxAgeDays) {
 /**
  * @param {string} target
  */
-function oxePaths(target) {
-  const oxe = path.join(target, '.oxe');
-  return {
-    oxe,
-    state: path.join(oxe, 'STATE.md'),
-    spec: path.join(oxe, 'SPEC.md'),
-    plan: path.join(oxe, 'PLAN.md'),
+function oxePaths(target) {
+  const oxe = path.join(target, '.oxe');
+  return {
+    oxe,
+    state: path.join(oxe, 'STATE.md'),
+    runtime: path.join(oxe, 'EXECUTION-RUNTIME.md'),
+    checkpoints: path.join(oxe, 'CHECKPOINTS.md'),
+    capabilitiesIndex: path.join(oxe, 'CAPABILITIES.md'),
+    capabilitiesDir: path.join(oxe, 'capabilities'),
+    investigationsIndex: path.join(oxe, 'INVESTIGATIONS.md'),
+    investigationsDir: path.join(oxe, 'investigations'),
+    dashboardDir: path.join(oxe, 'dashboard'),
+    sessionsIndex: path.join(oxe, 'SESSIONS.md'),
+    globalDir: path.join(oxe, 'global'),
+    globalLessons: path.join(oxe, 'global', 'LESSONS.md'),
+    globalMilestones: path.join(oxe, 'global', 'MILESTONES.md'),
+    globalMilestonesDir: path.join(oxe, 'global', 'milestones'),
+    sessionsDir: path.join(oxe, 'sessions'),
+    planReview: path.join(oxe, 'PLAN-REVIEW.md'),
+    planReviewComments: path.join(oxe, 'plan-review-comments.json'),
+    activeRun: path.join(oxe, 'ACTIVE-RUN.json'),
+    runsDir: path.join(oxe, 'runs'),
+    events: path.join(oxe, 'OXE-EVENTS.ndjson'),
+    spec: path.join(oxe, 'SPEC.md'),
+    plan: path.join(oxe, 'PLAN.md'),
     quick: path.join(oxe, 'QUICK.md'),
     verify: path.join(oxe, 'VERIFY.md'),
     discuss: path.join(oxe, 'DISCUSS.md'),
@@ -330,8 +428,41 @@ function oxePaths(target) {
     codebase: path.join(oxe, 'codebase'),
     lessons: path.join(oxe, 'LESSONS.md'),
     planAgents: path.join(oxe, 'plan-agents.json'),
-  };
-}
+  };
+}
+
+/**
+ * @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 {
+    ...base,
+    activeSession,
+    scopedRoot: sessionRoot,
+    sessionRoot,
+    sessionManifest: path.join(sessionRoot, 'SESSION.md'),
+    planReview: path.join(sessionRoot, 'plan', 'PLAN-REVIEW.md'),
+    planReviewComments: path.join(sessionRoot, 'plan', 'plan-review-comments.json'),
+    runtime: path.join(sessionRoot, 'execution', 'EXECUTION-RUNTIME.md'),
+    checkpoints: path.join(sessionRoot, 'execution', 'CHECKPOINTS.md'),
+    activeRun: path.join(sessionRoot, 'execution', 'ACTIVE-RUN.json'),
+    runsDir: path.join(sessionRoot, 'execution', 'runs'),
+    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'),
+    summary: path.join(sessionRoot, 'verification', 'SUMMARY.md'),
+    executionState: path.join(sessionRoot, 'execution', 'STATE.md'),
+  };
+}
 
 /**
  * Valida o arquivo plan-agents.json (se existir) e retorna avisos.
@@ -459,7 +590,7 @@ function planTaskAceiteWarnings(planPath) {
   return out;
 }
 
-function planWaveWarningsFixed(planPath, maxPerWave) {
+function planWaveWarningsFixed(planPath, maxPerWave) {
   if (!maxPerWave || maxPerWave <= 0 || !fs.existsSync(planPath)) return [];
   const raw = fs.readFileSync(planPath, 'utf8');
   const lines = raw.split('\n');
@@ -480,21 +611,241 @@ function planWaveWarningsFixed(planPath, maxPerWave) {
       w.push(`PLAN.md: onda ${wN} tem ${count} tarefas (máximo configurado: ${maxPerWave} — considere dividir ondas)`);
     }
   }
-  return w;
-}
+  return w;
+}
+
+/**
+ * @param {string} planPath
+ * @returns {{
+ *   hasSection: boolean,
+ *   bestPlan: string | null,
+ *   confidence: number | null,
+ *   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');
+  const m = raw.match(/##\s*Autoavaliação do Plano\s*([\s\S]*?)(?=\n## |\n#[^\#]|$)/i);
+  if (!m) {
+    return {
+      ...empty,
+      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',
+    '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}"`);
+  }
+  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%');
+  }
+  return {
+    hasSection: true,
+    bestPlan: best ? best[1].toLowerCase().replace('nao', 'não') : null,
+    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 {string} target
+ * @param {string | null} activeSession
+ * @returns {string[]}
+ */
+function sessionWarnings(target, activeSession) {
+  if (!activeSession) return [];
+  const base = oxePaths(target);
+  const scoped = scopedOxePaths(target, activeSession);
+  /** @type {string[]} */
+  const warns = [];
+  if (!/^sessions\/s\d{3}-/.test(activeSession)) {
+    warns.push(`active_session "${activeSession}" não segue o formato sessions/sNNN-slug`);
+  }
+  if (!fs.existsSync(scoped.sessionRoot)) {
+    warns.push(`active_session aponta para ${activeSession}, mas a pasta da sessão não existe em .oxe/`);
+    return warns;
+  }
+  if (!fs.existsSync(scoped.sessionManifest)) warns.push(`Sessão ativa ${activeSession} sem SESSION.md`);
+  if (!fs.existsSync(base.sessionsIndex)) warns.push('Sessão ativa definida, mas .oxe/SESSIONS.md não existe');
+  return warns;
+}
+
+/**
+ * @param {string} target
+ * @returns {string[]}
+ */
+function installationCompletenessWarnings(target) {
+  const p = oxePaths(target);
+  /** @type {string[]} */
+  const warns = [];
+  if (!fs.existsSync(p.oxe)) return warns;
+  if (!fs.existsSync(p.globalDir)) warns.push('.oxe/global/ ausente');
+  if (!fs.existsSync(p.globalLessons)) warns.push('.oxe/global/LESSONS.md ausente');
+  if (!fs.existsSync(p.globalMilestones)) warns.push('.oxe/global/MILESTONES.md ausente');
+  if (!fs.existsSync(p.globalMilestonesDir)) warns.push('.oxe/global/milestones/ ausente');
+  if (!fs.existsSync(p.sessionsDir)) warns.push('.oxe/sessions/ ausente');
+  if (!fs.existsSync(p.capabilitiesDir)) warns.push('.oxe/capabilities/ ausente');
+  if (!fs.existsSync(p.capabilitiesIndex)) warns.push('.oxe/CAPABILITIES.md ausente');
+  if (!fs.existsSync(p.investigationsDir)) warns.push('.oxe/investigations/ ausente');
+  if (!fs.existsSync(p.investigationsIndex)) warns.push('.oxe/INVESTIGATIONS.md ausente');
+  if (!fs.existsSync(p.runtime)) warns.push('.oxe/EXECUTION-RUNTIME.md ausente');
+  if (!fs.existsSync(p.checkpoints)) warns.push('.oxe/CHECKPOINTS.md ausente');
+  if (!fs.existsSync(p.activeRun)) warns.push('.oxe/ACTIVE-RUN.json ausente');
+  if (!fs.existsSync(p.runsDir)) warns.push('.oxe/runs/ ausente');
+  if (!fs.existsSync(p.events)) warns.push('.oxe/OXE-EVENTS.ndjson ausente');
+  if (azure.isAzureContextEnabled(target)) {
+    const azurePaths = azure.azurePaths(target);
+    if (!fs.existsSync(azurePaths.root)) warns.push('.oxe/cloud/azure/ ausente');
+    if (!fs.existsSync(azurePaths.operationsDir)) warns.push('.oxe/cloud/azure/operations/ ausente');
+    if (!fs.existsSync(azurePaths.profile)) warns.push('.oxe/cloud/azure/profile.json ausente');
+    if (!fs.existsSync(azurePaths.authStatus)) warns.push('.oxe/cloud/azure/auth-status.json ausente');
+  }
+  return warns;
+}
+
+/**
+ * @param {string} stateText
+ * @param {ReturnType<typeof scopedOxePaths>} p
+ * @returns {string[]}
+ */
+function runtimeWarnings(stateText, p) {
+  /** @type {string[]} */
+  const warns = [];
+  const checkpointPending = /\*\*checkpoint_status:\*\*\s*`?pending_approval`?/i.test(stateText);
+  const runtimeBlocked = /\*\*runtime_status:\*\*\s*`?(blocked|waiting_approval|failed)`?/i.test(stateText);
+  if (checkpointPending && !fs.existsSync(p.checkpoints)) {
+    warns.push('STATE.md indica checkpoint pendente, mas o índice de checkpoints não existe');
+  }
+  if (runtimeBlocked && !fs.existsSync(p.runtime)) {
+    warns.push('STATE.md indica runtime bloqueado, mas EXECUTION-RUNTIME.md não existe');
+  }
+  if (fs.existsSync(p.runtime)) {
+    const raw = fs.readFileSync(p.runtime, 'utf8');
+    if (!/##\s*Checkpoints/i.test(raw)) warns.push('EXECUTION-RUNTIME.md sem seção "Checkpoints"');
+    if (!/##\s*Agentes ativos/i.test(raw)) warns.push('EXECUTION-RUNTIME.md sem seção "Agentes ativos"');
+    if (!/Run ID/i.test(raw)) warns.push('EXECUTION-RUNTIME.md sem referência explícita de Run ID');
+    if (!/Tracing operacional/i.test(raw)) warns.push('EXECUTION-RUNTIME.md sem seção "Tracing operacional"');
+  }
+  if (!fs.existsSync(p.activeRun)) {
+    warns.push('ACTIVE-RUN.json não existe para o escopo atual');
+  }
+  if (!fs.existsSync(p.events)) {
+    warns.push('OXE-EVENTS.ndjson não existe para o escopo atual');
+  }
+  const runState = operational.readRunState(path.dirname(p.oxe), p.activeSession || null);
+  const checkpointRows = [];
+  if (fs.existsSync(p.checkpoints)) {
+    const checkpointText = fs.readFileSync(p.checkpoints, 'utf8');
+    for (const line of checkpointText.split('\n')) {
+      const match = line.match(/^\|\s*(CP-[^|]+)\|\s*[^|]*\|\s*[^|]*\|\s*[^|]*\|\s*([^|]+)\|/i);
+      if (!match) continue;
+      checkpointRows.push({ id: match[1].trim(), status: match[2].trim() });
+    }
+  }
+  for (const warn of operational.runtimeStateWarnings(runState, checkpointRows)) warns.push(warn);
+  return warns;
+}
+
+/**
+ * @param {ReturnType<typeof scopedOxePaths>} p
+ * @returns {string[]}
+ */
+function capabilityWarnings(p) {
+  /** @type {string[]} */
+  const warns = [];
+  if (fs.existsSync(p.capabilitiesDir) && !fs.existsSync(p.capabilitiesIndex)) {
+    warns.push('Existem capabilities em .oxe/capabilities/, mas .oxe/CAPABILITIES.md não existe');
+  }
+  for (const warn of operational.capabilityCatalogWarnings(path.dirname(p.oxe))) warns.push(warn);
+  return warns;
+}
+
+/**
+ * @param {ReturnType<typeof scopedOxePaths>} p
+ * @returns {string[]}
+ */
+function investigationWarnings(p) {
+  /** @type {string[]} */
+  const warns = [];
+  if (fs.existsSync(p.investigationsDir) && !fs.existsSync(p.investigationsIndex)) {
+    warns.push('Existe pasta de investigações, mas falta o índice INVESTIGATIONS.md');
+  }
+  return warns;
+}
+
+/**
+ * @param {string} stateText
+ * @param {ReturnType<typeof scopedOxePaths>} p
+ * @returns {string[]}
+ */
+function planReviewWarnings(stateText, p) {
+  /** @type {string[]} */
+  const warns = [];
+  const reviewStatus = parsePlanReviewStatus(stateText);
+  if (fs.existsSync(p.plan) && !reviewStatus) {
+    warns.push('PLAN.md existe, mas STATE.md não declara plan_review_status');
+  }
+  if (reviewStatus && !fs.existsSync(p.planReview)) {
+    warns.push('STATE.md declara revisão do plano, mas PLAN-REVIEW.md não existe');
+  }
+  if (reviewStatus === 'needs_revision' || reviewStatus === 'rejected') {
+    warns.push(`Plano em estado ${reviewStatus} — revisão adicional necessária antes de executar`);
+  }
+  return warns;
+}
 
 /**
  * Próximo passo único (espelha o workflow next.md).
  * @param {string} target
  * @param {{ discuss_before_plan?: boolean }} cfg
  */
-function suggestNextStep(target, cfg = {}) {
-  const p = oxePaths(target);
-  const discussBefore = Boolean(cfg.discuss_before_plan);
-  const has = (/** @type {string} */ f) => fs.existsSync(f);
-  const mapsComplete = EXPECTED_CODEBASE_MAPS.every((f) => has(path.join(p.codebase, f)));
-
-  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 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)) {
     return {
       step: 'scan',
       cursorCmd: '/oxe-scan',
@@ -503,19 +854,56 @@ function suggestNextStep(target, cfg = {}) {
     };
   }
 
-  const stateText = fs.readFileSync(p.state, 'utf8');
-  const phase = parseStatePhase(stateText);
+  const phase = parseStatePhase(stateText);
 
-  if (!mapsComplete && !has(p.quick)) {
+  if (!mapsComplete && !has(p.quick)) {
     return {
       step: 'scan',
       cursorCmd: '/oxe-scan',
       reason: 'Mapas do codebase incompletos e sem QUICK.md — atualize o contexto com scan',
       artifacts: ['.oxe/codebase/'],
-    };
-  }
-
-  if (phase === 'quick_active' || (has(p.quick) && !has(p.plan))) {
+    };
+  }
+
+  if (azureActive) {
+    const azureHealth = azure.azureDoctor(target, cfg, {
+      autoInstall: false,
+      write: false,
+    });
+    if (!azureHealth.authStatus || !azureHealth.authStatus.login_active) {
+      return {
+        step: 'azure-auth',
+        cursorCmd: 'npx oxe-cc azure auth login',
+        reason: 'Contexto Azure ativo, mas sem sessão Azure CLI autenticada',
+        artifacts: ['.oxe/cloud/azure/profile.json', '.oxe/cloud/azure/auth-status.json'],
+      };
+    }
+    if (!azureHealth.profile || !azureHealth.profile.subscription_id) {
+      return {
+        step: 'azure-auth',
+        cursorCmd: 'npx oxe-cc azure auth set-subscription --subscription <id-ou-nome>',
+        reason: 'Contexto Azure ativo, mas a subscription operacional ainda não está definida',
+        artifacts: ['.oxe/cloud/azure/profile.json', '.oxe/cloud/azure/auth-status.json'],
+      };
+    }
+    const maxAgeHours = cfg.azure && cfg.azure.inventory_max_age_hours != null
+      ? Number(cfg.azure.inventory_max_age_hours)
+      : 24;
+    const syncedAt = Date.parse(String(azureHealth.inventory && azureHealth.inventory.synced_at || ''));
+    const staleInventory =
+      !azureHealth.inventory ||
+      (maxAgeHours > 0 && !Number.isNaN(syncedAt) && ((Date.now() - syncedAt) / (1000 * 60 * 60)) > maxAgeHours);
+    if (staleInventory) {
+      return {
+        step: 'azure-sync',
+        cursorCmd: 'npx oxe-cc azure sync',
+        reason: 'Contexto Azure ativo, mas o inventário está ausente ou stale',
+        artifacts: ['.oxe/cloud/azure/inventory.json', '.oxe/cloud/azure/INVENTORY.md'],
+      };
+    }
+  }
+
+  if (phase === 'quick_active' || (has(p.quick) && !has(p.plan))) {
     return {
       step: 'execute',
       cursorCmd: '/oxe-execute',
@@ -542,16 +930,71 @@ function suggestNextStep(target, cfg = {}) {
     };
   }
 
-  if (!has(p.plan)) {
-    return {
-      step: 'plan',
-      cursorCmd: '/oxe-plan',
-      reason: 'SPEC existe mas PLAN.md não — gere o plano com verificação por tarefa',
-      artifacts: ['.oxe/PLAN.md'],
-    };
-  }
-
-  if (!has(p.verify)) {
+  if (!has(p.plan)) {
+    return {
+      step: 'plan',
+      cursorCmd: '/oxe-plan',
+      reason: 'SPEC existe mas PLAN.md não — gere o plano com verificação por tarefa',
+      artifacts: ['.oxe/PLAN.md'],
+    };
+  }
+
+  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);
+  if (phase === 'plan_ready' && (reviewStatus === 'needs_revision' || reviewStatus === 'rejected')) {
+    return {
+      step: 'plan',
+      cursorCmd: '/oxe-plan --replan',
+      reason: `Revisão do plano em estado ${reviewStatus} — ajuste o plano antes de executar`,
+      artifacts: ['.oxe/PLAN.md', '.oxe/PLAN-REVIEW.md', '.oxe/STATE.md'],
+    };
+  }
+  if (phase === 'plan_ready' && (!reviewStatus || reviewStatus === 'draft' || reviewStatus === 'in_review')) {
+    return {
+      step: 'dashboard',
+      cursorCmd: '/oxe-dashboard',
+      reason: 'Plano pronto, mas ainda não passou por revisão/aprovação visual',
+      artifacts: ['.oxe/PLAN.md', '.oxe/PLAN-REVIEW.md', '.oxe/STATE.md'],
+    };
+  }
+
+  const activeRun = operational.readRunState(target, parseActiveSession(stateText));
+  if (activeRun && activeRun.status === 'waiting_approval') {
+    return {
+      step: 'dashboard',
+      cursorCmd: '/oxe-dashboard',
+      reason: 'ACTIVE-RUN está aguardando aprovação formal antes de continuar',
+      artifacts: ['.oxe/ACTIVE-RUN.json', '.oxe/CHECKPOINTS.md', '.oxe/OXE-EVENTS.ndjson'],
+    };
+  }
+  if (activeRun && activeRun.status === 'paused') {
+    return {
+      step: 'execute',
+      cursorCmd: '/oxe-execute',
+      reason: 'ACTIVE-RUN está pausado — retome a execução a partir do cursor atual',
+      artifacts: ['.oxe/ACTIVE-RUN.json', '.oxe/EXECUTION-RUNTIME.md'],
+    };
+  }
+
+  if (/\*\*checkpoint_status:\*\*\s*`?pending_approval`?/i.test(stateText)) {
+    return {
+      step: 'execute',
+      cursorCmd: '/oxe-execute',
+      reason: 'Há checkpoint pendente de aprovação — resolva a aprovação antes de avançar a execução',
+      artifacts: ['.oxe/CHECKPOINTS.md', '.oxe/STATE.md'],
+    };
+  }
+
+  if (!has(p.verify)) {
     return {
       step: 'execute',
       cursorCmd: '/oxe-execute',
@@ -622,56 +1065,140 @@ function suggestNextStep(target, cfg = {}) {
 /**
  * @param {string} target
  */
-function buildHealthReport(target) {
-  const { config, path: cfgPath, parseError } = loadOxeConfigMerged(target);
-  const shape = validateConfigShape(config);
-  const p = oxePaths(target);
-  let stateText = '';
-  if (fs.existsSync(p.state)) {
-    try {
-      stateText = fs.readFileSync(p.state, 'utf8');
-    } catch {
-      stateText = '';
-    }
-  }
-  const phase = parseStatePhase(stateText);
+function buildHealthReport(target) {
+  const { config, path: cfgPath, parseError } = loadOxeConfigMerged(target);
+  const shape = validateConfigShape(config);
+  const base = oxePaths(target);
+  let stateText = '';
+  if (fs.existsSync(base.state)) {
+    try {
+      stateText = fs.readFileSync(base.state, 'utf8');
+    } catch {
+      stateText = '';
+    }
+  }
+  const activeSession = parseActiveSession(stateText);
+  const p = scopedOxePaths(target, activeSession);
+  const phase = parseStatePhase(stateText);
   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);
   const retroDate = parseLastRetroDate(stateText);
-  const staleLessons = isStaleLessons(retroDate, Number(config.lessons_max_age_days) || 0);
-  const phaseWarn = phase ? phaseCoherenceWarnings(phase, 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 planWarn = [
-    ...planWaveWarningsFixed(p.plan, Number(config.plan_max_tasks_per_wave) || 0),
-    ...planTaskAceiteWarnings(p.plan),
-    ...planAgentsWarnings(target),
-  ];
-  const next = suggestNextStep(target, { discuss_before_plan: config.discuss_before_plan });
-
-  return {
+  const staleLessons = isStaleLessons(retroDate, Number(config.lessons_max_age_days) || 0);
+  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 sessionWarn = sessionWarnings(target, activeSession);
+  const installWarn = installationCompletenessWarnings(target);
+  const reviewWarn = planReviewWarnings(stateText, p);
+  const planSelfEvaluation = parsePlanSelfEvaluation(p.plan);
+  const activeRun = operational.readRunState(target, activeSession);
+  const eventsSummary = operational.summarizeEvents(operational.readEvents(target, activeSession));
+  const memoryLayers = operational.buildMemoryLayers(target, activeSession);
+  const azureActive = azure.isAzureContextEnabled(target, config);
+  const azureReport = azureActive
+    ? azure.azureDoctor(target, config, {
+        autoInstall: false,
+        write: false,
+      })
+    : null;
+  const azureInventorySyncedAt = azureReport && azureReport.inventory ? azureReport.inventory.synced_at || null : null;
+  const azureInventoryMaxAgeHours = config.azure && config.azure.inventory_max_age_hours != null
+    ? Number(config.azure.inventory_max_age_hours)
+    : 24;
+  let azureInventoryStale = { stale: false, hours: null };
+  if (azureInventorySyncedAt) {
+    const syncedAt = Date.parse(String(azureInventorySyncedAt));
+    if (!Number.isNaN(syncedAt)) {
+      const ageHours = Math.floor((Date.now() - syncedAt) / (1000 * 60 * 60));
+      azureInventoryStale = {
+        stale: azureInventoryMaxAgeHours > 0 ? ageHours > azureInventoryMaxAgeHours : false,
+        hours: ageHours,
+      };
+    }
+  } else if (azureActive) {
+    azureInventoryStale = { stale: true, hours: null };
+  }
+  const next = suggestNextStep(target, {
+    discuss_before_plan: config.discuss_before_plan,
+    plan_confidence_threshold: threshold,
+    azure: config.azure,
+  });
+  const hardFailure = Boolean(parseError) || sessionWarn.some((w) => /não existe|sem SESSION\.md/i.test(w));
+  const warningCount =
+    phaseWarn.length +
+    runtimeWarn.length +
+    reviewWarn.length +
+    specWarn.length +
+    planWarn.length +
+    capabilityWarn.length +
+    investigationWarn.length +
+    sessionWarn.length +
+    installWarn.length +
+    (azureReport ? azureReport.warnings.length : 0) +
+    (sumWarn ? 1 : 0);
+  const healthStatus = hardFailure ? 'broken' : warningCount > 0 ? 'warning' : 'healthy';
+
+  return {
     configPath: cfgPath,
     configParseError: parseError,
     unknownConfigKeys: shape.unknownKeys,
-    typeErrors: shape.typeErrors,
-    phase,
-    scanDate,
+    typeErrors: shape.typeErrors,
+    phase,
+    activeSession,
+    scanDate,
     stale,
     compactDate,
     staleCompact,
     retroDate,
-    staleLessons,
-    phaseWarn,
-    summaryGapWarn: sumWarn,
-    specWarn,
-    planWarn,
-    next,
-    scanFocusGlobs: config.scan_focus_globs,
-    scanIgnoreGlobs: config.scan_ignore_globs,
-  };
+    staleLessons,
+    phaseWarn,
+    runtimeWarn,
+    reviewWarn,
+    capabilityWarn,
+    investigationWarn,
+    sessionWarn,
+    installWarn,
+    summaryGapWarn: sumWarn,
+    specWarn,
+    planWarn,
+    planSelfEvaluation,
+    planReviewStatus: parsePlanReviewStatus(stateText),
+    activeRun,
+    eventsSummary,
+    memoryLayers,
+    azureActive,
+    azure: azureReport
+      ? {
+          profile: azureReport.profile,
+          authStatus: azureReport.authStatus,
+          inventorySummary: azureReport.inventorySummary,
+          inventoryPath: azureReport.paths.inventory,
+          operationsPath: azureReport.paths.operationsDir,
+          inventorySyncedAt: azureInventorySyncedAt,
+          inventoryStale: azureInventoryStale,
+          pendingOperations: azure.listAzureOperations(target).filter((operation) => operation.phase === 'waiting_approval').length,
+          lastOperation: azure.listAzureOperations(target)[0] || null,
+          warnings: azureReport.warnings,
+        }
+      : null,
+    healthStatus,
+    next,
+    scanFocusGlobs: config.scan_focus_globs,
+    scanIgnoreGlobs: config.scan_ignore_globs,
+  };
 }
 
 module.exports = {
@@ -686,18 +1213,28 @@ module.exports = {
   loadOxeConfigMerged,
   validateConfigShape,
   parseStatePhase,
-  parseLastScanDate,
-  parseLastCompactDate,
-  parseLastRetroDate,
-  isStaleScan,
-  isStaleLessons,
-  planAgentsWarnings,
-  phaseCoherenceWarnings,
+  parseLastScanDate,
+  parseLastCompactDate,
+  parseLastRetroDate,
+  parseActiveSession,
+  parsePlanReviewStatus,
+  isStaleScan,
+  isStaleLessons,
+  planAgentsWarnings,
+  installationCompletenessWarnings,
+  parsePlanSelfEvaluation,
+  planSelfEvaluationWarnings,
+  runtimeWarnings,
+  planReviewWarnings,
+  capabilityWarnings,
+  investigationWarnings,
+  phaseCoherenceWarnings,
   verifyGapsWithoutSummaryWarning,
   specSectionWarnings,
   planWaveWarningsFixed,
   planTaskAceiteWarnings,
-  suggestNextStep,
-  buildHealthReport,
-  oxePaths,
-};
+  suggestNextStep,
+  buildHealthReport,
+  oxePaths,
+  scopedOxePaths,
+};