oxe-cc 0.6.6 → 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 = [
@@ -23,10 +25,11 @@ const ALLOWED_CONFIG_KEYS = [
   'security_in_verify',
   'install',
   'plugins',
-  'workstreams',
-  'milestones',
-  'scale_adaptive',
-];
+  'workstreams',
+  'milestones',
+  'scale_adaptive',
+  'azure',
+];
 
 /**
  * Profiles de execução OXE que controlam rigor do workflow.
@@ -125,9 +128,17 @@ function loadOxeConfigMerged(targetProject) {
     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 {
@@ -226,11 +237,49 @@ function validateConfigShape(cfg) {
   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
@@ -310,6 +359,19 @@ function parseActiveSession(stateText) {
   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
@@ -339,14 +401,26 @@ function oxePaths(target) {
   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'),
+    plan: path.join(oxe, 'PLAN.md'),
     quick: path.join(oxe, 'QUICK.md'),
     verify: path.join(oxe, 'VERIFY.md'),
     discuss: path.join(oxe, 'DISCUSS.md'),
@@ -371,6 +445,15 @@ function scopedOxePaths(target, 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'),
@@ -637,6 +720,113 @@ function installationCompletenessWarnings(target) {
   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;
 }
 
@@ -653,8 +843,9 @@ function suggestNextStep(target, cfg = {}) {
   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)));
-
-  if (!has(p.oxe) || !has(p.state)) {
+  const azureActive = azure.isAzureContextEnabled(target, cfg);
+
+  if (!has(p.oxe) || !has(p.state)) {
     return {
       step: 'scan',
       cursorCmd: '/oxe-scan',
@@ -665,16 +856,54 @@ function suggestNextStep(target, cfg = {}) {
 
   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',
@@ -719,8 +948,53 @@ function suggestNextStep(target, cfg = {}) {
       artifacts: ['.oxe/PLAN.md', '.oxe/STATE.md'],
     };
   }
-
-  if (!has(p.verify)) {
+
+  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',
@@ -813,10 +1087,13 @@ function buildHealthReport(target) {
   const retroDate = parseLastRetroDate(stateText);
   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),
@@ -825,14 +1102,53 @@ function buildHealthReport(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 + specWarn.length + planWarn.length + sessionWarn.length + installWarn.length + (sumWarn ? 1 : 0);
+    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 {
@@ -849,17 +1165,40 @@ function buildHealthReport(target) {
     retroDate,
     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,
-  };
+    scanFocusGlobs: config.scan_focus_globs,
+    scanIgnoreGlobs: config.scan_ignore_globs,
+  };
 }
 
 module.exports = {
@@ -878,12 +1217,17 @@ module.exports = {
   parseLastCompactDate,
   parseLastRetroDate,
   parseActiveSession,
+  parsePlanReviewStatus,
   isStaleScan,
   isStaleLessons,
   planAgentsWarnings,
   installationCompletenessWarnings,
   parsePlanSelfEvaluation,
   planSelfEvaluationWarnings,
+  runtimeWarnings,
+  planReviewWarnings,
+  capabilityWarnings,
+  investigationWarnings,
   phaseCoherenceWarnings,
   verifyGapsWithoutSummaryWarning,
   specSectionWarnings,