arkgate 4.8.13 → 4.8.15

package/bin/lib/projected-governed-coverage.mjs

@@ -0,0 +1,114 @@
+/**
+ * One definition of projected governed coverage: include-scoped files that
+ * match a layer glob, via computeCoverage. Shared by start, --recommend, and
+ * doctor so the same tree cannot advertise two "projected" percents.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { collectGovernedFiles } from './scan-files.mjs';
+import { computeCoverage } from './doctor-plan.mjs';
+import { ARCHITECTURE_PRESETS } from './presets.mjs';
+import {
+  detectWorkspaces,
+  resolveIncludeRoots,
+  resolveStartInitPreset,
+} from '../ark-shared.mjs';
+
+export function measureGovernedCoverage(root, config) {
+  const files = collectGovernedFiles(root, config);
+  return computeCoverage(root, config, files, config.rules ?? []);
+}
+
+export function summarizeGovernedCoverage(coverage) {
+  const governed = coverage?.governed ?? {};
+  return {
+    percent: typeof governed.percent === 'number' ? governed.percent : 0,
+    classifiedFiles: governed.classifiedFiles ?? 0,
+    totalFiles: governed.totalFiles ?? coverage?.totalFiles ?? 0,
+    emptyScope: coverage?.emptyScope === true,
+  };
+}
+
+export function starterConfigForPreset(root, preset) {
+  const factory = ARCHITECTURE_PRESETS[preset];
+  if (typeof factory !== 'function') return null;
+  const workspacesOrInclude =
+    preset === 'monorepo' || preset === 'ui-surface'
+      ? resolveIncludeRoots(root)
+      : detectWorkspaces(root);
+  return factory(workspacesOrInclude, root);
+}
+
+/**
+ * Contract start/recommend/doctor should score: existing ark.config.json, else
+ * the starter --init would write for this tree (same preset resolution as start).
+ */
+export function resolveProjectedCoverageConfig(root, recommendation = {}) {
+  const configPath = path.join(root, 'ark.config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (parsed && typeof parsed === 'object') {
+        return { config: parsed, source: 'existing-config' };
+      }
+    } catch {
+      /* fall through to starter */
+    }
+  }
+  const preset = resolveStartInitPreset(root, recommendation);
+  if (!preset) return { config: null, source: 'none', preset: null };
+  return { config: starterConfigForPreset(root, preset), source: 'start-starter', preset };
+}
+
+export function measureProjectedGovernedCoverage(root, recommendation = {}) {
+  const resolved = resolveProjectedCoverageConfig(root, recommendation);
+  if (!resolved.config) {
+    return {
+      percent: 0,
+      classifiedFiles: 0,
+      totalFiles: 0,
+      emptyScope: true,
+      source: resolved.source,
+      preset: resolved.preset ?? null,
+    };
+  }
+  return {
+    ...summarizeGovernedCoverage(measureGovernedCoverage(root, resolved.config)),
+    source: resolved.source,
+    preset: resolved.preset ?? recommendation.preset ?? null,
+  };
+}
+
+const PROJECTED_COVERAGE_REASON = /projected governed coverage is \d+% \(below 90%\)/;
+
+export function withProjectedGovernedCoverage(recommendation, root) {
+  if (!recommendation || typeof recommendation !== 'object') return recommendation;
+  const measured = measureProjectedGovernedCoverage(root, recommendation);
+  const percent = measured.percent;
+  const confirmationReasons = (recommendation.confirmationReasons ?? []).filter(
+    (reason) => !PROJECTED_COVERAGE_REASON.test(String(reason))
+  );
+  if (percent < 90) {
+    confirmationReasons.push(`projected governed coverage is ${percent}% (below 90%)`);
+  }
+  return {
+    ...recommendation,
+    requiresConfirmation:
+      Boolean(recommendation.requiresConfirmation) ||
+      percent < 90 ||
+      Boolean(recommendation.thinTsSurface),
+    confirmationReasons,
+    signals: {
+      ...recommendation.signals,
+      projectedGovernedCoverage: percent,
+      projectedGovernedClassifiedFiles: measured.classifiedFiles,
+      projectedGovernedTotalFiles: measured.totalFiles,
+      projectedGovernedSource: measured.source,
+    },
+    projectedCoverage: {
+      percent,
+      classifiedFiles: measured.classifiedFiles,
+      totalFiles: measured.totalFiles,
+    },
+  };
+}

package/bin/lib/recommend-cli.mjs

@@ -0,0 +1,54 @@
+/**
+ * `--recommend` presentation. Lives here so ark-check-runtime stays under the
+ * orchestration LOC budget and doctor does not parse this path.
+ */
+import path from 'node:path';
+import {
+  ADOPTION_PLAN_FILENAME,
+  buildArchitectureRecommendation,
+  formatArchitectureRecommendationHuman,
+  writeAdoptionPlan,
+} from '../ark-shared.mjs';
+import { withProjectedGovernedCoverage } from './projected-governed-coverage.mjs';
+
+export function runRecommend(args) {
+  try {
+    const recommendation = withProjectedGovernedCoverage(
+      buildArchitectureRecommendation(args.root),
+      args.root
+    );
+    let planWritten;
+    if (args.writePlan) {
+      const result = writeAdoptionPlan(args.root, recommendation);
+      planWritten = result.path;
+    }
+    if (args.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ...recommendation,
+            ...(planWritten
+              ? { adoptionPlanPath: path.relative(args.root, planWritten) || ADOPTION_PLAN_FILENAME }
+              : {}),
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(formatArchitectureRecommendationHuman(recommendation));
+      if (planWritten) {
+        console.log('');
+        console.log(`Wrote ${path.relative(args.root, planWritten) || ADOPTION_PLAN_FILENAME}`);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+    } else {
+      console.error(`ark-check --recommend failed: ${message}`);
+    }
+    process.exitCode = 2;
+  }
+}

package/bin/lib/remediation.mjs

@@ -216,6 +216,10 @@ export function deterministicNextAction(violation) {
             return 'Add metadata.source to the publish call, then run Ark again.';
         case 'INVARIANT_COVERAGE_OUTSIDE_ROOTS':
             return `Move the covering test under a declared coverage root, or add its root to coverage.coverageRoots in ark.config.json, then run Ark again.`;
+        case 'INVARIANT_CATALOG_EMPTY':
+            return typeof violation.file === 'string' && violation.file.length > 0
+                ? `Add 1–2 short phrases to invariants[] in ${violation.file}, then run ark-check --doctor. Starters show the shape.`
+                : 'Add 1–2 short phrases to invariants[] in arkrules/<Domain>.json, then run ark-check --doctor. Starters show the shape.';
         case 'ARKRULE_STRUCTURE':
         case 'ARKRULE_INVARIANT':
         case 'INVARIANT_UNCOVERED':
@@ -249,7 +253,7 @@ export function deterministicNextAction(violation) {
                 ? `Don't write ${violation.target} from a use-case. Take the event in, or change that choice through the valve (proposeRelease then apply), not a generic update.`
                 : "Don't write a named product choice from a use-case. Take the event in, or change that choice through the valve (proposeRelease then apply), not a generic update.";
         case 'ARKORDER_UNVALVED_RELEASE':
-            return 'Change ξ with proposeRelease then apply(ProposeResult). release() is only the first freeze. Never mechanical-safe.';
+            return 'Change the choice with proposeRelease then apply. release() is only the first freeze. Never mechanical-safe.';
         default:
             if (typeof violation.ruleId === 'string' && violation.ruleId.startsWith('ARKRULE_')) {
                 return `Fix the ArkRule ${typeof violation.arkruleId === 'string' ? violation.arkruleId : violation.ruleId}, then preflight again.`;
@@ -544,7 +548,7 @@ export function enrichViolationWithFixClass(violation) {
                                             : violation.ruleId === 'ARKORDER_STALE_SIGMA'
                                                 ? 'Refresh σ. ξ does not expire.'
                                                 : violation.ruleId === 'ARKORDER_UNVALVED_RELEASE'
-                                                    ? 'The pattern is frozen. proposeRelease then apply — do not call release() again with a different ξ.'
+                                                    ? 'The choice is already frozen. proposeRelease then apply — do not call release() again with a different value.'
                                                     : 'Call createOrderPlane from arkgate/order in a listed plane root so the app actually freezes a pattern.';
             break;
         default:

package/bin/lib/resolved-candidate-facts.mjs

@@ -211,32 +211,67 @@ function canonicalOverlayPath(
   return [...candidates].sort()[0] ?? requested;
 }
 
-function collectCandidateFiles(root, config, changes, observeInput) {
+function discoverScopedFiles(root, config, scopeRelatives, observeInput) {
+  const discovered = [];
+  const seen = new Set();
+  for (const raw of scopeRelatives ?? []) {
+    let relative;
+    try {
+      relative = canonicalProjectPath(
+        String(raw || '')
+          .replace(/\\/g, '/')
+          .replace(/^\.\//, '')
+      );
+    } catch {
+      continue;
+    }
+    if (seen.has(relative) || !isGovernableSourceFile(path.basename(relative))) continue;
+    if (!isIncluded(relative, config.include) || isScanExcludedRelative(relative, config)) {
+      continue;
+    }
+    const absolute = path.join(root, ...relative.split('/'));
+    if (!fs.existsSync(absolute)) continue;
+    seen.add(relative);
+    observeResolvedInput(observeInput, absolute, 'realpath');
+    discovered.push({
+      absolute,
+      real: fs.realpathSync(absolute),
+      relative,
+    });
+  }
+  return discovered.sort((left, right) =>
+    left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
+  );
+}
+
+function collectCandidateFiles(root, config, changes, observeInput, scopeRelatives) {
   const files = new Map();
   const directoryAliases = new Map();
   const expandedAliasDirectories = new Set();
-  const discovered = (config.include ?? [])
-    .flatMap((entry) =>
-      collectGovernedFiles(root, { ...config, include: [entry] }, {
-        observeInput,
-        onDirectory(absolute, real) {
-          let relative = normalize(path.relative(root, absolute));
-          if (relative === '.') relative = '';
-          rememberDirectoryAlias(directoryAliases, real, relative, absolute);
-        },
-      })
-    )
-    .map((absolute) => {
-      observeResolvedInput(observeInput, absolute, 'realpath');
-      return {
-        absolute,
-        real: fs.realpathSync(absolute),
-        relative: canonicalProjectPath(normalize(path.relative(root, absolute))),
-      };
-    })
-    .sort((left, right) =>
-      left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
-    );
+  const discovered = Array.isArray(scopeRelatives)
+    ? discoverScopedFiles(root, config, scopeRelatives, observeInput)
+    : (config.include ?? [])
+        .flatMap((entry) =>
+          collectGovernedFiles(root, { ...config, include: [entry] }, {
+            observeInput,
+            onDirectory(absolute, real) {
+              let relative = normalize(path.relative(root, absolute));
+              if (relative === '.') relative = '';
+              rememberDirectoryAlias(directoryAliases, real, relative, absolute);
+            },
+          })
+        )
+        .map((absolute) => {
+          observeResolvedInput(observeInput, absolute, 'realpath');
+          return {
+            absolute,
+            real: fs.realpathSync(absolute),
+            relative: canonicalProjectPath(normalize(path.relative(root, absolute))),
+          };
+        })
+        .sort((left, right) =>
+          left.relative < right.relative ? -1 : left.relative > right.relative ? 1 : 0
+        );
   const canonicalByRealpath = new Map();
   for (const candidate of discovered) {
     if (!canonicalByRealpath.has(candidate.real)) canonicalByRealpath.set(candidate.real, candidate);
@@ -582,7 +617,8 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
   const optionsByPath = new Map();
   const configInputsByPath = new Map();
   const reasons = [];
-  for (const configPath of configPaths) {
+  const loadConfigOptions = (configPath) => {
+    if (optionsByPath.has(configPath)) return optionsByPath.get(configPath);
     const configContents = new Map();
     const readConfig = (fileName) => {
       observeResolvedInput(observeInput, fileName, 'tsconfig');
@@ -605,15 +641,16 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
       });
       optionsByPath.set(configPath, {});
       configInputsByPath.set(configPath, configContents);
-      continue;
+      return {};
     }
     const parsed = ts.parseJsonConfigFileContent(
       read.config,
       {
         useCaseSensitiveFileNames: ts.sys?.useCaseSensitiveFileNames ?? true,
-        readDirectory(...args) {
-          observeResolvedInput(observeInput, args[0], 'tsconfig-directory');
-          return ts.sys?.readDirectory ? ts.sys.readDirectory(...args) : [];
+        readDirectory(dir) {
+          observeResolvedInput(observeInput, dir, 'tsconfig-directory');
+          // Options-only parse: `fileNames` are unused. Skip the include walk (#205).
+          return [];
         },
         fileExists(fileName) {
           observeResolvedInput(observeInput, fileName, 'tsconfig-exists');
@@ -637,11 +674,19 @@ function compilerContext(ts, root, tsconfig, candidateFiles, observeInput) {
     }
     optionsByPath.set(configPath, parsed.options ?? {});
     configInputsByPath.set(configPath, configContents);
-  }
+    return parsed.options ?? {};
+  };
+  for (const configPath of configPaths) loadConfigOptions(configPath);
 
   const optionsFor = (fileName) => {
-    const configPath = configByFile.get(path.resolve(fileName));
-    return configPath ? optionsByPath.get(configPath) ?? {} : {};
+    const resolved = path.resolve(fileName);
+    let configPath = configByFile.get(resolved);
+    if (!configPath) {
+      configPath = explicitPath
+        ?? nearestTsconfig(root, resolved, nearestConfigByDirectory, observeInput);
+      if (configPath) configByFile.set(resolved, configPath);
+    }
+    return configPath ? loadConfigOptions(configPath) ?? {} : {};
   };
   const configs = configPaths.map((configPath) => ({
     path: configLabel(root, configPath, externalAnchor),
@@ -1036,6 +1081,19 @@ function unavailableFacts(config, ts, reason) {
   });
 }
 
+function loadOneCandidateFile(root, config, relative, observeInput) {
+  const discovered = discoverScopedFiles(root, config, [relative], observeInput);
+  const found = discovered[0];
+  if (!found) return null;
+  observeResolvedInput(observeInput, found.absolute, 'source');
+  return {
+    path: found.relative,
+    absolute: path.resolve(found.absolute),
+    real: path.resolve(found.real),
+    content: fs.readFileSync(found.absolute, 'utf8'),
+  };
+}
+
 /** Resolve one complete candidate tree (base or virtual overlay) into versioned neutral facts. */
 export function resolveCandidateFacts({
   root,
@@ -1044,6 +1102,7 @@ export function resolveCandidateFacts({
   tsconfig,
   changes = [],
   observeInput,
+  scopeFiles,
 }) {
   if (!ts?.createSourceFile || !ts?.resolveModuleName) {
     return unavailableFacts(config, ts, 'No API-compatible TypeScript resolver is available.');
@@ -1053,10 +1112,17 @@ export function resolveCandidateFacts({
   let candidateFiles;
   let canonicalChanges;
   let compiler;
+  const scoped = Array.isArray(scopeFiles);
   try {
     observeResolvedInput(observeInput, root, 'realpath');
     canonicalRoot = fs.realpathSync(root);
-    const candidate = collectCandidateFiles(canonicalRoot, config, changes, observeInput);
+    const candidate = collectCandidateFiles(
+      canonicalRoot,
+      config,
+      changes,
+      observeInput,
+      scoped ? scopeFiles : undefined
+    );
     candidateFiles = candidate.files;
     canonicalChanges = candidate.changes;
     compiler = compilerContext(ts, canonicalRoot, tsconfig, candidateFiles, observeInput);
@@ -1102,11 +1168,20 @@ export function resolveCandidateFacts({
   const arkOrderXiFieldWrites = [];
   const arkOrderIngestWritesXi = [];
   const arkOrderReleaseKeyCounts = [];
-  const xiKeys = [...(config.arkOrder?.xiKeys ?? [])];
-  const compositionRootPatterns = [...(config.arkRun?.compositionRoots ?? [])];
-  const planeRootPatterns = [...(config.arkOrder?.planeRoots ?? [])];
+  const arkRunActive = config.arkRun != null && typeof config.arkRun === 'object';
+  const arkOrderActive = config.arkOrder != null && typeof config.arkOrder === 'object';
+  const arkRulesActive =
+    config.arkRules != null &&
+    typeof config.arkRules === 'object' &&
+    Object.keys(config.arkRules).length > 0;
+  const xiKeys = arkOrderActive ? [...(config.arkOrder?.xiKeys ?? [])] : [];
+  const compositionRootPatterns = arkRunActive
+    ? [...(config.arkRun?.compositionRoots ?? [])]
+    : [];
+  const planeRootPatterns = arkOrderActive ? [...(config.arkOrder?.planeRoots ?? [])] : [];
 
-  for (const candidate of candidateFiles) {
+  const seedPathSet = new Set(candidateFiles.map((file) => file.path));
+  const ingest = (candidate, fullExtract) => {
     const sourceFile = ts.createSourceFile(
       candidate.absolute,
       candidate.content,
@@ -1158,6 +1233,7 @@ export function resolveCandidateFacts({
         message: `${candidate.path} has ${parseDiagnosticCount} TypeScript parse diagnostic(s).`,
       });
     }
+    if (!fullExtract) return;
     const forbiddenUses = mayContainForbiddenCapability(ts, sourceFile, forbiddenGlobals)
       ? collectForbiddenCapabilityUses(ts, sourceFile, forbiddenGlobals)
       : [];
@@ -1188,83 +1264,132 @@ export function resolveCandidateFacts({
     );
     // Class-shape extraction is text-conservative (false negatives over false positives).
     // Only TS/TSX candidates; sensors consume the same shape via facts.classShapes.
+    // Extra-plane and ArkRules extractors stay silent when that plane is off (#212).
     if (/\.(tsx?|mts|cts)$/i.test(candidate.path)) {
-      try {
-        classShapes.push(...extractClassShapesFromSource(candidate.path, candidate.content));
-      } catch {
-        // Never fail the resolver for shape extraction; sensors stay silent on this file.
-      }
-      try {
-        arkRunKernelCalls.push(
-          ...extractArkRunKernelCallsFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkRun call extraction.
-      }
-      try {
-        arkRunDeclarations.push(
-          ...extractArkRunDeclarationsFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkRun declaration extraction.
-      }
-      try {
-        arkOrderPlaneCalls.push(
-          ...extractArkOrderPlaneCallsFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkOrder factory extraction.
-      }
-      try {
-        arkOrderGenericUpdates.push(
-          ...extractArkOrderGenericUpdatesFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkOrder generic-update extraction.
+      if (arkRulesActive || arkRunActive) {
+        try {
+          classShapes.push(...extractClassShapesFromSource(candidate.path, candidate.content));
+        } catch {
+          // Never fail the resolver for shape extraction; sensors stay silent on this file.
+        }
       }
-      try {
-        arkOrderXiFieldWrites.push(
-          ...extractArkOrderXiFieldWritesFromSource(candidate.path, candidate.content, xiKeys)
-        );
-      } catch {
-        // Never fail the resolver for ArkOrder xi-field-write extraction.
+      if (arkRunActive) {
+        try {
+          arkRunKernelCalls.push(
+            ...extractArkRunKernelCallsFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkRun call extraction.
+        }
+        try {
+          arkRunDeclarations.push(
+            ...extractArkRunDeclarationsFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkRun declaration extraction.
+        }
       }
-      try {
-        arkOrderIngestWritesXi.push(
-          ...extractArkOrderIngestWritesXiFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkOrder ingest-writes-ξ extraction.
+      if (arkOrderActive) {
+        try {
+          arkOrderPlaneCalls.push(
+            ...extractArkOrderPlaneCallsFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkOrder factory extraction.
+        }
+        try {
+          arkOrderGenericUpdates.push(
+            ...extractArkOrderGenericUpdatesFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkOrder generic-update extraction.
+        }
+        try {
+          arkOrderXiFieldWrites.push(
+            ...extractArkOrderXiFieldWritesFromSource(candidate.path, candidate.content, xiKeys)
+          );
+        } catch {
+          // Never fail the resolver for ArkOrder xi-field-write extraction.
+        }
+        try {
+          arkOrderIngestWritesXi.push(
+            ...extractArkOrderIngestWritesXiFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkOrder ingest-writes-ξ extraction.
+        }
+        try {
+          arkOrderReleaseKeyCounts.push(
+            ...extractArkOrderReleaseKeyCountsFromSource(candidate.path, candidate.content)
+          );
+        } catch {
+          // Never fail the resolver for ArkOrder release key-count extraction.
+        }
       }
-      try {
-        arkOrderReleaseKeyCounts.push(
-          ...extractArkOrderReleaseKeyCountsFromSource(candidate.path, candidate.content)
-        );
-      } catch {
-        // Never fail the resolver for ArkOrder release key-count extraction.
+    }
+  };
+
+  for (const candidate of candidateFiles) ingest(candidate, true);
+
+  if (scoped) {
+    const loaded = new Set(candidateFiles.map((file) => file.path));
+    let pending = [...candidateFiles];
+    while (pending.length > 0) {
+      const discovered = [];
+      for (const source of pending) {
+        const parsedFile = parsed.get(source.path);
+        if (!parsedFile) continue;
+        for (const dependency of parsedFile.dependencies) {
+          const resolved = resolveDependency(
+            ts,
+            dependency,
+            parsedFile.candidate.absolute,
+            compiler.optionsFor(parsedFile.candidate.absolute),
+            host
+          );
+          if (resolved.resolution !== 'resolved-project' || !resolved.target) continue;
+          if (loaded.has(resolved.target)) continue;
+          const extra = loadOneCandidateFile(
+            canonicalRoot,
+            config,
+            resolved.target,
+            observeInput
+          );
+          if (!extra) continue;
+          loaded.add(extra.path);
+          candidateFiles.push(extra);
+          ingest(extra, false);
+          discovered.push(extra);
+        }
       }
+      pending = discovered;
     }
   }
 
+  const extractCandidates = scoped
+    ? candidateFiles.filter((file) => seedPathSet.has(file.path))
+    : candidateFiles;
   const admittedTypeNames = new Set(classShapes.map((shape) => shape.className));
-  for (const candidate of candidateFiles) {
-    if (!/\.(tsx?|mts|cts)$/i.test(candidate.path)) continue;
-    try {
-      arkRunManagedNews.push(
-        ...extractArkRunManagedNewsFromSource(
-          candidate.path,
-          candidate.content,
-          admittedTypeNames
-        )
-      );
-    } catch {
-      // Never fail the resolver for managed-new extraction.
+  if (arkRunActive) {
+    for (const candidate of extractCandidates) {
+      if (!/\.(tsx?|mts|cts)$/i.test(candidate.path)) continue;
+      try {
+        arkRunManagedNews.push(
+          ...extractArkRunManagedNewsFromSource(
+            candidate.path,
+            candidate.content,
+            admittedTypeNames
+          )
+        );
+      } catch {
+        // Never fail the resolver for managed-new extraction.
+      }
     }
   }
 
   if (planeRootPatterns.length > 0) {
     const factoryFiles = new Set(arkOrderPlaneCalls.map((call) => call.file));
-    for (const candidate of candidateFiles) {
+    for (const candidate of extractCandidates) {
       for (const pattern of planeRootPatterns) {
         try {
           if (!globToRegExp(pattern).test(candidate.path)) continue;
@@ -1284,7 +1409,7 @@ export function resolveCandidateFacts({
     const factoryFiles = new Set(
       arkRunKernelCalls.filter((call) => call.kind === 'factory').map((call) => call.file)
     );
-    for (const candidate of candidateFiles) {
+    for (const candidate of extractCandidates) {
       for (const pattern of compositionRootPatterns) {
         try {
           if (!globToRegExp(pattern).test(candidate.path)) continue;