fix(ci): stop an env-gated all-skip package from outranking real evidence in the revert oracle

#4131 (closes #4108) correctly stops an all-skipped baseline from being
scored a pass, but `aggregate()`'s severity walk ranked ALL_SKIPPED above
PASS and ASSERTION_FAILURE unconditionally. CI's revert-oracle job installs
Python/ifcopenshell only when Python files changed, so a TS-only PR touching
even one env-gated all-skip file (e.g.
packages/export/src/ifcopenshell-schema-conformance.test.ts) now aggregates
to ALL_SKIPPED across the whole run, and verdict() falls into
BASELINE-BROKEN/exit 3 -- blocking a PR whose other packages produced real,
executed assertions that went red on revert.

Adds severityCandidates() in revert-oracle-all-skipped.mjs: when at least
one result in the run has kind PASS or ASSERTION_FAILURE, ALL_SKIPPED
entries are dropped from the severity walk (their counts/evidence still
fold into aggregate()'s totals, unfiltered). With no real evidence anywhere,
every result stays a candidate, so a single all-skipped package, or a run
where every package is all-skipped, still aggregates to ALL_SKIPPED and
still blocks -- #4108's own case is unchanged.

Verified both directions with synthetic aggregate()/verdict() calls before
fixing: a PASS-plus-ALL_SKIPPED run aggregated to ALL_SKIPPED/BASELINE-BROKEN
(exit 3) pre-fix, and to PASS/OBSERVED (exit 0) post-fix; a single- or
every-package all-skipped run stayed ALL_SKIPPED/BASELINE-BROKEN (exit 3) in
both cases.

Mutated to confirm the tests hold: reverting the aggregate() change back to
scanning `results` directly turns exactly the three new multi-package tests
red; reverting severityCandidates() to unconditionally filter ALL_SKIPPED
(dropping the single-signal guard) turns exactly the two single/every
all-skipped tests red. All other tests stayed green in both mutations.

scripts/lib/revert-oracle.mjs stays within its 528-line module-size budget
(now flush against it); the new logic lives in the existing
revert-oracle-all-skipped.mjs sibling module instead of growing the budget.

node --test scripts/lib/revert-oracle*.test.mjs: 104 -> 108 tests, all
passing.

Author: BIMvoice

scripts/lib/revert-oracle-all-skipped.mjs

@@ -60,3 +60,27 @@ export function classifyExecuted(parsed) {
   }
   return { kind: PASS, passed: parsed.passed, failed: parsed.failed, total: parsed.total, evidence: [] };
 }
+
+/**
+ * `aggregate()`'s severity walk (`revert-oracle.mjs`) ranks ALL_SKIPPED above
+ * PASS, which is right when a run's ONLY signal is an all-skipped package —
+ * #4108's own case: the baseline measured nothing, so nothing can be
+ * concluded — but wrong when ANOTHER package in the same run produced real
+ * evidence (a PASS or ASSERTION_FAILURE). An env-gated all-skip file (e.g.
+ * `ifcopenshell-schema-conformance.test.ts` on a TS-only PR, where CI never
+ * installs Python) must not outrank a genuinely observed change and block a
+ * well-tested PR. That was a real regression #4108's fix (#4131) introduced.
+ *
+ * Returns the subset of `results` that should decide the aggregate's worst
+ * kind: with real evidence present, ALL_SKIPPED entries are dropped from the
+ * severity walk (their counts and evidence still fold into the caller's
+ * totals via its own `sum`/`flatMap` over the FULL `results` array, unfiltered
+ * — only the *verdict-deciding* kind ignores them). With no real evidence
+ * anywhere, every result — ALL_SKIPPED included — stays a candidate, so a
+ * single-package or an every-package all-skipped run still poisons to
+ * ALL_SKIPPED exactly as before.
+ */
+export function severityCandidates(results) {
+  const hasEvidence = results.some((r) => r.kind === PASS || r.kind === ASSERTION_FAILURE);
+  return hasEvidence ? results.filter((r) => r.kind !== ALL_SKIPPED) : results;
+}

scripts/lib/revert-oracle.mjs

@@ -35,7 +35,7 @@
  */
 
 import { parsePython, PYTEST_MISSING_PATTERN } from './revert-oracle-python.mjs';
-import { ALL_SKIPPED, classifyExecuted } from './revert-oracle-all-skipped.mjs';
+import { ALL_SKIPPED, classifyExecuted, severityCandidates } from './revert-oracle-all-skipped.mjs';
 // ---------------------------------------------------------------------------
 // Diff classification
 // ---------------------------------------------------------------------------
@@ -511,8 +511,9 @@ export function aggregate(results) {
   if (!Array.isArray(results) || results.length === 0) {
     return { kind: UNPARSEABLE, passed: null, failed: null, total: null, evidence: ['no packages were run'] };
   }
-  let worst = results[0];
-  for (const r of results) {
+  const candidates = severityCandidates(results);
+  let worst = candidates[0];
+  for (const r of candidates) {
     if (KIND_SEVERITY.indexOf(r.kind) > KIND_SEVERITY.indexOf(worst.kind)) worst = r;
   }
   const sum = (key) =>

scripts/lib/revert-oracle.test.mjs

@@ -950,13 +950,73 @@ test('aggregate: an assertion failure alongside passes stays an assertion failur
   assert.equal(a.total, 8);
 });
 
-test('#4108: aggregate: one all-skipped package outranks a genuinely green one', () => {
+test('#4131 regression: aggregate: an all-skipped package no longer outranks a genuinely green one', () => {
+  // #4131's own fix for #4108 made this the false positive: an env-gated
+  // all-skip file (ifcopenshell absent on a TS-only PR) must not poison a run
+  // that also contains a package with real, executed evidence.
   const a = aggregate([
     { kind: PASS, passed: 5, failed: 0, total: 5, evidence: [] },
     { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] },
   ]);
-  assert.equal(a.kind, ALL_SKIPPED);
+  assert.equal(a.kind, PASS);
   assert.equal(a.total, 7);
+  assert.equal(a.passed, 5);
+});
+
+test('#4131 regression: aggregate: an all-skipped package no longer outranks a real assertion failure', () => {
+  const a = aggregate([
+    { kind: ASSERTION_FAILURE, passed: 2, failed: 1, total: 3, evidence: ['assertion X failed'] },
+    { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] },
+  ]);
+  assert.equal(a.kind, ASSERTION_FAILURE);
+  assert.equal(a.failed, 1);
+  assert.equal(a.total, 5);
+});
+
+test('#4131 regression: multi-package all-skipped-plus-evidence run does not block CI', () => {
+  // The end-to-end shape: a well-tested PR whose reverted run turns real
+  // assertions RED in one package while an unrelated env-gated file stays
+  // all-skipped in both the baseline and the reverted run.
+  const baseline = aggregate([
+    { kind: PASS, passed: 12, failed: 0, total: 12, evidence: [] },
+    { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] },
+  ]);
+  const reverted = aggregate([
+    { kind: ASSERTION_FAILURE, passed: 10, failed: 2, total: 12, evidence: ['assertion X failed'] },
+    { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] },
+  ]);
+  const v = verdict({ baseline, reverted });
+  assert.equal(v.verdict, OBSERVED);
+  assert.equal(v.exitCode, 0);
+});
+
+test('#4108 (still fixed): aggregate: a SINGLE all-skipped package is still ALL_SKIPPED and still blocks', () => {
+  // With no other package producing real evidence, an all-skipped package
+  // must still poison the run -- this is #4108's actual case and #4131's
+  // fix for it must not be weakened.
+  const results = [{ kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] }];
+  const baseline = aggregate(results);
+  const reverted = aggregate(results);
+  assert.equal(baseline.kind, ALL_SKIPPED);
+  const v = verdict({ baseline, reverted });
+  assert.equal(v.verdict, BASELINE_BROKEN);
+  assert.equal(v.exitCode, 3);
+});
+
+test('#4108 (still fixed): aggregate: EVERY package all-skipped is still ALL_SKIPPED and still blocks', () => {
+  // No package anywhere produced real evidence, so the "another package has
+  // evidence" exception must not apply -- this must not slip through as a pass.
+  const results = [
+    { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 2, evidence: ['all skipped'] },
+    { kind: ALL_SKIPPED, passed: 0, failed: 0, total: 3, evidence: ['all skipped'] },
+  ];
+  const baseline = aggregate(results);
+  const reverted = aggregate(results);
+  assert.equal(baseline.kind, ALL_SKIPPED);
+  assert.equal(baseline.total, 5);
+  const v = verdict({ baseline, reverted });
+  assert.equal(v.verdict, BASELINE_BROKEN);
+  assert.equal(v.exitCode, 3);
 });
 
 test('aggregate: zero packages is UNPARSEABLE, never a pass', () => {