oxe-cc 1.8.0 → 1.8.3

package/CHANGELOG.md

@@ -4,6 +4,69 @@ Todas as versões seguem [Semantic Versioning](https://semver.org/). As mudança
 
 ---
 
+## [1.8.3] — 2026-05-04
+
+### Release readiness e higiene de publicação
+
+Esta release consolida a linha `1.8.3` para publicação no npm com foco em consistência de versão, alinhamento documental e pacote distribuído mais limpo.
+
+#### Publicação
+
+- alinhamento da versão `1.8.3` entre manifesto raiz, runtime, extensão VS Code, README e changelog
+- fechamento do gate oficial `doctor --release` para a linha atual
+- preparação do pacote npm para sair sem drift entre versão publicada e documentação principal
+
+#### Higiene do pacote
+
+- exclusão dos arquivos `.vsix` históricos da extensão VS Code do tarball npm
+- manutenção apenas do código-fonte da extensão dentro do pacote, evitando distribuir binários legados desnecessários
+
+## [1.8.2] — 2026-04-30
+
+### Fluxo inicial mais coerente e geração de `spec`/`plan` mais forte
+
+Esta release fecha a linha de robustez do ciclo `install -> status/doctor -> /oxe -> spec -> plan -> execute -> verify` sem abrir nova superfície pública. O foco foi remover ruído operacional em projetos novos e aumentar a densidade executável dos artefatos que o OXE induz.
+
+#### Fluxo operacional
+
+- `install`, `status` e `doctor` passam a convergir em `/oxe` como próximo passo canônico para projetos recém-inicializados
+- `doctor` e `status` deixam de tratar `IMPLEMENTATION-PACK`, `REFERENCE-ANCHORS` e `FIXTURE-PACK` como blocker primário antes de existir `PLAN.md`
+- o relatório racional agora marca o estado sem plano como `não aplicável ainda`, sem contaminar o próximo passo
+- instalações e desinstalações locais por runtime continuam simétricas, com inferência de artefatos locais preservada
+
+#### Indução mais forte de SPEC e PLAN
+
+- `SPEC.template.md` passou a exigir outcome observável, público-alvo, restrições técnicas, setup externo, conteúdo/fluxos obrigatórios e contratos esperados para o plano
+- `PLAN.template.md` ganhou contrato operacional da solução, densidade operacional mínima, `symbols alvo`, `estado/fluxo coberto` e `fixture/anchor obrigatório` por tarefa
+- `oxe/workflows/spec.md` agora força extração explícita de blocos de interface, conteúdo mínimo, interações, responsividade e acessibilidade em demandas de produto/app/UI
+- `oxe/workflows/plan.md` agora endurece o gate de confiança `>90%` para tarefas mutáveis vagas e exige fechamento mais forte de interface, conteúdo, estado persistido, anchors e fixtures em apps/UI estáticos
+
+#### Testes
+
+- novo teste cobrindo o estado racional não bloqueante antes da existência de `PLAN.md`
+- suíte focada de CLI/health atualizada para manter o comportamento novo estável
+
+## [1.8.1] — 2026-04-30
+
+### Hotfix — Gaps implementados no fonte TypeScript (não em arquivos compilados)
+
+A v1.8.0 aplicou as 5 correções críticas diretamente nos arquivos `.js` compilados (`lib/runtime/`), que são sobrescritos a cada `npm run build:runtime`. Esta release porta todas as correções para o fonte TypeScript em `packages/runtime/src/`, tornando-as permanentes.
+
+#### Correções portadas para TypeScript
+
+- **`models/failure.ts`**: `FailureClass` agora inclui `'verify'` e `'llm'` como classes canônicas
+- **`scheduler/scheduler.ts`**: `TaskResult` com campo opcional `completed_by`; `TaskExecutor.execute()` aceita `options?: { previousError? }`; `verifyNode()` importa e chama `verifyRun` da fonte TS; `executeNode()` repassa `options`; `requestGateForNode()` com warning quando manager ausente
+- **`executor/built-in-tools.ts`**: `finishTask` handler + registro em `BUILT_IN_TOOLS`
+- **`executor/action-tool-map.ts`**: `finish_task` injetado universalmente em `selectToolsForActions()`
+- **`executor/node-prompt-builder.ts`**: parâmetro `options`, seção de retry context, instrução `finish_task`
+- **`executor/llm-task-executor.ts`**: detecção de `finish_task`, `completed_by` no retorno, `turn_limit_exhausted` retorna `success: false`
+
+#### Testes
+- 542 testes passando (era 542 na v1.8.0, nenhuma regressão)
+- 36 testes de gaps (gap1–gap5) todos passando contra o código compilado
+
+---
+
 ## [1.8.0] — 2026-04-29
 
 ### Autonomous Execution — 5 Critical Gaps Resolved

package/README.md

@@ -7,7 +7,7 @@
 [![npm](https://img.shields.io/npm/v/oxe-cc.svg?style=flat-square)](https://www.npmjs.com/package/oxe-cc)
 [![license](https://img.shields.io/npm/l/oxe-cc.svg?style=flat-square)](LICENSE)
 
-**Versão:** `1.8.0` · [package.json](package.json)
+**Versão:** `1.8.3` · [package.json](package.json)
 
 **Framework OXE — Orchestrated eXperience Engineering**
 

package/bin/lib/oxe-manifest.cjs

@@ -51,19 +51,26 @@ function writeFileManifest(home, files, version) {
  * Before overwriting with --force, backup files that diverged from last manifest.
  * @param {string} home
  * @param {Record<string, string>} prevManifest
- * @param {{ dryRun: boolean, force: boolean }} opts
- * @param {{ yellow: string, cyan: string, dim: string, reset: string }} colors
- * @returns {string[]} modified paths
- */
-function backupModifiedFromManifest(home, prevManifest, opts, colors) {
-  const { yellow, cyan, dim, reset } = colors;
-  if (!opts.force || opts.dryRun) return [];
-  const modified = [];
-  for (const [absPath, oldHash] of Object.entries(prevManifest)) {
-    if (!fs.existsSync(absPath)) continue;
-    let now;
-    try {
-      now = sha256File(absPath);
+ * @param {{ dryRun: boolean, force: boolean }} opts
+ * @param {{ yellow: string, cyan: string, dim: string, reset: string }} colors
+ * @param {{ scopeRoots?: string[] }} [scope]
+ * @returns {string[]} modified paths
+ */
+function backupModifiedFromManifest(home, prevManifest, opts, colors, scope = {}) {
+  const { yellow, cyan, dim, reset } = colors;
+  if (!opts.force || opts.dryRun) return [];
+  const normalizedRoots = Array.isArray(scope.scopeRoots)
+    ? scope.scopeRoots.map((root) => path.resolve(root))
+    : [];
+  const modified = [];
+  for (const [absPath, oldHash] of Object.entries(prevManifest)) {
+    if (normalizedRoots.length > 0 && !normalizedRoots.some((root) => absPath === root || absPath.startsWith(`${root}${path.sep}`))) {
+      continue;
+    }
+    if (!fs.existsSync(absPath)) continue;
+    let now;
+    try {
+      now = sha256File(absPath);
     } catch {
       continue;
     }

package/bin/lib/oxe-operational.cjs

@@ -456,6 +456,61 @@ function reduceCanonicalRunState(projectRoot, activeSession, options = {}) {
   return serializeCanonicalState(reduceCanonicalRunStateLive(projectRoot, activeSession, options));
 }
 
+/**
+ * Static-analysis lints for common pitfalls detectable before execution.
+ * Returns hint strings to be appended to validationErrors (shown at compile time).
+ */
+function lintPlanForCommonPitfalls(parsedPlan, parsedSpec, projectRoot, rawSpecText = '') {
+  const hints = [];
+  const specText = (parsedSpec && parsedSpec.objective ? parsedSpec.objective : '') +
+    JSON.stringify(parsedSpec && parsedSpec.criteria ? parsedSpec.criteria : []) +
+    (rawSpecText || '');
+  const planTasks = parsedPlan && Array.isArray(parsedPlan.tasks) ? parsedPlan.tasks : [];
+
+  // ── Lint 1: HTML/JS SPA sem restrição de file:// ──────────────────────────
+  // Detects: spec mentions HTML/SPA + no files restriction, but no verify command
+  // checks for fetch() absence. Warns to add a fetch-detection verify.
+  const isHtmlApp = /html|spa|browser|page|frontend|estático|static|aplicação web|web app|web page|interface web|\.html/i.test(specText);
+  if (isHtmlApp) {
+    const hasFetchGuard = planTasks.some(t =>
+      t.verifyCommand && /fetch|XMLHttpRequest|file:\/\//i.test(t.verifyCommand)
+    );
+    const specMentionsServer = /servidor|server|http-server|localhost|npx serve|vite|webpack/i.test(specText);
+    const specMentionsFileProtocol = /file:\/\/|sem servidor|without server|no.server/i.test(specText);
+    if (!hasFetchGuard && !specMentionsServer && !specMentionsFileProtocol) {
+      hints.push(
+        'HINT(html-fetch): SPEC não declara se o app precisa de servidor HTTP. ' +
+        'Se abrir em file://, adicione à SPEC: "sem servidor HTTP" e um verify que detecte fetch(): ' +
+        '`node -e "if(require(\'fs\').readFileSync(\'app.js\',\'utf8\').includes(\'fetch(\'))throw new Error(\'fetch not allowed in file://\')"`'
+      );
+    }
+  }
+
+  // ── Lint 2: Verify commands que só verificam existência de função, não comportamento ──
+  const existenceOnlyVerify = planTasks.filter(t =>
+    t.verifyCommand &&
+    /s\.includes\(/.test(t.verifyCommand) &&
+    !/existsSync|readFileSync.*utf8|require\(/.test(t.verifyCommand)
+  );
+  if (existenceOnlyVerify.length > 2) {
+    hints.push(
+      `HINT(verify-depth): ${existenceOnlyVerify.length} tarefa(s) verificam apenas presença de string no código ` +
+      `(s.includes). Considere adicionar verificações de comportamento: executar o código, não só inspecioná-lo.`
+    );
+  }
+
+  // ── Lint 3: Tarefas sem verify command (T-level) ──────────────────────────
+  const noVerify = planTasks.filter(t => !t.verifyCommand && !t.done);
+  if (noVerify.length > 0) {
+    hints.push(
+      `HINT(no-verify): ${noVerify.length} tarefa(s) sem Comando de verificação: ${noVerify.map(t => t.id).join(', ')}. ` +
+      `Tarefas sem verify não serão testadas inline pelo scheduler.`
+    );
+  }
+
+  return hints;
+}
+
 function compileExecutionGraphFromArtifacts(projectRoot, activeSession, options = {}) {
   const runtime = loadRuntimeModule();
   const parsers = loadSdkParsers();
@@ -468,12 +523,17 @@ function compileExecutionGraphFromArtifacts(projectRoot, activeSession, options
   const artifactPaths = resolveRuntimeArtifactPaths(projectRoot, activeSession);
   const specText = readTextIfExists(artifactPaths.spec);
   const planText = readTextIfExists(artifactPaths.plan);
-  if (!specText) throw new Error(`SPEC.md ausente em ${artifactPaths.spec}`);
-  if (!planText) throw new Error(`PLAN.md ausente em ${artifactPaths.plan}`);
+  if (!specText) throw new Error(`SPEC.md ausente em ${artifactPaths.spec}\n  Crie .oxe/SPEC.md com /oxe-spec no seu agente, ou use o template em oxe/templates/SPEC.template.md`);
+  if (!planText) throw new Error(`PLAN.md ausente em ${artifactPaths.plan}\n  Crie .oxe/PLAN.md com /oxe-plan no seu agente (requer SPEC.md), ou use o template em oxe/templates/PLAN.template.md`);
   const parsedSpec = parsers.parseSpec(specText);
   const parsedPlan = parsers.parsePlan(planText);
   const graph = runtime.compile(parsedPlan, parsedSpec, options.compilerOptions || {});
   const validationErrors = typeof runtime.validateGraph === 'function' ? runtime.validateGraph(graph) : [];
+
+  // Static-analysis lints: detect common patterns that cause runtime failures
+  const lintHints = lintPlanForCommonPitfalls(parsedPlan, parsedSpec, projectRoot, specText);
+  if (lintHints.length) validationErrors.push(...lintHints);
+
   const compiledGraph = runtime.toSerializable(graph);
   const current = options.runState || readRunState(projectRoot, activeSession) || {};
   const runId = current.run_id || makeRunId();
@@ -669,6 +729,20 @@ async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
   const parsers = loadSdkParsers();
   if (!parsers) throw new Error('SDK parsers não disponíveis.');
 
+  // Auto-wire LlmTaskExecutor if providerConfig is supplied
+  let executor = options.executor || null;
+  if (!executor && options.providerConfig) {
+    if (typeof runtime.LlmTaskExecutor !== 'function') throw new Error('Runtime não exporta LlmTaskExecutor.');
+    executor = new runtime.LlmTaskExecutor(options.providerConfig, null, options.onProgress || null);
+  }
+  // Auto-wire InplaceWorkspaceManager as default
+  let workspaceManager = options.workspaceManager || null;
+  if (!workspaceManager) {
+    if (typeof runtime.InplaceWorkspaceManager === 'function') {
+      workspaceManager = new runtime.InplaceWorkspaceManager(projectRoot);
+    }
+  }
+
   // Resolve compiled graph from run state or compile on demand
   let current = options.runState || readRunState(projectRoot, activeSession);
   if (!current || !current.compiled_graph) {
@@ -693,11 +767,14 @@ async function runRuntimeExecute(projectRoot, activeSession, options = {}) {
   // Build ctx with GateManager (Gap 1)
   const ctx = createExecutionContext(projectRoot, activeSession, {
     runId: current.run_id,
-    executor: options.executor || null,
-    workspaceManager: options.workspaceManager || null,
+    executor,
+    workspaceManager,
     pluginRegistry: options.pluginRegistry || buildRuntimePluginRegistry(projectRoot),
     schedulerOptions: options.schedulerOptions || {},
-    onEvent: (event) => appendEvent(projectRoot, activeSession, event),
+    onEvent: (event) => {
+      appendEvent(projectRoot, activeSession, event);
+      options.onProgress?.(event);
+    },
   });
 
   // Gap 5: multi-agent path if plan-agents.json exists
@@ -906,6 +983,11 @@ function buildRecoveryConsistency(projectRoot, activeSession, runState, journal,
   const runDir = runState && runState.run_id ? path.join(projectRoot, '.oxe', 'runs', runState.run_id) : null;
   const allEvents = readEvents(projectRoot, activeSession);
   const runEvents = runState && runState.run_id ? allEvents.filter((event) => event.run_id === runState.run_id) : [];
+  // Detect if execution has ever started (at least one attempt recorded)
+  const attemptCount = runState && runState.canonical_state && runState.canonical_state.summary
+    ? (runState.canonical_state.summary.attempt_count || 0)
+    : 0;
+  const executionStarted = attemptCount > 0;
   const issues = [];
   if (!activeRunRef || activeRunRef.run_id !== (runState && runState.run_id)) {
     issues.push('ACTIVE-RUN.json não referencia o mesmo run persistido em .oxe/runs/.');
@@ -913,10 +995,12 @@ function buildRecoveryConsistency(projectRoot, activeSession, runState, journal,
   if (!runFile || !fs.existsSync(runFile)) {
     issues.push('Arquivo canónico da run ausente em .oxe/runs/<run>.json.');
   }
-  if (!journal) {
+  // Journal is only created after execution starts — skip this check pre-execution
+  if (!journal && executionStarted) {
     issues.push('Journal ausente para recover/replay.');
   }
-  if (runEvents.length === 0) {
+  // Events for this run only exist after execution — skip pre-execution
+  if (runEvents.length === 0 && executionStarted) {
     issues.push('Nenhum evento NDJSON encontrado para a run ativa.');
   }
   if (!runState || !runState.canonical_state) {
@@ -1146,7 +1230,7 @@ function projectRuntimeArtifacts(projectRoot, activeSession, options = {}) {
   const paths = resolveRuntimeArtifactPaths(projectRoot, activeSession);
   const op = operationalPaths(projectRoot, activeSession);
   const projectionRefs = {
-    plan_ref: path.relative(projectRoot, paths.plan).replace(/\\/g, '/'),
+    plan_ref: path.relative(projectRoot, paths.plan.replace(/PLAN\.md$/, 'PLAN-STATUS.md')).replace(/\\/g, '/'),
     verify_ref: path.relative(projectRoot, paths.verify).replace(/\\/g, '/'),
     state_ref: path.relative(projectRoot, paths.state).replace(/\\/g, '/'),
     run_summary_ref: path.relative(projectRoot, path.join(op.executionRoot, 'RUN-SUMMARY.md')).replace(/\\/g, '/'),
@@ -1156,10 +1240,12 @@ function projectRuntimeArtifacts(projectRoot, activeSession, options = {}) {
     generated_at: new Date().toISOString(),
   };
   if (options.write !== false) {
-    ensureDirForFile(paths.plan);
+    // Write plan projection to PLAN-STATUS.md — never overwrite the source PLAN.md
+    const planStatusPath = paths.plan.replace(/PLAN\.md$/, 'PLAN-STATUS.md');
+    ensureDirForFile(planStatusPath);
     ensureDirForFile(paths.verify);
     ensureDirForFile(paths.state);
-    fs.writeFileSync(paths.plan, projections.plan + '\n', 'utf8');
+    fs.writeFileSync(planStatusPath, projections.plan + '\n', 'utf8');
     fs.writeFileSync(paths.verify, projections.verify + '\n', 'utf8');
     fs.writeFileSync(paths.state, projections.state + '\n', 'utf8');
     fs.writeFileSync(path.join(op.executionRoot, 'RUN-SUMMARY.md'), projections.runSummary + '\n', 'utf8');

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,
   };
 }
@@ -2026,12 +2076,21 @@ function suggestNextStep(target, cfg = {}) {
     };
   }
 
+  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,