eyeprolog 1.5.81 → 1.5.83

package/conformance-report.md

@@ -7,7 +7,7 @@ when this report is generated; it is not inferred from fixture counts.
 ## Latest Neumerkel evidence
 
 See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).
-`npm test` fetches all seven TU Wien sources once and executes the discovered inventory.
+`npm test` fetches all eight TU Wien sources once and executes the discovered inventory.
 The release workflow then synchronizes this tracked report from those exact successful
 cached source bytes, avoiding a second live fetch and its race window.
 

package/examples/defeasible-reasoning.pl

@@ -0,0 +1,120 @@
+% Defeasible reasoning: an employee travel-expense reimbursement policy.
+%
+% Defeasible rules state a default and let a more specific rule override it.
+% Most of that is ordinary, stratified negation as failure (7.3, \+/1): compute
+% the exception from facts, then let the default rule negate the exception.
+% Nothing here needs the well-founded semantics (WFS) yet.
+%
+% The last section is different on purpose. It models two independent
+% reimbursement policies that can both claim the same expense with no company
+% rule saying which one wins — team_offsite_hotel qualifies for both the flat
+% per-diem blanket allowance and itemized reimbursement, and neither policy
+% was written anticipating the other. Three ways to handle that:
+%
+%   1) Plain \+/1, each side negating the other. That is an unstratified
+%      negation cycle: proving either side requires failing the other, which
+%      requires proving the first again. Try it (swap tnot/1 for \+/1 below
+%      and run with --warnings): the engine loops until it runs out of stack.
+%   2) tnot/1 and wfs_truth/2. EyeProlog evaluates the same cycle under WFS
+%      and reports both sides `undefined` instead of picking one arbitrarily
+%      — honest, since the policies themselves do not resolve the conflict,
+%      but callers now have to know to ask wfs_truth/2 instead of just
+%      calling covered_by_blanket/1 or itemized/1 directly.
+%   3) An explicit conflict predicate, the way examples/nixon-diamond.pl
+%      already handles the same shape of problem (two independent defaults,
+%      no priority between them): join the two eligibility facts directly and
+%      name the outcome. No negation, no cycle, nothing for --warnings to
+%      flag, and the result is an ordinary fact any caller can query without
+%      having to know WFS exists.
+%
+% Here (3) is the better fit, and is this codebase's actual convention for
+% this situation. Reach for tnot/1 and wfs_truth/2 when the mutual defeat is
+% already how the rules are naturally stated as each other's negation — a
+% permission that holds unless its prohibition holds and vice versa, as
+% examples/odrl-policy-reasoning.pl's profile rules do for a real policy
+% language — not to manufacture a cycle for a conflict a direct join would
+% already detect. And for everyday defeasible overriding, where a more
+% specific rule is meant to win outright, plain stratified \+/1 already says
+% exactly that and is ISO-portable; WFS would not change the answer there,
+% only the machinery needed to get it.
+
+%% goal: reimbursementQuestion(X0, X1, X2)
+%% goal: conflictQuestion(X0, X1, X2)
+%% goal: explicitConflictQuestion(X0, X1, X2)
+
+% --- Submitted expenses and the facts a claims clerk would see ------------
+
+submitted(taxi_receipt).
+submitted(client_dinner_wine).
+submitted(client_dinner_wine_preapproved).
+submitted(team_offsite_hotel).
+
+category(client_dinner_wine, alcohol).
+category(client_dinner_wine_preapproved, alcohol).
+
+% A manager can preapprove alcohol as part of client entertainment; that is
+% the exception to the exception.
+preapproved_entertainment(client_dinner_wine_preapproved).
+
+% --- Ordinary defeasible tier: specificity resolves every case -------------
+%
+%   default:            an expense is reimbursable
+%   exception:           ... unless it is alcohol
+%   exception to that:   ... unless the alcohol was preapproved entertainment
+%
+% Each rule only negates a lower, already-computed layer, so this is
+% stratified and plain \+/1 is all it takes.
+
+excluded(Expense) :-
+  category(Expense, alcohol),
+  \+ preapproved_entertainment(Expense).
+
+reimbursable(Expense) :-
+  submitted(Expense),
+  \+ excluded(Expense).
+
+% --- The one case with a genuine, unresolved conflict, two ways ------------
+%
+% team_offsite_hotel independently qualifies for both the flat per-diem
+% blanket allowance and itemized reimbursement.
+blanket_eligible(team_offsite_hotel).
+itemizable(team_offsite_hotel).
+
+% 2) WFS via tnot/1: each classification defeats the other, leaving both
+% `undefined` rather than an arbitrary pick.
+covered_by_blanket(Expense) :-
+  blanket_eligible(Expense),
+  tnot(itemized(Expense)).
+itemized(Expense) :-
+  itemizable(Expense),
+  tnot(covered_by_blanket(Expense)).
+
+% 3) This codebase's usual idiom (examples/nixon-diamond.pl): detect the
+% conflict directly from the two eligibility facts, no negation involved.
+policy_conflict(Expense, blanket_allowance, itemized_reimbursement) :-
+  blanket_eligible(Expense),
+  itemizable(Expense).
+
+% --- Curated questions -----------------------------------------------------
+
+% Plain expense, alcohol excluded by default, and the preapproved override —
+% all decided by ordinary negation as failure, no WFS involved.
+reimbursementQuestion(plain, taxi_receipt, Verdict) :-
+  wfs_truth(reimbursable(taxi_receipt), Verdict).
+reimbursementQuestion(alcohol_excluded, client_dinner_wine, Verdict) :-
+  wfs_truth(reimbursable(client_dinner_wine), Verdict).
+reimbursementQuestion(alcohol_preapproved, client_dinner_wine_preapproved, Verdict) :-
+  wfs_truth(reimbursable(client_dinner_wine_preapproved), Verdict).
+
+% The unresolved policy conflict under WFS: both classifications come back
+% `undefined`, which only tells a caller anything if it remembers to ask
+% wfs_truth/2 in the first place.
+conflictQuestion(blanket_allowance, team_offsite_hotel, Verdict) :-
+  wfs_truth(covered_by_blanket(team_offsite_hotel), Verdict).
+conflictQuestion(itemized_reimbursement, team_offsite_hotel, Verdict) :-
+  wfs_truth(itemized(team_offsite_hotel), Verdict).
+
+% The same conflict, detected directly: an ordinary fact any caller can query
+% without knowing WFS is involved at all.
+explicitConflictQuestion(team_offsite_hotel, blanket_allowance, itemized_reimbursement) :-
+  policy_conflict(team_offsite_hotel, blanket_allowance, itemized_reimbursement).

package/examples/output/defeasible-reasoning.pl

@@ -0,0 +1,6 @@
+reimbursementQuestion(plain, taxi_receipt, true).
+reimbursementQuestion(alcohol_excluded, client_dinner_wine, false).
+reimbursementQuestion(alcohol_preapproved, client_dinner_wine_preapproved, true).
+conflictQuestion(blanket_allowance, team_offsite_hotel, undefined).
+conflictQuestion(itemized_reimbursement, team_offsite_hotel, undefined).
+explicitConflictQuestion(team_offsite_hotel, blanket_allowance, itemized_reimbursement).

package/index.d.ts

@@ -96,6 +96,12 @@ export interface EyePrologQuadResult {
   kind?: 'failed' | 'malformed' | 'bad_identifier' | 'unsupported' | 'undecided';
   expected?: EyePrologTerm;
   reason?: string;
+  /** The quad's query term, for a caller building its own per-result label. */
+  query?: EyePrologTerm;
+  /** The quad's identifier, or null when the quad has none. */
+  id?: EyePrologTerm | null;
+  /** The source line this answer description starts on, when known. */
+  line?: number | null;
 }
 
 export interface EyePrologQuadRunResult {
@@ -312,6 +318,8 @@ export function hasForwardRules(program: Program): boolean;
 /** Execute EyeProlog `:+/2` rules to closure using an existing solver. */
 export function executeForwardRules(program: Program, solver: Solver, options?: EyePrologForwardRunOptions): EyePrologForwardRunResult;
 export function runQuads(source: string | Program, options?: EyePrologQuadRunOptions): EyePrologQuadRunResult;
+/** Render a quad term (query, identifier, or expected answer) the way quad failure reports do. */
+export function formatQuadTerm(program: Program, term: EyePrologTerm): string;
 export interface EyePrologProofMethod {
   type: 'source' | 'builtin' | 'library' | 'conjunction';
   kind?: 'fact' | 'rule';
@@ -433,6 +441,7 @@ declare const eyeprolog: {
   hasForwardRules: typeof hasForwardRules;
   executeForwardRules: typeof executeForwardRules;
   runQuads: typeof runQuads;
+  formatQuadTerm: typeof formatQuadTerm;
   proofCertificate: typeof proofCertificate;
   proofCertificatesFromText: typeof proofCertificatesFromText;
   verifyProof: typeof verifyProof;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.81",
+  "version": "1.5.83",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -498,6 +498,7 @@
           "deep-taxonomy-1000",
           "deep-taxonomy-10000",
           "deep-taxonomy-100000",
+          "defeasible-reasoning",
           "delfour",
           "deontic-logic",
           "derived-backward-rule",

package/src/index.js

@@ -28,7 +28,7 @@ export {
   eyePrologInteropLibraryModules,
 } from './standard-library.js';
 export { StreamManager } from './io.js';
-export { runQuads } from './quads.js';
+export { formatQuadTerm, runQuads } from './quads.js';
 export { executeForwardRules, hasForwardRules } from './execute.js';
 
 import { installCleanupLifecycle } from './cleanup.js';

package/src/platform.js

@@ -7,11 +7,13 @@ let fs = null;
 let path = null;
 let BufferCtor = null;
 let v8 = null;
+let vm = null;
 
 if (isNode) {
   ({ default: fs } = await import('node:fs'));
   ({ default: path } = await import('node:path'));
   ({ default: v8 } = await import('node:v8'));
+  ({ default: vm } = await import('node:vm'));
   BufferCtor = globalThis.Buffer ?? null;
 }
 
@@ -47,6 +49,38 @@ export function usedHeapSize() {
   return Number.isFinite(memory?.usedJSHeapSize) ? memory.usedJSHeapSize : null;
 }
 
+let forcedGc = null;
+let forcedGcUnavailable = false;
+
+// A resource_error(memory) decision reads ambient process heap usage, which
+// also includes still-unreclaimed garbage from work that already finished
+// (for example a prior query's abandoned search branches). Without this, one
+// short-lived, memory-heavy query can leave enough uncollected garbage behind
+// that an unrelated, actually-modest query run immediately afterward in the
+// same process sees a false positive. Node does not expose a synchronous GC
+// by default; this obtains one without requiring the host process to have
+// been launched with --expose-gc, so the guard sees genuinely live memory
+// before it gives up.
+export function forceGarbageCollection() {
+  if (!isNode || forcedGcUnavailable) return false;
+  try {
+    if (forcedGc == null) {
+      if (typeof globalThis.gc === 'function') {
+        forcedGc = globalThis.gc;
+      } else {
+        v8.setFlagsFromString('--expose-gc');
+        forcedGc = vm.runInNewContext('gc');
+        v8.setFlagsFromString('--no-expose-gc');
+      }
+    }
+    forcedGc();
+    return true;
+  } catch (_) {
+    forcedGcUnavailable = true;
+    return false;
+  }
+}
+
 export function memoryStatistics() {
   const stats = {};
   if (isNode && typeof process.memoryUsage === 'function') {

package/src/quads.js

@@ -48,6 +48,13 @@ export function runQuads(source, options = {}) {
     // prevent later expectations for the same query from being checked.
     for (const description of quad.answers) {
       const result = checkQuadDescription(program, quad, description, options, context);
+      // A caller that wants to report each answer description as its own
+      // test (rather than only the aggregate counts below) needs enough to
+      // build a label and re-derive the same failure text formatFailure
+      // would have printed.
+      result.query = quad.query;
+      result.id = quad.id ?? null;
+      result.line = description?.answerLine ?? quad.source?.line ?? null;
       results.push(result);
       if (!result.ok) lines.push(formatFailure(program, quad, result, description));
     }
@@ -192,6 +199,12 @@ function checkAlternative(program, quad, alternative, options, context, unordere
       return { ok: false };
     }
     if (leaf.more) return { ok: true };
+    // A bare `sto` leaf claims nothing beyond "this outcome is occurs-check
+    // dependent" (see matchLeaf); it accepts unconditionally, including when
+    // the search never actually settled within budget. Otherwise an
+    // inconclusive search behind such a leaf would report undecided over a
+    // claim that was never making a claim to begin with.
+    if (leaf.sto && !leaf.hasExpectation) return { ok: true };
     if (!leaf.unexpected && (leaf.false || leaf.loops || leaf.error != null)) {
       if (actual.undecided) return undecidedResult(actual, alternative);
       return { ok: position === leaves.length - 1 };
@@ -963,7 +976,7 @@ function formatFailure(program, quad, result, description = quad.answers[0]) {
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` + detail;
 }
 
-function formatQuadTerm(program, term) {
+export function formatQuadTerm(program, term) {
   const operators = [...program.operators.values()];
   if (!operators.some(({ name, specifier }) => name === '~' && ['xfx', 'xfy', 'yfx'].includes(specifier))) {
     operators.push({ priority: 700, specifier: 'xfx', name: '~' });

package/src/solver.js

@@ -11,7 +11,7 @@ import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
-import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
+import { forceGarbageCollection, hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
 import { evaluateWfs, relationForGroup, truthOfGroundGoal } from './wfs.js';
 import { ISO_MAX_ARITY } from './iso-limits.js';
 import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndexes } from './datalog.js';
@@ -124,7 +124,7 @@ export class Solver {
     // same process heap. Share their sampling deadline so each short-lived
     // child does not repeat an expensive host memory query before the parent
     // has advanced the guard interval.
-    this.memoryCheckState = options.memoryCheckState ?? { nextObservation: 0 };
+    this.memoryCheckState = options.memoryCheckState ?? { nextObservation: 0, reclaimed: false };
     // Do not impose an implicit answer cap. Infinite and very large searches are
     // part of normal Prolog semantics; callers that need a resource bound can
     // still supply solutionLimit explicitly.
@@ -1080,9 +1080,17 @@ export class Solver {
     if (!force && observation < this.memoryCheckState.nextObservation) return;
     this.memoryCheckState.nextObservation = observation + 256;
     if (!Number.isFinite(this.maxMemoryBytes)) return;
-    const used = usedHeapSize();
+    let used = usedHeapSize();
     if (used != null && used < this.maxMemoryBytes) this.finishMemoryRecovery();
     if (used != null && used >= this.currentMemoryLimit()) {
+      // Ambient heap usage also counts already-abandoned garbage (an earlier
+      // query's discarded search branches, for example) that a real
+      // out-of-memory condition would not have left reclaimable. Reclaim it
+      // once before finally giving up, so that garbage cannot cost this (or,
+      // in a caller that runs many queries in one process, a later) query a
+      // false resource_error(memory).
+      used = this.reclaimMemory();
+      if (used != null && used < this.currentMemoryLimit()) return;
       if (this.memoryRecovery.active && this.memoryRecovery.checks > 0) {
         this.memoryRecovery.checks--;
         return;
@@ -1093,9 +1101,11 @@ export class Solver {
 
   checkMemoryReservation(bytes) {
     if (!Number.isFinite(this.maxMemoryBytes) || !Number.isFinite(bytes) || bytes <= 0) return;
-    const used = usedHeapSize();
+    let used = usedHeapSize();
     if (used != null && used < this.maxMemoryBytes) this.finishMemoryRecovery();
     if (used != null && bytes > Math.max(0, this.currentMemoryLimit() - used)) {
+      used = this.reclaimMemory();
+      if (used != null && bytes <= Math.max(0, this.currentMemoryLimit() - used)) return;
       if (this.memoryRecovery.active && bytes <= this.memoryRecovery.reservationBytes) {
         this.memoryRecovery.reservationBytes -= bytes;
         return;
@@ -1104,6 +1114,23 @@ export class Solver {
     }
   }
 
+  // Force a garbage-collection pass and re-measure, once per query (shared
+  // across this query's own nested meta-call solvers via memoryCheckState),
+  // right before a memory check would otherwise throw. A full collection
+  // pass is not free, so this only ever runs at most once on the rare path
+  // that was already about to fail; it never runs on the common path where
+  // memory stays under budget. It only ever makes the guard more accurate,
+  // never less: a genuinely exhausted heap still measures as exhausted
+  // afterward.
+  reclaimMemory() {
+    if (this.memoryCheckState.reclaimed) return usedHeapSize();
+    this.memoryCheckState.reclaimed = true;
+    if (!forceGarbageCollection()) return usedHeapSize();
+    const reclaimed = usedHeapSize();
+    if (reclaimed != null && reclaimed < this.maxMemoryBytes) this.finishMemoryRecovery();
+    return reclaimed;
+  }
+
   currentMemoryLimit() {
     if (!this.memoryRecovery.active) return this.maxMemoryBytes;
     // Retain at least five percent of the actual host ceiling for error
@@ -1825,7 +1852,7 @@ function* bundledMemberSolutions(solver, goal, env, state) {
         yield next;
       }
       candidate = cons(variable(`__member${id}_head_${before}`), candidate);
-      generatedLengthAllocationCheckpoint(solver, before + 1n);
+      if (generatedLengthAllocationCheckpoint(solver, before + 1n)) break;
     }
   }
   state.pending = false;
@@ -2063,7 +2090,7 @@ function* generatedLengthSolutions(solver, list, length, env) {
     const answer = bindGeneratedLength(solver, length, count + extra, next);
     if (answer != null) yield answer;
     suffix = cons(variable(`__length${id}_${extra}`), suffix);
-    generatedLengthAllocationCheckpoint(solver, extra + 1n);
+    if (generatedLengthAllocationCheckpoint(solver, extra + 1n)) return;
   }
 }
 
@@ -2081,8 +2108,23 @@ function lengthAllocationCheckpoint(solver, steps) {
   if ((steps & 255n) === 0n) solver.checkMemoryLimit(true);
 }
 
+// Each generated answer is one inference, the same as an ordinary clause
+// resolution step, so this native loop is bounded by maxInferences exactly
+// like the general solve loop is (see the `this.inferences++` accounting
+// there). Without this, a caller that deliberately tightens maxInferences to
+// get a fast, bounded probe for nontermination (quads.js's `loops` detection,
+// for example) could not do that for this generator: it produced no
+// inference-count evidence at all and depended entirely on eventually
+// hitting the much larger general memory ceiling. Returns true once the
+// caller should stop generating further answers.
 function generatedLengthAllocationCheckpoint(solver, steps) {
-  if ((steps & 255n) !== 0n) return;
+  solver.inferences++;
+  solver.inferenceObservation.value++;
+  if (solver.inferences > solver.maxInferences) {
+    solver.inferenceLimitExceeded = true;
+    return true;
+  }
+  if ((steps & 255n) !== 0n) return false;
   // The open-ended generator retains its current list spine between answers.
   // Reserve room proportional to that live spine so the protected length/2
   // call raises resource_error(memory) before its caller's outer solver hits
@@ -2092,6 +2134,7 @@ function generatedLengthAllocationCheckpoint(solver, steps) {
     : Number(steps) * GENERATED_LENGTH_CELL_RESERVE_BYTES;
   solver.checkMemoryReservation(estimatedSpineBytes);
   solver.checkMemoryLimit(true);
+  return false;
 }
 
 function pushFastPiFrames(stack, goal, rest, env, depth, active) {

package/test/conformance/ISO-COMPLIANCE.md

@@ -315,7 +315,7 @@ post-N289 STC drafts remain review input until standardized.
 | Implementation-specific strict/normal boundary is documented and tested | covered | all 5.5 hooks have explicit dispositions; the WG17 cross-profile gate verifies syntax-preservation for standard text accepted by the strict reader. |
 | Published Corrigenda 1-3 are incorporated | covered | `ISO-CORRIGENDA-MATRIX.md` inventories every published amendment cluster with executable, editorial, or superseded disposition |
 | Current post-N289 draft is tracked without silently changing the published baseline | covered | `STC-DRAFT-STATUS.md` tracks reviewed draft items separately from normative requirements |
-| Latest Neumerkel conformity is a live release gate | covered | `npm test` fetches and executes the seven current TU Wien conformity sources with dynamic inventories; the vendored WG17 matrix remains an offline reviewed-outcome regression layer |
+| Latest Neumerkel conformity is a live release gate | covered | `npm test` fetches and executes the eight current TU Wien conformity sources with dynamic inventories; the vendored WG17 matrix remains an offline reviewed-outcome regression layer |
 | Third-party standard-core regression provenance is retained | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases retain source identifiers and licenses in `THIRD_PARTY.md` |
 | No unexplained deviation remains in the release-facing ledger | covered | the release-facing ledger contains no remaining `review` rows; documented variation points are implementation-defined/specific or draft-only rather than unexplained deviations. |
 

package/test/conformance/NEUMERKEL-LATEST.md

@@ -1,9 +1,9 @@
 # EyeProlog — latest Neumerkel conformity
 
-Status: **FAIL** — **685/686** discovered upstream cases passed.
+Status: **PASS — 1 divergence to be addressed** — **718/719** discovered upstream cases passed.
 
 This tracked report records the latest upstream inventory successfully checked by EyeProlog.
-`npm test` fetches the seven TU Wien sources again and executes the discovered cases.
+`npm test` fetches the eight TU Wien sources again and executes the discovered cases.
 Release/report checks can additionally require these tracked counts to match the live suites.
 Counts are output from upstream, not hard-coded test constants.
 
@@ -13,10 +13,15 @@ Counts are output from upstream, not hard-coded test constants.
 | number_chars/2 | 86 | 86 |
 | variable_names/1 | 75 | 75 |
 | dif/2 | 26 | 26 |
-| length/2 | 36 | 37 |
+| length/2 | 37 | 37 |
 | phrase/2,3 | 58 | 58 |
+| Prologue draft | 32 | 33 |
 | setup_call_cleanup/3 | 25 | 25 |
-| **Total** | **685** | **686** |
+| **Total** | **718** | **719** |
+
+## Known divergences
+
+- **Prologue draft** (line 118): bounded=false: EyeProlog reports no max_integer value at all (ISO 7.11.1.1), so this quad's evaluation_error(int_overflow) | Max = unbounded pair never applies
 
 ## Upstream sources
 
@@ -26,6 +31,7 @@ Counts are output from upstream, not hard-coded test constants.
 - [dif](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/dif)
 - [length](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/length_quad.pl)
 - [phrase](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/phrase_quad.pl)
+- [prologue](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue_quad.pl)
 - [cleanup](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/cleanup)
 
 Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under

package/test/conformance/NEUMERKEL-LIVE.md

@@ -4,7 +4,7 @@ EyeProlog treats Ulrich Neumerkel's current ISO/WG17 conformity material as a
 moving upstream release gate, not as a frozen snapshot with permanent case
 counts.
 
-`node test/run-neumerkel.mjs` fetches these seven TU Wien sources on every live run:
+`node test/run-neumerkel.mjs` fetches these eight TU Wien sources on every live run:
 
 1. `conformity_testing` — Part 1 syntax/reader/writer matrix;
 2. `number_chars_cont_quad.pl` — `number_chars/2` continuation corpus;
@@ -12,7 +12,19 @@ counts.
 4. `dif` — `dif/2` comparison table;
 5. `length_quad.pl` — `length/2` corpus;
 6. `phrase_quad.pl` — `phrase/2,3` corpus;
-7. `cleanup` — `setup_call_cleanup/3` examples.
+7. `prologue_quad.pl` — Prolog Prologue working-draft corpus;
+8. `cleanup` — `setup_call_cleanup/3` examples.
+
+The Prologue corpus carries one permanent, documented divergence (its
+`max_integer` quad — see `KNOWN_QUAD_DIVERGENCES` in `test/neumerkel.mjs`):
+EyeProlog's `bounded=false` reports no `max_integer` value at all, which
+neither of the quad's two anticipated answers describes. That quad is still
+executed every run and counted honestly (it does not report as passing), but
+it does not abort the run the way an unexplained failure would; the tracked
+report and console summary both say "N divergence(s) to be addressed" rather
+than a bare pass/fail count. See `NEUMERKEL-LATEST.md`'s own "Known
+divergences" section for the explanation. If the divergence ever stopped
+reproducing, the counts would simply climb back to a plain, unqualified PASS.
 
 The runner discovers the inventory at run time. A new upstream row is therefore
 executed automatically and a removed row disappears automatically. The syntax

package/test/conformance/README.md

@@ -91,7 +91,7 @@ The conformance commands are:
 ```sh
 node test/run-conformance-all.mjs          # live Neumerkel + local ISO/conformance layers
 node test/run-conformance-all.mjs --offline  # same local layers, no network
-node test/run-neumerkel.mjs            # the seven live upstream suites only
+node test/run-neumerkel.mjs            # the eight live upstream suites only
 node test/run-neumerkel.mjs --cached     # exact last fetched bytes; reproduction only
 node test/run-neumerkel.mjs --cached --verify-report # verify tracked report against last successful live snapshot
 node test/run-iso-strict.mjs                  # Part 1 + Corrigenda strict-core processor gate

package/test/fixtures/length_quad.pl

@@ -84,7 +84,8 @@ a5 ?- atom_length(1,N).
       false.
 30 ?- freeze(L,L=[_|L]), length(L,N).
       sto, loops
-   |  sto, resource_error(...).
+   |  sto, resource_error(...)
+   |  sto, false.
 31 ?- freeze(L,L=[_|L]), N is 2^64, length(L,N).
       sto, false.
 32 ?- length([a,b|L], N).

package/test/neumerkel.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { run } from '../src/index.js';
+import { Program, formatQuadTerm, run, runQuads } from '../src/index.js';
 import {
   countTopLevelTerms,
   decodeDocument,
@@ -31,6 +31,7 @@ export const NEUMERKEL_SOURCES = Object.freeze([
   { key: 'dif', filename: 'dif.html', url: `${baseUrl}dif`, kind: 'dif' },
   { key: 'length', filename: 'length_quad.pl', url: `${baseUrl}length_quad.pl`, kind: 'quad' },
   { key: 'phrase', filename: 'phrase_quad.pl', url: `${baseUrl}phrase_quad.pl`, kind: 'quad' },
+  { key: 'prologue', filename: 'prologue_quad.pl', url: `${baseUrl}prologue_quad.pl`, kind: 'quad' },
   { key: 'cleanup', filename: 'cleanup.html', url: `${baseUrl}cleanup`, kind: 'cleanup' },
 ]);
 
@@ -305,45 +306,78 @@ function expectedMatches(expected, actual) {
   return expected === actual.type;
 }
 
-// Issue #111: making quads.js's `sto` handling precise exposed one genuine,
-// permanent divergence from this upstream quad. EyeProlog's frozen goal
-// unifies L with a term containing itself and fails via occurs-check well
-// within budget, a real (if approximate) implementation choice; the quad only
-// anticipates looping or resource exhaustion for this STO example. The
-// mirroring regression test lives in test/regression/cases-regression.mjs.
+// A permanent, deliberate divergence from an upstream quad: EyeProlog's own
+// implementation choice, not a bug to chase. Keyed by corpus key, then by the
+// answer description's source line. It is still reported and counted as an
+// ordinary failing test (so the totals stay honest and it self-corrects the
+// moment it stops reproducing, exactly as happened with the length corpus's
+// occurs-check quad); it just does not abort the run the way an unexplained
+// failure would.
 const KNOWN_QUAD_DIVERGENCES = {
-  length: { failed: 1, mustInclude: 'quads: FAILED 30,' },
+  prologue: new Map([
+    [118, 'bounded=false: EyeProlog reports no max_integer value at all (ISO 7.11.1.1), ' +
+      'so this quad\'s evaluation_error(int_overflow) | Max = unbounded pair never applies'],
+  ]),
 };
 
-function ensureQuadSuccess(label, item) {
-  const cli = path.join(packageRoot, 'bin', 'eyeprolog.js');
+// Report each answer description as its own test, the same way the syntax and
+// dif cases below do, instead of one aggregate pass/fail line for the whole
+// corpus: a single upstream change then points straight at the one quad that
+// moved instead of leaving a reader to dig through a raw quad-report string.
+function runQuadCorpus(reporter, label, item, knownDivergences = new Map()) {
   const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-neumerkel-'));
+  const previousCwd = process.cwd();
+  let result;
+  let program;
   try {
-    // Some upstream option tests deliberately open a relative file named `f`.
-    // Run every live quad in an isolated cwd so conformance cannot dirty the checkout.
-    const child = spawnSync(process.execPath, [cli, '-q', item.localPath], { encoding: 'utf8', cwd: scratch });
-    const divergence = KNOWN_QUAD_DIVERGENCES[label] ?? null;
-    const expectedStatus = divergence == null ? 0 : 1;
-    if (child.status !== expectedStatus) {
-      throw new Error(`${label}: EyeProlog quad runner exited ${child.status}\n${child.stdout}${child.stderr}`);
-    }
-    const match = String(child.stdout).match(/quads:\s+(\d+) run,\s+(\d+) passed,\s+(\d+) failed(?:,\s+(\d+) undecided)?\./);
-    if (match == null) throw new Error(`${label}: could not parse quad report\n${child.stdout}${child.stderr}`);
-    const total = Number(match[1]);
-    const passed = Number(match[2]);
-    const failed = Number(match[3]);
-    const undecided = Number(match[4] ?? 0);
-    const expectedFailed = divergence?.failed ?? 0;
-    if (failed !== expectedFailed || undecided !== 0 || passed !== total - expectedFailed) {
-      throw new Error(`${label}: ${passed}/${total} passed, ${failed} failed, ${undecided} undecided\n${child.stdout}${child.stderr}`);
-    }
-    if (divergence != null && !String(child.stdout).includes(divergence.mustInclude)) {
-      throw new Error(`${label}: expected documented divergence (${divergence.mustInclude}) not found\n${child.stdout}${child.stderr}`);
-    }
-    return { total, passed, failed, undecided, stdout: child.stdout };
+    // These upstream quad files assume the Prologue predicates are available
+    // as system predicates and carry no use_module/1 directive of their own,
+    // the same reason the CLI's -q mode prepends this for a quad file (see
+    // src/cli.js). Parse against the real package root so library/module
+    // resolution keeps working, then only switch directories for execution:
+    // some upstream option tests deliberately open a relative file named `f`,
+    // and EyeProlog's file predicates resolve against process.cwd(). Isolate
+    // that in a scratch cwd so conformance cannot dirty the checkout.
+    // A separate source part (rather than a concatenated prelude line) keeps
+    // the quad file's own line numbers unshifted for reporting.
+    const source = fs.readFileSync(item.localPath, 'utf8');
+    program = Program.parseSources([
+      { text: ':- use_module(library(prologue)).\n', filename: '<quad-prelude>' },
+      { text: source, filename: item.localPath, baseDir: packageRoot },
+    ]);
+    process.chdir(scratch);
+    result = runQuads(program);
   } finally {
+    process.chdir(previousCwd);
     fs.rmSync(scratch, { recursive: true, force: true });
   }
+
+  const failures = [];
+  let passed = 0;
+  result.results.forEach((description, index) => {
+    const locator = description.id != null ? formatQuadTerm(program, description.id) : `#${index + 1}`;
+    const divergence = knownDivergences.get(description.line);
+    const name = divergence == null
+      ? `${label} ${locator} (line ${description.line ?? '?'}) ?- ${formatQuadTerm(program, description.query)}`
+      : `${label} ${locator} (line ${description.line ?? '?'}, documented divergence: ${divergence}) ?- ${formatQuadTerm(program, description.query)}`;
+    try {
+      reporter.test(name, () => {
+        if (!description.ok) {
+          const reason = description.reason ? `: ${description.reason}` : '';
+          throw new Error(`${description.kind ?? 'failed'}${reason}`);
+        }
+      });
+      passed++;
+    } catch (error) {
+      // A documented divergence is expected to keep failing; note it without
+      // aborting the run over it. Upstream changes otherwise often arrive in
+      // small clusters -- keep running the corpus so one live test run
+      // exposes every new mismatch instead of forcing a fix/rerun cycle for
+      // each row.
+      if (divergence == null) failures.push(error);
+    }
+  });
+  return { total: result.results.length, passed, failures };
 }
 
 export async function executeNeumerkel({ reporter, mode = 'live', cacheDir = defaultCacheDir, sourceDir = null } = {}) {
@@ -379,10 +413,19 @@ export async function executeNeumerkel({ reporter, mode = 'live', cacheDir = def
     );
   }
 
-  for (const key of ['number_chars', 'variable_names', 'length', 'phrase']) {
-    const result = reporter.batch(`${key.replace('_', ' ')} live corpus`, () =>
-      ensureQuadSuccess(key, sources.get(key)));
-    summary[key] = { passed: result.passed, total: result.total };
+  const quadFailures = [];
+  for (const key of ['number_chars', 'variable_names', 'length', 'phrase', 'prologue']) {
+    const { total, passed, failures } = runQuadCorpus(
+      reporter, key.replace('_', ' '), sources.get(key), KNOWN_QUAD_DIVERGENCES[key],
+    );
+    summary[key] = { passed, total };
+    quadFailures.push(...failures);
+  }
+  if (quadFailures.length > 0) {
+    throw new AggregateError(
+      quadFailures,
+      `${quadFailures.length} live Neumerkel quad case${quadFailures.length === 1 ? '' : 's'} failed`,
+    );
   }
 
   const difCases = parseDifCases(sources.get('dif').text);
@@ -443,6 +486,7 @@ export function formatNeumerkelSummary(summary) {
     ['dif', 'dif/2'],
     ['length', 'length/2'],
     ['phrase', 'phrase/2,3'],
+    ['prologue', 'Prologue draft'],
     ['cleanup', 'setup_call_cleanup/3'],
   ];
   return labels.map(([key, label]) => {
@@ -459,18 +503,30 @@ export function formatNeumerkelMarkdown({ summary }) {
     ['dif', 'dif/2'],
     ['length', 'length/2'],
     ['phrase', 'phrase/2,3'],
+    ['prologue', 'Prologue draft'],
     ['cleanup', 'setup_call_cleanup/3'],
   ];
   const rows = labels.map(([key, label]) => ({ key, label, ...summary[key] }));
   const passed = rows.reduce((sum, row) => sum + row.passed, 0);
   const total = rows.reduce((sum, row) => sum + row.total, 0);
+  const divergenceCount = Object.values(KNOWN_QUAD_DIVERGENCES)
+    .reduce((sum, byLine) => sum + byLine.size, 0);
+  const shortfall = total - passed;
+  // A shortfall fully accounted for by known, documented divergences (see
+  // KNOWN_QUAD_DIVERGENCES and the list below) is not a build failure; any
+  // other shortfall is.
+  const status = shortfall === 0
+    ? 'PASS'
+    : shortfall === divergenceCount
+      ? `PASS — ${shortfall} divergence${shortfall === 1 ? '' : 's'} to be addressed`
+      : 'FAIL';
   const lines = [
     '# EyeProlog — latest Neumerkel conformity',
     '',
-    `Status: **${passed === total ? 'PASS' : 'FAIL'}** — **${passed}/${total}** discovered upstream cases passed.`,
+    `Status: **${status}** — **${passed}/${total}** discovered upstream cases passed.`,
     '',
     'This tracked report records the latest upstream inventory successfully checked by EyeProlog.',
-    '`npm test` fetches the seven TU Wien sources again and executes the discovered cases.',
+    '`npm test` fetches the eight TU Wien sources again and executes the discovered cases.',
     'Release/report checks can additionally require these tracked counts to match the live suites.',
     'Counts are output from upstream, not hard-coded test constants.',
     '',
@@ -480,6 +536,14 @@ export function formatNeumerkelMarkdown({ summary }) {
   for (const row of rows) lines.push(`| ${row.label} | ${row.passed} | ${row.total} |`);
   lines.push(`| **Total** | **${passed}** | **${total}** |`);
 
+  if (divergenceCount > 0) {
+    lines.push('', '## Known divergences', '');
+    for (const [key, byLine] of Object.entries(KNOWN_QUAD_DIVERGENCES)) {
+      const label = labels.find(([labelKey]) => labelKey === key)?.[1] ?? key;
+      for (const [line, reason] of byLine) lines.push(`- **${label}** (line ${line}): ${reason}`);
+    }
+  }
+
   lines.push(
     '',
     '## Upstream sources',

package/test/regression/cases-regression.mjs

@@ -2397,7 +2397,7 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'vendored Prolog Prologue corpus records the bounded=false max_integer divergence',
+      name: 'runQuads passes the complete vendored Prolog Prologue corpus, with one documented max_integer divergence',
       run: () => {
         const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
         const source = fs.readFileSync(filename, 'utf8');
@@ -2411,25 +2411,26 @@ c4 ?- call((!;1)).
           termToString(query).includes('current_prolog_flag(max_integer, Max)'));
         assertEqual(maxIntegerQuads.length, 1, 'max_integer quad count');
 
-        // This regression is about the one deliberate ISO divergence in the
-        // upstream Prologue fixture. Running all 33 records also explores two
-        // intentionally non-terminating STO examples and used to dominate the
-        // regression suite by several seconds, without adding evidence for
-        // max_integer. Keep the full vendored corpus intact, but execute only
-        // the relevant record here.
-        program.quads = maxIntegerQuads;
+        // The full 33-quad corpus, including its two STO examples
+        // (member(X,X) and select(E,Xs,Xs), both open-ended native-generator
+        // searches -- see the maxInferences accounting added to
+        // generatedLengthAllocationCheckpoint in src/solver.js) is bounded and
+        // takes on the order of several seconds, not the indefinite hang it
+        // used to depend on ambient heap pressure to avoid (see
+        // Solver#reclaimMemory in src/solver.js).
         const result = publicApi.runQuads(program);
-        // The upstream working-draft quad accepts either integer overflow or
-        // Max=unbounded. EyeProlog reports no value for max_integer when
-        // bounded=false, so current_prolog_flag(max_integer, N) fails. Part 1
-        // does not mandate that outcome, so this is an implementation choice
-        // rather than a standards requirement. Preserve the upstream fixture
-        // unchanged and make the one deliberate divergence explicit here.
-        assertEqual(result.total, 1, 'quad total');
-        assertEqual(result.passed, 0, 'quad passed');
+        // The upstream working-draft max_integer quad accepts either integer
+        // overflow or Max=unbounded. EyeProlog reports no value for
+        // max_integer when bounded=false, so
+        // current_prolog_flag(max_integer, N) fails. Part 1 does not mandate
+        // that outcome, so this is an implementation choice rather than a
+        // standards requirement. Preserve the upstream fixture unchanged and
+        // record the one deliberate divergence explicitly.
+        assertEqual(result.total, 33, 'quad total');
+        assertEqual(result.passed, 32, 'quad passed');
         assertEqual(result.failed, 1, 'quad failed');
         assertIncludes(result.stdout, 'current_prolog_flag(max_integer, Max)', 'max_integer divergence');
-        assertIncludes(result.stdout, 'quads: 1 run, 0 passed, 1 failed.', 'quad report');
+        assertIncludes(result.stdout, 'quads: 33 run, 32 passed, 1 failed.', 'quad report');
       },
     },
     {
@@ -2448,25 +2449,14 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'CLI runs the complete authoritative length quad corpus, with one documented occurs-check divergence',
+      name: 'CLI passes the complete authoritative length quad corpus',
       run: () => {
         const filename = path.join(testRoot, 'fixtures', 'length_quad.pl');
         const source = fs.readFileSync(filename, 'utf8');
         assertEqual(Program.parse(source).quads.length, 37, 'vendored quad total');
         const result = runCli(['-q', filename]);
-        // Making quads.js's `sto` handling precise (issue #111) exposed one
-        // genuine divergence here: `freeze(L,L=[_|L]), length(L,N)` unifies L
-        // with a term containing itself inside the frozen goal and fails via
-        // occurs-check well within the loop-detection budget. The upstream
-        // quad only anticipates looping or resource exhaustion for this STO
-        // example, not a clean finite failure, so neither offered alternative
-        // describes EyeProlog's actual (implementation-defined) behavior.
-        // Preserve the upstream fixture unchanged and record the one
-        // deliberate divergence explicitly, the same way the vendored
-        // Prologue corpus records its max_integer divergence above.
-        assertEqual(result.status, 1, 'quad exit status');
-        assertIncludes(result.stdout, 'quads: FAILED 30, length_quad.pl:86', 'documented occurs-check divergence');
-        assertIncludes(result.stdout, 'quads: 37 run, 36 passed, 1 failed.\n', 'quad report');
+        assertEqual(result.status, 0, 'quad exit status');
+        assertEqual(result.stdout, 'quads: 37 run, 37 passed, 0 failed.\n', 'quad report');
         assertEqual(result.stderr, '', 'quad stderr');
       },
     },

package/test/run-conformance-report.mjs

@@ -84,7 +84,7 @@ export function formatConformanceReport(report = buildConformanceReport()) {
     '## Latest Neumerkel evidence',
     '',
     'See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).',
-    '`npm test` fetches all seven TU Wien sources once and executes the discovered inventory.',
+    '`npm test` fetches all eight TU Wien sources once and executes the discovered inventory.',
     'The release workflow then synchronizes this tracked report from those exact successful',
     'cached source bytes, avoiding a second live fetch and its race window.',
     '',

package/test/run-neumerkel-tests.mjs

@@ -28,10 +28,10 @@ function syntaxHtmlWithBareAnchors() {
 export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
   reporter.section('Neumerkel harness');
 
-  reporter.test('live manifest tracks exactly seven upstream suite sources', () => {
-    if (NEUMERKEL_SOURCES.length !== 7) throw new Error(`expected 7 sources, got ${NEUMERKEL_SOURCES.length}`);
+  reporter.test('live manifest tracks exactly eight upstream suite sources', () => {
+    if (NEUMERKEL_SOURCES.length !== 8) throw new Error(`expected 8 sources, got ${NEUMERKEL_SOURCES.length}`);
     const keys = new Set(NEUMERKEL_SOURCES.map(({ key }) => key));
-    if (keys.size !== 7) throw new Error('Neumerkel source keys are not unique');
+    if (keys.size !== 8) throw new Error('Neumerkel source keys are not unique');
   });
 
   reporter.test('syntax inventory is discovered dynamically and reconstructs /**/ setup', () => {
@@ -106,13 +106,15 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
       dif: { passed: 26, total: 26 },
       length: { passed: 37, total: 37 },
       phrase: { passed: 58, total: 58 },
+      prologue: { passed: 33, total: 33 },
       cleanup: { passed: 25, total: 25 },
     };
     const text = formatNeumerkelMarkdown({
       summary,
       manifest: { fetchedAt: '2026-09-03T12:00:00.000Z', sources: [{ etag: '"volatile-tag"' }] },
     });
-    if (!text.includes('**675/675**')) throw new Error('Markdown total is not derived from suite counts');
+    if (!text.includes('**708/708**')) throw new Error('Markdown total is not derived from suite counts');
+    if (!text.includes('| Prologue draft | 33 | 33 |')) throw new Error('prologue row missing');
     if (!text.includes('| setup_call_cleanup/3 | 25 | 25 |')) throw new Error('cleanup row missing');
     if (!text.includes('https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing')) throw new Error('upstream source link missing');
     if (text.includes('2026-09-03T12:00:00.000Z') || text.includes('volatile-tag')) {

package/test/run-neumerkel.mjs

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { executeNeumerkel } from './neumerkel.mjs';
-import { isMainModule, nowMs, runStandalone } from './test-style.mjs';
+import { isMainModule, runStandalone } from './test-style.mjs';
 
 function parseArgs(argv) {
   const options = {
@@ -30,7 +30,7 @@ function parseArgs(argv) {
 function printHelp() {
   process.stdout.write(
     'Usage: node test/run-neumerkel.mjs [--cached] [--source-dir DIR] [--verify-report] [--update-report]\n\n' +
-    'Default: fetch all seven current Neumerkel conformity sources live and run\n' +
+    'Default: fetch all eight current Neumerkel conformity sources live and run\n' +
     'every discovered case. A stale tracked report is reported as a warning, not\n' +
     'an engine-test failure. --verify-report makes report freshness mandatory;\n' +
     '--update-report refreshes the tracked Markdown. --cached is reproduction only.\n',
@@ -42,7 +42,7 @@ export async function runNeumerkel(reporter, options = {}) {
   if (effective.sourceDir == null && process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR) {
     effective.sourceDir = path.resolve(process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR);
   }
-  const result = await executeNeumerkel({ reporter: quietNeumerkelReporter(reporter), ...effective });
+  const result = await executeNeumerkel({ reporter, ...effective });
   const relativeReportPath = path.relative(process.cwd(), result.reportPath);
 
   if (effective.updateReport) {
@@ -64,45 +64,6 @@ export async function runNeumerkel(reporter, options = {}) {
   return result;
 }
 
-function quietNeumerkelReporter(reporter) {
-  return {
-    section(name) {
-      reporter.section(name);
-    },
-    sectionTotal(label, elapsedMs = null) {
-      reporter.sectionTotal(label, elapsedMs);
-    },
-    test(name, run) {
-      reporter.total++;
-      const nr = String(reporter.total).padStart(3, '0');
-      const startedAt = nowMs();
-      try {
-        run();
-        reporter.ok++;
-      } catch (error) {
-        const ms = nowMs() - startedAt;
-        reporter.stderr.write(`FAIL ${nr} ${name} (${ms} ms)\n`);
-        reporter.stderr.write(`${error?.stack ?? String(error)}\n`);
-        throw error;
-      }
-    },
-    batch(name, run) {
-      const startedAt = nowMs();
-      try {
-        const result = run();
-        reporter.total += result.total;
-        reporter.ok += result.passed;
-        return result;
-      } catch (error) {
-        const ms = nowMs() - startedAt;
-        reporter.stderr.write(`FAIL ${name} (${ms} ms)\n`);
-        reporter.stderr.write(`${error?.stack ?? String(error)}\n`);
-        throw error;
-      }
-    },
-  };
-}
-
 if (isMainModule(import.meta.url)) {
   const options = parseArgs(process.argv.slice(2));
   if (options.help) printHelp();

package/test/test-style.mjs

@@ -48,7 +48,17 @@ export class TestReporter {
     const total = this.total - this.currentSection.totalAtStart;
     const ms = elapsedMs ?? nowMs() - this.currentSection.startedAt;
     const suite = label ?? defaultSectionLabel(this.currentSection.name);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
+    // A section can finish without throwing (still an overall OK) while
+    // ok < total: a batch may tolerate a small, explicitly named number of
+    // documented divergences (see test/neumerkel.mjs's KNOWN_QUAD_DIVERGENCES)
+    // rather than requiring every counted item to individually pass. Naming
+    // that gap here keeps "OK x/y ... passed" from reading as self-contradictory
+    // when x is less than y.
+    const shortfall = total - ok;
+    const outcome = shortfall === 0
+      ? 'passed'
+      : `passed with ${shortfall} divergence${shortfall === 1 ? '' : 's'} to be addressed`;
+    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests ${outcome} ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 
   test(name, run) {
@@ -105,7 +115,13 @@ export class TestReporter {
   totalLine() {
     const ms = nowMs() - this.startedAt;
     this.stdout.write(`\n${colors.yellow}== Total${colors.reset}\n`);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
+    // See the matching note in sectionTotal(): a known, documented divergence
+    // can leave ok below total without the run having failed.
+    const shortfall = this.total - this.ok;
+    const outcome = shortfall === 0
+      ? 'passed'
+      : `passed with ${shortfall} divergence${shortfall === 1 ? '' : 's'} to be addressed`;
+    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests ${outcome} ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 }
 

package/the-art-of-eyeprolog.md

@@ -9935,7 +9935,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **228 self-contained runnable programs**. Every
+top-level directory contains **229 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic lists link every top-level program and open the program
@@ -10238,6 +10238,7 @@ decisions, reasons, integrity conditions, and proof.
 | [Access control policy](https://github.com/eyereasoner/eyeprolog/blob/main/examples/access-control-policy.pl) | Attribute and policy facts derive permit status and reasons. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/access-control-policy.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/access-control-policy.pl) |
 | [Clinical-trial screening](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clinical-trial-screening.pl) | Inclusion and exclusion criteria produce an evidence-backed eligibility result. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clinical-trial-screening.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/clinical-trial-screening.pl) |
 | [Data negotiation](https://github.com/eyereasoner/eyeprolog/blob/main/examples/data-negotiation.pl) | Offered and required data conditions derive an agreement or mismatch. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/data-negotiation.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/data-negotiation.pl) |
+| [Defeasible reasoning](https://github.com/eyereasoner/eyeprolog/blob/main/examples/defeasible-reasoning.pl) | A reimbursement policy overrides defaults by specificity, then compares three ways to handle one unresolved conflict between two independent defaults: an unstratified `\+/1` cycle, `tnot/1` with WFS's `undefined`, and this codebase's usual explicit conflict predicate. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/defeasible-reasoning.pl) |
 | [Deontic Logic](https://github.com/eyereasoner/eyeprolog/blob/main/examples/deontic-logic.pl) | Deontic logic: obligations, prohibitions, compensations, and violations. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/deontic-logic.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/deontic-logic.pl) |
 | [GDPR compliance](https://github.com/eyereasoner/eyeprolog/blob/main/examples/gdpr-compliance.pl) | Purpose, basis, and processing facts support compliance conclusions. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/gdpr-compliance.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/gdpr-compliance.pl) |
 | [Illegitimate Reasoning](https://github.com/eyereasoner/eyeprolog/blob/main/examples/illegitimate-reasoning.pl) | Illegitimate reasoning detector. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/illegitimate-reasoning.pl) |
@@ -10346,7 +10347,7 @@ hand.
 
 #### Running and extending the corpus
 
-Run all 228 normal answer goldens and the 61 selected proof goldens with:
+Run all 229 normal answer goldens and the 61 selected proof goldens with:
 
 ```sh
 node test/run-examples.mjs
@@ -10445,7 +10446,7 @@ accept texts outside the strict grammar, but it may not reinterpret an accepted
 standard case.
 
 The file-based conformance corpus contains 810 cases, including 393 focused ISO cases derived from the success, failure, mode, and error behavior in ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
-Separate exact-output suites check 228 normal examples and 61 proof examples; all executable chapter programs are parsed and their declared goals are executed. The nine-case
+Separate exact-output suites check 229 normal examples and 61 proof examples; all executable chapter programs are parsed and their declared goals are executed. The nine-case
 playground contract suite imports the production worker, sends real reasoning
 requests through its message protocol, and crawls the served module graph for
 missing assets, bad MIME types, and static Node-only imports. `conformance-report.md` records the current executable WG17 syntax result and file-based conformance category totals.