oxe-cc 1.8.0 → 1.9.1

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

@@ -839,6 +839,18 @@ function codexIntegrationPaths() {
   };
 }
 
+/**
+ * @param {string} target
+ */
+function codexWorkspacePaths(target) {
+  const root = path.resolve(target);
+  return {
+    root,
+    promptsDir: path.join(root, '.codex', 'prompts'),
+    skillsRoot: path.join(root, '.agents', 'skills'),
+  };
+}
+
 /**
  * @param {string} filePath
  */
@@ -1108,11 +1120,21 @@ function summarizeRecoveryState(target, activeSession, activeRun, verificationAr
   };
 }
 
-function summarizeEnterpriseRuntime(target, activeRun, activeSession, config) {
-  const pendingGates = readExecutionGates(target, activeSession);
-  const auditSummary = summarizeAuditTrail(target, activeRun && activeRun.run_id ? activeRun.run_id : null);
-  const runtimeMode = operational.buildRuntimeModeStatus(activeRun);
-  const providerCatalog = operational.buildRuntimeProviderCatalog(target);
+function summarizeEnterpriseRuntime(target, activeRun, activeSession, config) {
+  const pendingGates = readExecutionGates(target, activeSession);
+  const auditSummary = summarizeAuditTrail(target, activeRun && activeRun.run_id ? activeRun.run_id : null);
+  const runtimeModeBase = operational.buildRuntimeModeStatus(activeRun);
+  const providerCatalog = operational.buildRuntimeProviderCatalog(target);
+  const enterprisePackageAvailable = Boolean(providerCatalog && providerCatalog.available);
+  const runtimeMode = enterprisePackageAvailable && runtimeModeBase.enterprise_available === false
+    ? {
+        ...runtimeModeBase,
+        enterprise_available: true,
+        reason: runtimeModeBase.reason === 'Nenhum ACTIVE-RUN encontrado para o escopo atual.'
+          ? 'Runtime enterprise disponível no pacote, mas ainda sem ACTIVE-RUN canónico neste escopo.'
+          : 'Runtime enterprise disponível no pacote; a run atual ainda não materializou artefatos canónicos.',
+      }
+    : runtimeModeBase;
   if (!activeRun || !activeRun.run_id) {
     return {
       runtimeMode,
@@ -1484,9 +1506,16 @@ function copilotIntegrationReport(target) {
  * @param {string} target
  */
 function codexIntegrationReport(target) {
-  const paths = codexIntegrationPaths();
-  const promptFiles = listOxeCodexPromptFiles(paths.promptsDir);
-  const skillDirs = listOxeSkillDirs(paths.skillsRoot);
+  const workspace = codexWorkspacePaths(target);
+  const globalPaths = codexIntegrationPaths();
+  const workspacePromptFiles = listOxeCodexPromptFiles(workspace.promptsDir);
+  const workspaceSkillDirs = listOxeSkillDirs(workspace.skillsRoot);
+  const globalPromptFiles = listOxeCodexPromptFiles(globalPaths.promptsDir);
+  const globalSkillDirs = listOxeSkillDirs(globalPaths.skillsRoot);
+  const workspaceDetected = workspacePromptFiles.length > 0 || workspaceSkillDirs.length > 0;
+  const globalDetected = globalPromptFiles.length > 0 || globalSkillDirs.length > 0;
+  const promptFiles = workspaceDetected ? workspacePromptFiles : globalPromptFiles;
+  const skillDirs = workspaceDetected ? workspaceSkillDirs : globalSkillDirs;
   const promptNames = promptFiles.map((filePath) => path.basename(filePath));
   const skillNames = skillDirs.map((dirPath) => path.basename(dirPath));
   const promptPathWarnings = [];
@@ -1496,11 +1525,15 @@ function codexIntegrationReport(target) {
 
   /** @type {string[]} */
   const warnings = [];
-  const detected = promptFiles.length > 0 || skillDirs.length > 0;
+  const detected = workspaceDetected || globalDetected;
+  const promptSource = workspaceDetected ? 'workspace' : globalDetected ? 'global' : 'missing';
   const commandsReady = promptNames.includes('oxe.md');
   const skillsReady = skillNames.includes('oxe');
+  if (!workspaceDetected && globalDetected) {
+    warnings.push('Codex OXE foi encontrado apenas no ambiente global do usuário; este projeto não tem integração local instalada.');
+  }
   if (detected && promptFiles.length === 0) {
-    warnings.push('Codex tem skills OXE instaladas, mas ~/.codex/prompts não contém prompts OXE; a barra / não listará /oxe.');
+    warnings.push('Codex tem skills OXE instaladas, mas o diretório de prompts ativo não contém prompts OXE; a barra / não listará /oxe.');
   }
   if (promptFiles.length > 0 && !commandsReady) {
     warnings.push('Codex prompts OXE existem, mas o entrypoint principal oxe.md está ausente.');
@@ -1525,11 +1558,28 @@ function codexIntegrationReport(target) {
     detected,
     commandsReady,
     skillsReady,
-    root: paths.root,
-    promptsDir: paths.promptsDir,
-    skillsRoot: paths.skillsRoot,
+    promptSource,
+    root: workspaceDetected ? workspace.root : globalPaths.root,
+    promptsDir: workspaceDetected ? workspace.promptsDir : globalPaths.promptsDir,
+    skillsRoot: workspaceDetected ? workspace.skillsRoot : globalPaths.skillsRoot,
     promptFiles,
     skillDirs,
+    workspace: {
+      root: workspace.root,
+      promptsDir: workspace.promptsDir,
+      skillsRoot: workspace.skillsRoot,
+      promptFiles: workspacePromptFiles,
+      skillDirs: workspaceSkillDirs,
+      detected: workspaceDetected,
+    },
+    global: {
+      root: globalPaths.root,
+      promptsDir: globalPaths.promptsDir,
+      skillsRoot: globalPaths.skillsRoot,
+      promptFiles: globalPromptFiles,
+      skillDirs: globalSkillDirs,
+      detected: globalDetected,
+    },
     warnings,
   };
 }
@@ -2020,18 +2070,29 @@ 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',
       ],
     };
   }
 
+  if (!mapsComplete && !has(p.quick) && !has(p.spec) && !has(p.plan)) {
+    return {
+      step: 'oxe',
+      cursorCmd: '/oxe',
+      reason: 'Projeto recém-inicializado e sem SPEC/PLAN — use a entrada universal para começar o fluxo e escolher o primeiro scan.',
+      artifacts: ['.oxe/STATE.md', '.oxe/codebase/'],
+    };
+  }
+
   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/'],
+    return {
+      step: 'scan',
+      cursorCmd: '/oxe-scan',
+      reason: 'Mapas do codebase incompletos e sem QUICK.md — atualize o contexto com scan',
+      artifacts: ['.oxe/codebase/'],
     };
   }
 

package/bin/lib/oxe-rationality.cjs

@@ -350,14 +350,16 @@ function buildExecutionRationality(paths = {}) {
   const implementationPack = summarizeImplementationPack(paths.implementationPackJson || null, planTasks);
   const referenceAnchors = summarizeReferenceAnchors(paths.referenceAnchors || null, externalRefs);
   const fixturePack = summarizeFixturePack(paths.fixturePackJson || null, planTasks, implementationPack);
-  const criticalExecutionGaps = Array.from(
-    new Set([
-      ...implementationPack.criticalGaps,
-      ...referenceAnchors.criticalGaps,
-      ...fixturePack.criticalGaps,
-    ])
-  );
   const applicable = Boolean(paths.plan && fs.existsSync(paths.plan));
+  const criticalExecutionGaps = applicable
+    ? Array.from(
+      new Set([
+        ...implementationPack.criticalGaps,
+        ...referenceAnchors.criticalGaps,
+        ...fixturePack.criticalGaps,
+      ])
+    )
+    : [];
   return {
     applicable,
     planTaskCount: planTasks.length,

package/bin/lib/oxe-release.cjs

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