eyeprolog 1.5.32 → 1.5.33

package/README.md

@@ -74,9 +74,9 @@ All 33 bundled modules that overlap Scryer's current `src/lib/` surface cover Sc
 - [Symbiotic Knowledge Graphs](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
 - [rdf-prolog-roundtrip](https://github.com/eyereasoner/rdf-prolog-roundtrip) — standalone RDF 1.2 ↔ ISO Prolog bridge used by the RDF examples
 - [ISO conformance audit](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
-- [Conformance report](conformance-report.md) — generated executable conformance status and corpus summary
+- [Latest Neumerkel conformity](test/conformance/NEUMERKEL-LATEST.md) — tracked result from the current live upstream inventory
+- [Conformance report](conformance-report.md) — generated executable conformance status and local corpus summary
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
-
 ## RDF, Prolog, and symbiotic knowledge graphs
 
 EyeProlog can sit behind an RDF knowledge graph without inventing a private graph representation. [`rdf-prolog-roundtrip`](https://github.com/eyereasoner/rdf-prolog-roundtrip) converts RDF 1.2 datasets to ordinary `rdf(Subject, Predicate, Object, Graph)` facts, EyeProlog applies portable rules, and ground `rdf/4` results can be converted back to RDF.
@@ -95,5 +95,5 @@ cd eyeprolog
 npm install
 npm test
 ```
-
+`npm test` is the release gate and fetches the latest seven Neumerkel conformity sources before the local gates; use `npm run test:offline` for a network-free pass, `npm run test:conformance` for all conformance layers, `npm run test:neumerkel` for live upstream only, and `npm run test:neumerkel:cached` only to reproduce the last fetch. Upstream counts are discovered dynamically and verified against the tracked [latest Neumerkel report](test/conformance/NEUMERKEL-LATEST.md). Exact bytes/hashes stay under Git-ignored `.cache/neumerkel/`; refresh the tracked report with `npm run conformance:update:neumerkel` when upstream changes. Benchmarks remain `npm run benchmark` and `npm run benchmark:lips`.
 EyeProlog is released under the [MIT License](LICENSE.md).

package/conformance-report.md

@@ -4,6 +4,12 @@ This report combines an executable external conformance gate with the file-based
 conformance corpus under `test/conformance/`. The executable result is measured
 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).
+The live release gate fetches all seven TU Wien sources again and verifies that tracked
+report still matches the discovered upstream inventory.
+
 ## Executable conformance status
 
 | Gate | Passed | Total | Status |

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.32",
+  "version": "1.5.33",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,31 +46,32 @@
   },
   "scripts": {
     "test": "node test/run-all.mjs",
-    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
-    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
-    "test:eyeprolog": "node test/run-all.mjs",
-    "test:conformance": "node test/run-conformance.mjs",
-    "test:iso-strict": "node test/run-iso-strict.mjs",
-    "test:interop": "node test/run-interop.mjs",
-    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:offline": "node test/run-all.mjs --offline",
+    "test:conformance": "node test/run-conformance-all.mjs",
+    "test:conformance:offline": "node test/run-conformance-all.mjs --offline",
+    "test:neumerkel": "node test/run-neumerkel.mjs",
+    "test:neumerkel:cached": "node test/run-neumerkel.mjs --cached --no-verify-report",
+    "test:neumerkel:harness": "node test/run-neumerkel-tests.mjs",
+    "test:iso": "node test/run-iso-strict.mjs",
     "test:wg17": "node test/run-wg17.mjs",
-    "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
-    "test:regression:api": "node test/run-regression.mjs api",
-    "test:regression:core": "node test/run-regression.mjs regression",
-    "test:regression:docs": "node test/run-regression.mjs docs",
-    "test:regression:white-box": "node test/run-regression.mjs white-box",
+    "test:examples": "node test/run-examples.mjs",
+    "test:interop": "node test/run-interop.mjs",
     "test:playground": "node test/run-playground.mjs",
-    "wg17:upgrade": "node tools/upgrade-wg17.mjs",
-    "report:wg17": "node tools/report-wg17-syntax-coverage.mjs",
-    "report:wg17-syntax": "node tools/report-wg17-syntax-coverage.mjs",
-    "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
-    "postversion": "git push origin HEAD --follow-tags",
     "test:architecture": "node test/run-architecture.mjs",
+    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:benchmark": "node test/run-benchmark-tests.mjs",
     "benchmark": "node test/benchmark.mjs",
+    "benchmark:lips": "node test/lips-benchmark.mjs",
     "benchmark:baseline": "node test/benchmark.mjs --save .benchmarks/baseline.json",
-    "test:benchmark": "node test/run-benchmark-tests.mjs",
+    "conformance:update": "npm run conformance:update:wg17 && npm run conformance:update:neumerkel",
+    "conformance:report": "node test/run-conformance-report.mjs conformance-report.md",
+    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
+    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
     "generate:reference": "node tools/generate-predicate-reference.mjs",
-    "benchmark:lips": "node test/lips-benchmark.mjs"
+    "preversion": "npm test && npm run conformance:report",
+    "postversion": "git push origin HEAD --follow-tags",
+    "conformance:update:wg17": "node tools/upgrade-wg17.mjs",
+    "conformance:update:neumerkel": "node test/run-neumerkel.mjs --update-report"
   }
 }

package/test/conformance/ISO-COMPLIANCE.md

@@ -270,17 +270,30 @@ requirement of ISO/IEC 13211-2:2000 or ISO/IEC TS 13211-3.
 
 ## Release gate
 
-A release intended to advance ISO conformance must pass all of:
+A release intended to advance ISO conformance uses one canonical command:
 
 ```sh
 npm test
-npm run test:iso-strict
+```
+
+That command first fetches and runs the **latest seven Neumerkel conformity
+sources**, then executes the deterministic local conformance, strict ISO,
+vendored WG17 regression, regression/API, examples, documentation and
+architecture gates. The upstream case counts are discovered dynamically.
+
+Useful focused commands are:
+
+```sh
 npm run test:conformance
+npm run test:neumerkel
+npm run test:iso
 npm run test:wg17
+npm run test:offline
 ```
 
-The unified `npm test` gate includes the strict-core suite. Expected conformance
-outputs are never auto-accepted.
+`test:offline` is a development/reproduction aid; it is not sufficient for a
+release claim that says EyeProlog passes the latest Neumerkel suites. Expected
+conformance outputs are never auto-accepted.
 
 ## Exit criteria for a full conformance claim
 
@@ -300,7 +313,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 |
-| Externally sourced syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations; this is external review evidence, not certification |
+| 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 |
 | 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 `audit` rows; documented variation points are implementation-defined/specific or draft-only rather than unexplained deviations. |
 

package/test/conformance/NEUMERKEL-LATEST.md

@@ -0,0 +1,34 @@
+# EyeProlog — latest Neumerkel conformity
+
+Status: **PASS** — **665/665** 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 verifies that these discovered counts
+still match the live suites. Counts are output from upstream, not hard-coded test constants.
+
+| Suite | Passed | Total |
+|---|---:|---:|
+| syntax | 366 | 366 |
+| number_chars/2 | 78 | 78 |
+| variable_names/1 | 75 | 75 |
+| dif/2 | 26 | 26 |
+| length/2 | 37 | 37 |
+| phrase/2,3 | 58 | 58 |
+| setup_call_cleanup/3 | 25 | 25 |
+| **Total** | **665** | **665** |
+
+## Upstream sources
+
+- [syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)
+- [number_chars](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/number_chars_cont_quad.pl)
+- [variable_names](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/variable_names_quad.pl)
+- [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)
+- [cleanup](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/cleanup)
+
+Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under
+Git-ignored `.cache/neumerkel/` for local audit/reproduction and are intentionally not committed.
+Refresh this tracked report with `npm run conformance:update:neumerkel` and commit it whenever
+the live upstream inventory changes.
+

package/test/conformance/NEUMERKEL-LIVE.md

@@ -0,0 +1,63 @@
+# Live Neumerkel conformity gate
+
+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.
+
+`npm run test:neumerkel` fetches these seven 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;
+3. `variable_names_quad.pl` — `variable_names/1` corpus;
+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.
+
+The runner discovers the inventory at run time. A new upstream row is therefore
+executed automatically and a removed row disappears automatically.
+
+## Tracked GitHub evidence
+
+The latest successful discovered inventory is committed as
+[`NEUMERKEL-LATEST.md`](NEUMERKEL-LATEST.md). This is the stable report to link
+from GitHub, releases, or other documentation.
+
+A normal live run verifies that the tracked Markdown still matches the current
+upstream suite counts. If the upstream inventory changed, the gate fails with an
+instruction to refresh it:
+
+```sh
+npm run conformance:update:neumerkel
+```
+
+Commit the resulting `test/conformance/NEUMERKEL-LATEST.md` after reviewing the
+change. The tracked report intentionally omits fetch timestamps and HTTP
+validators, so repeated runs against unchanged upstream suites do not dirty the
+checkout.
+
+## Local audit cache
+
+Exact downloaded bytes, SHA-256 hashes, fetch timestamps, HTTP validators, and
+machine-readable results are kept under `.cache/neumerkel/`. `.cache/` remains
+Git-ignored: it is an audit/reproduction cache, not published project evidence.
+
+Use:
+
+```sh
+npm run test:neumerkel
+```
+
+for the canonical live check. For offline reproduction of the exact last live
+fetch, use:
+
+```sh
+npm run test:neumerkel:cached
+```
+
+The cached command never claims to check the latest upstream suites and is not
+used by the release gate.
+
+The vendored WG17 syntax matrix remains useful as a deterministic reviewed
+regression snapshot, but it is secondary to this live gate: passing the snapshot
+cannot mask a new or changed Neumerkel case.

package/test/conformance/README.md

@@ -69,68 +69,55 @@ Case names may be nested in category directories such as `arithmetic/`, `strings
 
 ## Running the suite
 
-Run all tests, including conformance, regression, documentation sync, API,
-examples, and book examples:
+The release gate is network-aware by design: it checks the current upstream
+Neumerkel conformity material before the deterministic local corpus.
 
 ```sh
 npm test
 ```
 
-Run only the conformance suite:
+For an offline-only development pass:
 
 ```sh
-node test/run-conformance.mjs
+npm run test:offline
 ```
 
-Run the Part 1 + Corrigenda strict-core processor gate:
+The conformance commands are:
 
 ```sh
-npm run test:iso-strict
+npm run test:conformance          # live Neumerkel + local ISO/conformance layers
+npm run test:conformance:offline  # same local layers, no network
+npm run test:neumerkel            # the seven live upstream suites only
+npm run test:neumerkel:cached     # exact last fetched bytes; reproduction only
+npm run test:iso                  # Part 1 + Corrigenda strict-core processor gate
+npm run test:wg17                 # vendored reviewed WG17 syntax regression
 ```
 
-Run the vendored WG17 conformity matrix independently:
+`test:neumerkel` always fetches the current TU Wien sources. It does not skip a
+fetch because a cache exists. The runner discovers the number of active tests from those sources and fails on any newly introduced case EyeProlog does not pass. It verifies the stable, tracked [NEUMERKEL-LATEST.md](NEUMERKEL-LATEST.md), which is the GitHub-facing result to cite. Exact bytes, SHA-256 hashes, timestamps, and HTTP validators stay under Git-ignored `.cache/neumerkel/` for audit/reproduction only. Refresh the tracked report with `npm run conformance:update:neumerkel` when the live inventory changes. See [NEUMERKEL-LIVE.md](NEUMERKEL-LIVE.md).
 
-```sh
-npm run test:wg17
-```
-
-Refresh the WG17 snapshot from the TU Wien conformity tables before a release
-or whenever upstream changes:
+The vendored WG17 syntax snapshot is intentionally secondary. Update all upstream conformance evidence with `npm run conformance:update`, or use the focused commands:
 
 ```sh
-npm run wg17:upgrade
+npm run conformance:update:wg17
+npm run conformance:update:neumerkel
 npm run test:wg17
 ```
 
-`wg17:upgrade` reconciles the upstream inventory by identifier: unchanged cases
-may keep their reviewed exact outcomes as an additional regression lock,
-removed cases disappear, and new or semantically changed cases initially have
-no local snapshot. **Every case is always checked independently against the
-upstream Codex expectation**, so a reviewed EyeProlog outcome can never make a
-non-conforming result pass (the failure mode that previously hid WG17 #227).
-The runner follows the upstream `read(G), G` input protocol, including the
-terminating newline, so stream-sensitive cases such as #270 and #271 exercise
-the characters left after `read/1`. Normal `npm test` remains offline and uses
-only the committed upstream snapshot.
+Every vendored syntax case is still checked against its upstream Codex
+expectation; reviewed exact outcomes are an additional regression lock rather
+than an alternative acceptance rule.
 
-Regenerate the public conformance report, including the executable WG17 syntax status and the file-based category inventory:
+Regenerate the top-level local-corpus report with `npm run conformance:report`. It links to [NEUMERKEL-LATEST.md](NEUMERKEL-LATEST.md) rather than duplicating live evidence. Counts in the tracked Neumerkel report are generated evidence, not permanent constants in project policy.
 
-```sh
-node test/run-conformance-report.mjs
-node test/run-conformance-report.mjs conformance-report.md
-```
-
-Run matching conformance cases by passing a filename or directory fragment:
+Run a matching local file-based conformance subset directly with:
 
 ```sh
 node test/run-conformance.mjs reusable
-node test/run-conformance.mjs 092_scalar_string_conversions
 node test/run-conformance.mjs variables/
 node test/run-conformance.mjs error/variables
 ```
 
-The runner executes normal programs with queries in-process through the public JavaScript API so small conformance cases avoid measuring Node startup overhead. Warning and proof cases intentionally use the CLI because warning output and `why/2` proof output are host-interface contracts.
-
 ## Scope
 
 The corpus covers accepted syntax, typed scalar identity and explicit scalar conversions, query answers,
@@ -147,12 +134,7 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 386 cases in `iso/` and 802 file-based conformance cases in
-total. Of those, 11 cases in `stc/` are explicitly labelled working-draft
-review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
-The generated `conformance-report.md` is the authoritative source for the current
-executable WG17 syntax result and file-based category totals. Together with regression, documentation-sync, API, example,
-and book-example checks, `npm test` is the release gate.
+The corpus has 386 cases in `iso/` and 802 file-based conformance cases in total. Of those, 11 cases in `stc/` are explicitly labelled working-draft review evidence rather than normative ISO claims. The separate vendored strict-reader WG17 matrix is a deterministic regression snapshot; the live Neumerkel gate discovers the current upstream inventory at run time and verifies the tracked `NEUMERKEL-LATEST.md`. The generated `conformance-report.md` records local corpus totals and links to that live evidence. Together with regression, documentation-sync, API, example, and book-example checks, `npm test` is the release gate.
 
 ## Updating expected output
 

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -46,6 +46,6 @@ None.
 
 ## Maintenance
 
-1. Run `npm run wg17:upgrade` to reconcile the dated fixture with upstream.
+1. Run `npm run conformance:update` to reconcile the dated fixture with upstream.
 2. Review every new or changed ISO expectation before adding its expected outcome.
 3. Run `npm run test:wg17` and keep this generated status page synchronized.

package/test/neumerkel.mjs

@@ -0,0 +1,470 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+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 {
+  countTopLevelTerms,
+  decodeDocument,
+  htmlCellText,
+  parseWg17SyntaxTable,
+  setupInput,
+} from '../tools/upgrade-wg17.mjs';
+import {
+  executeWg17Item,
+  matchesUpstreamExpectation,
+  wg17TestDescription,
+} from './run-wg17.mjs';
+
+const testRoot = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(testRoot, '..');
+const defaultCacheDir = path.join(packageRoot, '.cache', 'neumerkel');
+export const NEUMERKEL_REPORT_PATH = path.join(packageRoot, 'test', 'conformance', 'NEUMERKEL-LATEST.md');
+const baseUrl = 'https://www.complang.tuwien.ac.at/ulrich/iso-prolog/';
+
+export const NEUMERKEL_SOURCES = Object.freeze([
+  { key: 'syntax', filename: 'conformity_testing.html', url: `${baseUrl}conformity_testing`, kind: 'syntax' },
+  { key: 'number_chars', filename: 'number_chars_cont_quad.pl', url: `${baseUrl}number_chars_cont_quad.pl`, kind: 'quad' },
+  { key: 'variable_names', filename: 'variable_names_quad.pl', url: `${baseUrl}variable_names_quad.pl`, kind: 'quad' },
+  { 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: 'cleanup', filename: 'cleanup.html', url: `${baseUrl}cleanup`, kind: 'cleanup' },
+]);
+
+function sha256(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+function safeMkdir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function sourceRevision(text) {
+  const normalized = htmlCellText(text);
+  const matches = [...normalized.matchAll(/\b(?:revision|version)\s+([0-9]+(?:\.[0-9]+)*)/gi)];
+  return matches.at(-1)?.[1] ?? null;
+}
+
+async function fetchOne(source) {
+  let response;
+  try {
+    response = await fetch(source.url, {
+      headers: { 'user-agent': 'EyeProlog-Neumerkel-Conformance/1' },
+      redirect: 'follow',
+      cache: 'no-store',
+    });
+  } catch (error) {
+    throw new Error(
+      `Neumerkel live fetch failed for ${source.key} (${source.url}). ` +
+      'The canonical conformance gate requires network access; use npm run test:offline ' +
+      'for a network-free local run or npm run test:neumerkel:cached to reproduce the last live fetch.',
+      { cause: error },
+    );
+  }
+  if (!response.ok) {
+    throw new Error(`Neumerkel fetch failed for ${source.key} (${source.url}): ${response.status} ${response.statusText}`);
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  const contentType = response.headers.get('content-type') ?? '';
+  return {
+    bytes,
+    text: decodeDocument(bytes, contentType),
+    metadata: {
+      key: source.key,
+      url: source.url,
+      filename: source.filename,
+      sha256: sha256(bytes),
+      bytes: bytes.byteLength,
+      etag: response.headers.get('etag'),
+      lastModified: response.headers.get('last-modified'),
+      contentType,
+    },
+  };
+}
+
+function readCachedOne(source, cacheDir) {
+  const filename = path.join(cacheDir, source.filename);
+  if (!fs.existsSync(filename)) {
+    throw new Error(`Neumerkel cache is incomplete: missing ${path.relative(packageRoot, filename)}; run npm run test:neumerkel online first`);
+  }
+  const bytes = new Uint8Array(fs.readFileSync(filename));
+  return {
+    bytes,
+    text: decodeDocument(bytes, ''),
+    metadata: {
+      key: source.key,
+      url: source.url,
+      filename: source.filename,
+      sha256: sha256(bytes),
+      bytes: bytes.byteLength,
+      cached: true,
+    },
+  };
+}
+
+function readSourceDirOne(source, sourceDir) {
+  const filename = path.join(sourceDir, source.filename);
+  if (!fs.existsSync(filename)) throw new Error(`missing Neumerkel source fixture: ${filename}`);
+  const bytes = new Uint8Array(fs.readFileSync(filename));
+  return {
+    bytes,
+    text: decodeDocument(bytes, ''),
+    metadata: {
+      key: source.key,
+      url: source.url,
+      filename: source.filename,
+      sha256: sha256(bytes),
+      bytes: bytes.byteLength,
+      sourceDir: true,
+    },
+  };
+}
+
+export async function loadNeumerkelSources({ mode = 'live', cacheDir = defaultCacheDir, sourceDir = null } = {}) {
+  const loaded = new Map();
+  for (const source of NEUMERKEL_SOURCES) {
+    const item = sourceDir != null
+      ? readSourceDirOne(source, sourceDir)
+      : mode === 'cached'
+        ? readCachedOne(source, cacheDir)
+        : await fetchOne(source);
+    loaded.set(source.key, { ...source, ...item, localPath: sourceDir != null ? path.join(sourceDir, source.filename) : path.join(cacheDir, source.filename) });
+  }
+
+  if (mode === 'live' && sourceDir == null) {
+    safeMkdir(cacheDir);
+    for (const item of loaded.values()) fs.writeFileSync(path.join(cacheDir, item.filename), item.bytes);
+    const fetchedAt = new Date().toISOString();
+    const manifest = {
+      schema: 1,
+      policy: 'live Neumerkel sources fetched for this conformance run; cached copies are reproducibility aids only',
+      fetchedAt,
+      sources: [...loaded.values()].map((item) => ({
+        ...item.metadata,
+        revision: item.kind === 'syntax' || item.kind === 'cleanup' ? sourceRevision(item.text) : null,
+      })),
+    };
+    fs.writeFileSync(path.join(cacheDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+  }
+
+  return loaded;
+}
+
+export function materializeSyntaxCases(html) {
+  const rows = parseWg17SyntaxTable(html);
+  let precedingBaseQuery = null;
+  return rows.map((row) => {
+    const input = setupInput(row.query, precedingBaseQuery);
+    const item = {
+      id: row.id,
+      query: row.query,
+      input,
+      readCount: countTopLevelTerms(input),
+      expected: row.expected,
+      assertion: 'upstream-live',
+    };
+    if (!row.query.includes('/**/')) precedingBaseQuery = row.query;
+    return item;
+  });
+}
+
+function htmlTableRows(html) {
+  const rowStarts = [...html.matchAll(/<tr\b[^>]*>/gi)];
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < rowStarts.length; rowIndex++) {
+    const rowStart = rowStarts[rowIndex];
+    const bodyStart = rowStart.index + rowStart[0].length;
+    const nextRow = rowStarts[rowIndex + 1]?.index ?? html.length;
+    const explicitEnd = html.slice(bodyStart, nextRow).search(/<\/tr\s*>/i);
+    const rowEnd = explicitEnd < 0 ? nextRow : bodyStart + explicitEnd;
+    const body = html.slice(bodyStart, rowEnd);
+    const cellStarts = [...body.matchAll(/<t[dh]\b[^>]*>/gi)];
+    const cells = [];
+    for (let cellIndex = 0; cellIndex < cellStarts.length; cellIndex++) {
+      const cellStart = cellStarts[cellIndex];
+      const cellBodyStart = cellStart.index + cellStart[0].length;
+      const cellEnd = cellStarts[cellIndex + 1]?.index ?? body.length;
+      cells.push(body.slice(cellBodyStart, cellEnd));
+    }
+    rows.push(cells);
+  }
+  return rows;
+}
+
+function stripPromptAndDot(query) {
+  return String(query)
+    .replace(/^\s*\?-\s*/, '')
+    .trim()
+    .replace(/\.\s*$/, '')
+    .trim();
+}
+
+function classifyDifExpected(text) {
+  const expected = String(text).replace(/\s+/g, ' ').trim();
+  if (expected.length === 0) return null;
+  if (expected.includes('|')) return 'lenient';
+  if (/^(?:false|fails?)\b/i.test(expected)) return 'fails';
+  if (/^(?:true|succeeds?)\b/i.test(expected)) return 'succeeds';
+  if (expected.includes('=')) return 'succeeds';
+  return 'lenient';
+}
+
+export function parseDifCases(html) {
+  const result = [];
+  const seen = new Set();
+  for (const cells of htmlTableRows(html)) {
+    if (cells.length < 3) continue;
+    const idText = htmlCellText(cells[0]).replace(/^#\s*/, '').trim();
+    if (!/^\d+$/.test(idText)) continue;
+    const id = Number(idText);
+    if (seen.has(id)) continue;
+    const query = stripPromptAndDot(htmlCellText(cells[1]));
+    const expectedText = htmlCellText(cells[2]);
+    const expected = classifyDifExpected(expectedText);
+    if (!query || expected == null) continue;
+    result.push({ id, query, expected, expectedText });
+    seen.add(id);
+  }
+  if (result.length === 0) throw new Error('no Neumerkel dif/2 cases found; upstream HTML format may have changed');
+  return result;
+}
+
+function htmlToText(html) {
+  return html
+    .replace(/<!--[^]*?-->/g, '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/(?:p|div|pre|li|blockquote|h[1-6]|table|tr)>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;|&apos;/gi, "'")
+    .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
+    .replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16)))
+    .replace(/\r\n?/g, '\n');
+}
+
+function classifyCleanupDescription(text) {
+  const first = String(text).trim();
+  if (/^Fails\b/i.test(first)) return 'fails';
+  if (/^Instantiation error\b/i.test(first)) return 'instantiation_error';
+  if (/^Type error\b/i.test(first)) return 'type_error';
+  if (/^System error\b/i.test(first)) return 'error';
+  if (/^Succeeds\b/i.test(first)) return 'succeeds';
+  return 'lenient';
+}
+
+export function parseCleanupCases(html) {
+  const lines = htmlToText(html).split('\n');
+  const cases = [];
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index].trimEnd();
+    const trimmed = line.trim();
+    if (!trimmed.includes('setup_call_cleanup') || !trimmed.endsWith('.')) continue;
+    // Match the reference extraction protocol: only complete one-line example
+    // goals are executable. Multi-line prose examples remain specification
+    // evidence but are not silently reassembled by the harness.
+    if (/^setup_call_cleanup\b/.test(trimmed) === false && /^catch\(.*setup_call_cleanup/.test(trimmed) === false) continue;
+    const goal = trimmed.slice(0, -1).trim();
+    if (/\bopen\s*\(/.test(goal)) continue;
+
+    let description = '';
+    for (let next = index + 1; next < lines.length; next++) {
+      const candidate = lines[next];
+      if (candidate.trim() === '') continue;
+      description = candidate.trim();
+      break;
+    }
+    if (!description) continue;
+    cases.push({ id: cases.length + 1, goal, expected: classifyCleanupDescription(description), description });
+  }
+  if (cases.length === 0) throw new Error('no Neumerkel setup_call_cleanup/3 examples found; upstream HTML format may have changed');
+  return cases;
+}
+
+function executeGoal(goal) {
+  try {
+    const result = run('', { goal: `once((${goal}))` });
+    return result.stats.completed_goal_lists > 0 ? { type: 'succeeds' } : { type: 'fails' };
+  } catch (error) {
+    const formal = String(error?.formal ?? error?.message ?? error);
+    if (/instantiation_error/.test(formal)) return { type: 'instantiation_error', formal };
+    if (/type_error/.test(formal)) return { type: 'type_error', formal };
+    return { type: 'error', formal };
+  }
+}
+
+function expectedMatches(expected, actual) {
+  if (expected === 'lenient') return true;
+  if (expected === 'error') return ['error', 'instantiation_error', 'type_error'].includes(actual.type);
+  return expected === actual.type;
+}
+
+function ensureQuadSuccess(label, item) {
+  const cli = path.join(packageRoot, 'bin', 'eyeprolog.js');
+  const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-neumerkel-'));
+  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 });
+    if (child.status !== 0) {
+      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);
+    if (failed !== 0 || undecided !== 0 || passed !== total) {
+      throw new Error(`${label}: ${passed}/${total} passed, ${failed} failed, ${undecided} undecided\n${child.stdout}${child.stderr}`);
+    }
+    return { total, passed, failed, undecided, stdout: child.stdout };
+  } finally {
+    fs.rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+export async function executeNeumerkel({ reporter, mode = 'live', cacheDir = defaultCacheDir, sourceDir = null } = {}) {
+  const sources = await loadNeumerkelSources({ mode, cacheDir, sourceDir });
+  const summary = {};
+
+  reporter.section(`Neumerkel conformity (${mode === 'live' && sourceDir == null ? 'live upstream' : sourceDir != null ? 'source fixtures' : 'cached'})`);
+
+  const syntaxCases = materializeSyntaxCases(sources.get('syntax').text);
+  for (const item of syntaxCases) {
+    reporter.test(`syntax ${wg17TestDescription(item)}`, () => {
+      const actual = executeWg17Item(item);
+      if (!matchesUpstreamExpectation(item.expected, actual, item)) {
+        throw new Error(`syntax #${item.id} expected ${item.expected}; actual ${JSON.stringify(actual)}`);
+      }
+    });
+  }
+  summary.syntax = { passed: syntaxCases.length, total: syntaxCases.length };
+
+  for (const key of ['number_chars', 'variable_names', 'length', 'phrase']) {
+    let result;
+    reporter.test(`${key.replace('_', ' ')} live corpus`, () => {
+      result = ensureQuadSuccess(key, sources.get(key));
+    });
+    summary[key] = { passed: result.total, total: result.total };
+  }
+
+  const difCases = parseDifCases(sources.get('dif').text);
+  for (const item of difCases) {
+    reporter.test(`dif #${item.id} ${item.query}`, () => {
+      const actual = executeGoal(item.query);
+      if (!expectedMatches(item.expected, actual)) {
+        throw new Error(`dif #${item.id} expected ${item.expected} (${item.expectedText}); actual ${JSON.stringify(actual)}`);
+      }
+    });
+  }
+  summary.dif = { passed: difCases.length, total: difCases.length };
+
+  const cleanupCases = parseCleanupCases(sources.get('cleanup').text);
+  for (const item of cleanupCases) {
+    reporter.test(`cleanup #${item.id} ${item.goal}`, () => {
+      const actual = executeGoal(item.goal);
+      if (!expectedMatches(item.expected, actual)) {
+        throw new Error(`cleanup #${item.id} expected ${item.expected} (${item.description}); actual ${JSON.stringify(actual)}`);
+      }
+    });
+  }
+  summary.cleanup = { passed: cleanupCases.length, total: cleanupCases.length };
+
+  reporter.sectionTotal('live Neumerkel conformity');
+
+  const cacheManifest = path.join(cacheDir, 'manifest.json');
+  const cachedManifest = fs.existsSync(cacheManifest) ? JSON.parse(fs.readFileSync(cacheManifest, 'utf8')) : null;
+  const manifest = sourceDir != null
+    ? {
+        schema: 1,
+        policy: 'local source fixtures used for this conformance run',
+        fetchedAt: null,
+        sources: [...sources.values()].map((item) => ({
+          ...item.metadata,
+          revision: item.kind === 'syntax' || item.kind === 'cleanup' ? sourceRevision(item.text) : null,
+        })),
+      }
+    : cachedManifest;
+  if (mode === 'live' && sourceDir == null && manifest != null) {
+    fs.writeFileSync(path.join(cacheDir, 'results.json'), `${JSON.stringify({
+      schema: 1,
+      fetchedAt: manifest.fetchedAt,
+      summary,
+      sourceSha256: Object.fromEntries(manifest.sources.map((source) => [source.key, source.sha256])),
+    }, null, 2)}\n`);
+  }
+
+  const reportText = formatNeumerkelMarkdown({ summary, manifest });
+  return { summary, manifest, cacheDir, reportPath: NEUMERKEL_REPORT_PATH, reportText };
+}
+
+export function formatNeumerkelSummary(summary) {
+  const labels = [
+    ['syntax', 'syntax'],
+    ['number_chars', 'number_chars/2'],
+    ['variable_names', 'variable_names/1'],
+    ['dif', 'dif/2'],
+    ['length', 'length/2'],
+    ['phrase', 'phrase/2,3'],
+    ['cleanup', 'setup_call_cleanup/3'],
+  ];
+  return labels.map(([key, label]) => {
+    const row = summary[key];
+    return `${label.padEnd(22)} ${row.passed}/${row.total}`;
+  }).join('\n');
+}
+
+export function formatNeumerkelMarkdown({ summary }) {
+  const labels = [
+    ['syntax', 'syntax'],
+    ['number_chars', 'number_chars/2'],
+    ['variable_names', 'variable_names/1'],
+    ['dif', 'dif/2'],
+    ['length', 'length/2'],
+    ['phrase', 'phrase/2,3'],
+    ['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 lines = [
+    '# EyeProlog — latest Neumerkel conformity',
+    '',
+    `Status: **${passed === total ? 'PASS' : 'FAIL'}** — **${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 verifies that these discovered counts',
+    'still match the live suites. Counts are output from upstream, not hard-coded test constants.',
+    '',
+    '| Suite | Passed | Total |',
+    '|---|---:|---:|',
+  ];
+  for (const row of rows) lines.push(`| ${row.label} | ${row.passed} | ${row.total} |`);
+  lines.push(`| **Total** | **${passed}** | **${total}** |`);
+
+  lines.push(
+    '',
+    '## Upstream sources',
+    '',
+  );
+  for (const source of NEUMERKEL_SOURCES) lines.push(`- [${source.key}](${source.url})`);
+
+  lines.push(
+    '',
+    'Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under',
+    'Git-ignored `.cache/neumerkel/` for local audit/reproduction and are intentionally not committed.',
+    'Refresh this tracked report with `npm run conformance:update:neumerkel` and commit it whenever',
+    'the live upstream inventory changes.',
+    '',
+  );
+  return `${lines.join('\n')}\n`;
+}
+
+

package/test/run-all.mjs

@@ -13,8 +13,14 @@ import { runWg17 } from './run-wg17.mjs';
 import { runOpenRuleBenchChecks } from './run-openrulebench.mjs';
 import { runArchitecture } from './run-architecture.mjs';
 import { runCleanup } from './run-cleanup.mjs';
+import { runNeumerkel } from './run-neumerkel.mjs';
+import { runNeumerkelHarnessTests } from './run-neumerkel-tests.mjs';
+
+const offline = process.argv.includes('--offline');
 
 await runStandalone(async (reporter) => {
+  runNeumerkelHarnessTests(reporter);
+  if (!offline) await runNeumerkel(reporter);
   runConformance(reporter);
   runIsoStrict(reporter);
   runWg17(reporter);

package/test/run-conformance-all.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { runStandalone } from './test-style.mjs';
+import { runNeumerkel } from './run-neumerkel.mjs';
+import { runConformance } from './run-conformance.mjs';
+import { runIsoStrict } from './run-iso-strict.mjs';
+import { runWg17 } from './run-wg17.mjs';
+
+const offline = process.argv.includes('--offline');
+
+await runStandalone(async (reporter) => {
+  if (!offline) await runNeumerkel(reporter);
+  runConformance(reporter);
+  runIsoStrict(reporter);
+  runWg17(reporter);
+});

package/test/run-conformance-report.mjs

@@ -78,11 +78,23 @@ export function formatConformanceReport(report = buildConformanceReport()) {
     'conformance corpus under `test/conformance/`. The executable result is measured',
     'when this report is generated; it is not inferred from fixture counts.',
     '',
+  ];
+
+  lines.push(
+    '## Latest Neumerkel evidence',
+    '',
+    'See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).',
+    'The live release gate fetches all seven TU Wien sources again and verifies that tracked',
+    'report still matches the discovered upstream inventory.',
+    '',
+  );
+
+  lines.push(
     '## Executable conformance status',
     '',
     '| Gate | Passed | Total | Status |',
     '|---|---:|---:|---|',
-  ];
+  );
 
   for (const gate of report.executable) {
     const status = gate.passed === gate.total ? 'pass' : 'fail';

package/test/run-conformance.mjs

@@ -11,7 +11,7 @@ import { goalsFromSource } from './goal-metadata.mjs';
 import { listPrologFiles, withStandardModules } from './test-support.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
-const filterArg = process.argv[2] ?? null;
+const filterArg = process.argv[2]?.startsWith('--') ? null : process.argv[2] ?? null;
 
 export function runConformance(reporter = new TestReporter(), requestedFilter = null) {
   const filter = requestedFilter ?? filterArg;

package/test/run-neumerkel-tests.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { NEUMERKEL_SOURCES, formatNeumerkelMarkdown, materializeSyntaxCases, parseCleanupCases, parseDifCases } from './neumerkel.mjs';
+import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
+
+function syntaxHtml(count = 101) {
+  const rows = [];
+  for (let id = 1; id <= count; id++) {
+    const query = id === 2 ? '/**/ writeq(a).' : id === 1 ? 'op(9,fy,x).' : 'true.';
+    const expected = id === 2 ? 'a' : 'succeeds';
+    rows.push(`<tr><td>${id}<td>${query}<td>${expected}`);
+  }
+  return `<table>${rows.join('')}</table>`;
+}
+
+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}`);
+    const keys = new Set(NEUMERKEL_SOURCES.map(({ key }) => key));
+    if (keys.size !== 7) throw new Error('Neumerkel source keys are not unique');
+  });
+
+  reporter.test('syntax inventory is discovered dynamically and reconstructs /**/ setup', () => {
+    const cases = materializeSyntaxCases(syntaxHtml());
+    if (cases.length !== 101) throw new Error(`expected 101 cases, got ${cases.length}`);
+    if (!cases[1].input.includes('op(9,fy,x)')) throw new Error('/**/ setup was not reconstructed');
+  });
+
+  reporter.test('dif table discovery uses upstream row ids and answer descriptions', () => {
+    const cases = parseDifCases('<table><tr><td>1<td>?- dif(1,2).<td>true<tr><td>2<td>?- dif(X,X).<td>false</table>');
+    if (cases.length !== 2 || cases[0].expected !== 'succeeds' || cases[1].expected !== 'fails') {
+      throw new Error(`unexpected dif parse ${JSON.stringify(cases)}`);
+    }
+  });
+
+  reporter.test('tracked Markdown report records dynamic counts without volatile metadata', () => {
+    const summary = {
+      syntax: { passed: 366, total: 366 },
+      number_chars: { passed: 78, total: 78 },
+      variable_names: { passed: 75, total: 75 },
+      dif: { passed: 26, total: 26 },
+      length: { passed: 37, total: 37 },
+      phrase: { passed: 58, total: 58 },
+      cleanup: { passed: 25, total: 25 },
+    };
+    const text = formatNeumerkelMarkdown({
+      summary,
+      manifest: { fetchedAt: '2026-09-03T12:00:00.000Z', sources: [{ etag: '"volatile-tag"' }] },
+    });
+    if (!text.includes('**665/665**')) throw new Error('Markdown total is not derived from suite counts');
+    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')) {
+      throw new Error('tracked Markdown must exclude volatile fetch metadata');
+    }
+  });
+
+  reporter.test('cleanup discovery follows the reference one-line example protocol', () => {
+    const html = `<pre>
+setup_call_cleanup(fail,_,_).
+   Fails.
+setup_call_cleanup(open(f,read,S),true,close(S)).
+   Succeeds.
+catch(setup_call_cleanup(true,throw(x),true),E,true).
+   Succeeds.
+catch(
+  setup_call_cleanup(true,throw(x),true),
+  E,true).
+   Succeeds.
+</pre>`;
+    const cases = parseCleanupCases(html);
+    if (cases.length !== 2) throw new Error(`expected 2 executable one-line non-file cases, got ${cases.length}`);
+    if (cases[0].expected !== 'fails' || cases[1].expected !== 'succeeds') throw new Error('cleanup classification mismatch');
+  });
+
+  reporter.sectionTotal('Neumerkel harness');
+}
+
+if (isMainModule(import.meta.url)) await runStandalone(runNeumerkelHarnessTests);

package/test/run-neumerkel.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+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';
+
+function parseArgs(argv) {
+  const options = {
+    mode: 'live',
+    sourceDir: process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR ?? null,
+    updateReport: false,
+    verifyReport: true,
+  };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === '--cached') options.mode = 'cached';
+    else if (arg === '--update-report') options.updateReport = true;
+    else if (arg === '--no-verify-report') options.verifyReport = false;
+    else if (arg === '--source-dir') {
+      if (argv[index + 1] == null) throw new Error('--source-dir requires a directory');
+      options.sourceDir = path.resolve(argv[++index]);
+    } else if (arg === '--help' || arg === '-h') options.help = true;
+    else throw new Error(`unknown option ${arg}`);
+  }
+  return options;
+}
+
+function printHelp() {
+  process.stdout.write(
+    'Usage: npm run test:neumerkel -- [--cached] [--source-dir DIR] [--update-report] [--no-verify-report]\n\n' +
+    'Default: fetch all seven current Neumerkel conformity sources live, run the\n' +
+    'discovered cases, and verify test/conformance/NEUMERKEL-LATEST.md matches\n' +
+    'the successful upstream result. --update-report refreshes that tracked file.\n' +
+    '--cached is for offline reproduction only; it is never the release gate.\n',
+  );
+}
+
+export async function runNeumerkel(reporter, options = {}) {
+  const effective = { verifyReport: true, updateReport: false, ...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 relativeReportPath = path.relative(process.cwd(), result.reportPath);
+
+  if (effective.updateReport) {
+    fs.mkdirSync(path.dirname(result.reportPath), { recursive: true });
+    fs.writeFileSync(result.reportPath, result.reportText);
+    reporter.stdout.write(`Updated Neumerkel report: ${relativeReportPath}\n`);
+  } else if (effective.verifyReport !== false) {
+    const committed = fs.existsSync(result.reportPath) ? fs.readFileSync(result.reportPath, 'utf8') : null;
+    if (committed !== result.reportText) {
+      throw new Error(
+        `tracked Neumerkel report is stale: ${relativeReportPath}\n` +
+        'Run npm run conformance:update:neumerkel and commit the updated report.',
+      );
+    }
+    reporter.stdout.write(`Neumerkel report: ${relativeReportPath}\n`);
+  } else {
+    reporter.stdout.write(`Neumerkel report verification skipped (${relativeReportPath})\n`);
+  }
+  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;
+      }
+    },
+  };
+}
+
+if (isMainModule(import.meta.url)) {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) printHelp();
+  else await runStandalone((reporter) => runNeumerkel(reporter, options));
+}

package/test/run-regression.mjs

@@ -5363,7 +5363,7 @@ ${profile}`;
           '| Clause 7 semantic requirements have explicit dispositions | covered |',
           '| Clause 8 built-in modes/errors have explicit dispositions | covered |',
           '| Clause 9 evaluable-functor requirements have explicit dispositions | covered |',
-          '| Externally sourced syntax corpus is an offline release gate | covered |',
+          '| Latest Neumerkel conformity is a live release gate | covered |',
           '| No unexplained deviation remains in the release-facing ledger | covered |',
         ]) assertIncludes(exit, item, item);
         assertNotIncludes(exit, '| audit |', 'no release-facing audit rows remain');
@@ -5468,7 +5468,9 @@ ${profile}`;
       run: () => {
         const reportFile = path.join(packageRoot, 'conformance-report.md');
         assertEqual(fs.existsSync(reportFile), true, 'conformance-report.md exists');
-        assertEqual(fs.readFileSync(reportFile, 'utf8'), formatConformanceReport(buildConformanceReport()), 'conformance-report.md');
+        const actual = fs.readFileSync(reportFile, 'utf8');
+        const expected = formatConformanceReport(buildConformanceReport());
+        assertEqual(actual, expected, 'conformance-report.md');
       },
     },
     {
@@ -8557,7 +8559,10 @@ function documentedConformanceMetricIssues() {
       ...[...text.matchAll(/\b(\d+)-case[^\n|]*WG17/g)].map((match) => Number(match[1])),
       ...[...text.matchAll(/WG17[^\n|]*?\b(\d+) executable/g)].map((match) => Number(match[1])),
     ];
-    if (claims.length === 0) issues.push(`${relative}: WG17 total not found`);
+    if (claims.length === 0) {
+      const dynamicPolicy = /live Neumerkel|current upstream inventory|discovered dynamically/i.test(text);
+      if (!dynamicPolicy) issues.push(`${relative}: WG17 total or dynamic-upstream policy not found`);
+    }
     for (const claim of claims) {
       if (claim !== wg17) issues.push(`${relative}: WG17 count ${claim} != ${wg17}`);
     }

package/the-art-of-eyeprolog.md

@@ -10228,7 +10228,7 @@ syntax. Separate corpora cover expected errors, warnings, and proofs:
 
 ```sh
 npm run test:conformance
-npm run test:iso-strict
+npm run test:iso
 npm run test:wg17
 node test/run-conformance-report.mjs
 ```

package/tools/report-wg17-syntax-coverage.mjs

@@ -134,7 +134,7 @@ ${untracedIds.length === 0 ? 'None.' : `${formatRanges(untracedIds)}.`}
 
 ## Maintenance
 
-1. Run \`npm run wg17:upgrade\` to reconcile the dated fixture with upstream.
+1. Run \`npm run conformance:update\` to reconcile the dated fixture with upstream.
 2. Review every new or changed ISO expectation before adding its expected outcome.
 3. Run \`npm run test:wg17\` and keep this generated status page synchronized.
 `;
@@ -158,7 +158,7 @@ if (process.argv[1] != null && path.resolve(process.argv[1]) === fileURLToPath(i
   if (process.argv.includes('--check')) {
     const current = fs.readFileSync(statusPath, 'utf8');
     if (current !== rendered) {
-      process.stderr.write('WG17 syntax status is stale; run npm run report:wg17 and update the file.\n');
+      process.stderr.write('WG17 syntax status is stale; run npm run conformance:update and update the file.\n');
       process.exitCode = 1;
     }
   } else {

package/tools/upgrade-wg17.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Refresh the vendored WG17 conformity fixtures from their public upstream
-// tables. Normal test runs remain fully offline and deterministic.
+// tables. The vendored snapshot remains an offline deterministic regression layer; the release gate also runs live upstream suites.
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -381,7 +381,7 @@ function parseArgs(argv) {
 }
 
 function printHelp() {
-  process.stdout.write(`Usage: npm run wg17:upgrade -- [--check] [--source URL_OR_FILE]\n\n` +
+  process.stdout.write(`Usage: npm run conformance:update -- [--check] [--source URL_OR_FILE]\n\n` +
     `Refreshes the vendored WG17 conformity tests from the TU Wien table.\n` +
     `New or changed rows are executable immediately against the upstream\n` +
     `Codex expectation; existing reviewed exact outcomes remain pinned only as additional regression checks.\n`);
@@ -401,7 +401,7 @@ export async function upgradeWg17({ check = false, source = syntaxSource } = {})
 
   if (check) {
     if (semanticChanges > 0) {
-      process.stderr.write('WG17 snapshot is stale; run npm run wg17:upgrade.\n');
+      process.stderr.write('WG17 snapshot is stale; run npm run conformance:update.\n');
       process.exitCode = 1;
       return { changed: true, ...reconciliation };
     }