eyeprolog 1.5.33 → 1.5.35

package/README.md

@@ -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`.
+`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. A stale tracked [latest Neumerkel report](test/conformance/NEUMERKEL-LATEST.md) produces a warning during normal tests. `npm run conformance:update:neumerkel` refreshes it from live upstream; `npm run conformance:sync:neumerkel` refreshes it from the exact successful snapshot already fetched by `npm test`; and `npm run conformance:check:neumerkel` verifies that snapshot without a second live fetch. npm's version lifecycle uses the sync path and stages the generated reports into the release commit. Exact bytes/hashes stay under Git-ignored `.cache/neumerkel/`. Benchmarks remain `npm run benchmark` and `npm run benchmark:lips`.
 EyeProlog is released under the [MIT License](LICENSE.md).

package/conformance-report.md

@@ -7,8 +7,9 @@ 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.
+`npm test` fetches all seven 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.
 
 ## Executable conformance status
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.33",
+  "version": "1.5.35",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,7 +50,7 @@
     "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:cached": "node test/run-neumerkel.mjs --cached",
     "test:neumerkel:harness": "node test/run-neumerkel-tests.mjs",
     "test:iso": "node test/run-iso-strict.mjs",
     "test:wg17": "node test/run-wg17.mjs",
@@ -69,9 +69,11 @@
     "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",
-    "preversion": "npm test && npm run conformance:report",
+    "preversion": "npm test && npm run conformance:sync:neumerkel && npm run conformance:report && git add test/conformance/NEUMERKEL-LATEST.md conformance-report.md",
     "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"
+    "conformance:update:neumerkel": "node test/run-neumerkel.mjs --update-report",
+    "conformance:check:neumerkel": "node test/run-neumerkel.mjs --cached --verify-report",
+    "conformance:sync:neumerkel": "node test/run-neumerkel.mjs --cached --update-report"
   }
 }

package/src/parser.js

@@ -811,6 +811,17 @@ class Parser {
     let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
     const leftIsBareOperatorAtom = initialWasCurrentOperator &&
       left.type === ATOM && left.name === initialOperatorName;
+    // Neumerkel syntax #379: the DCG rule operator `-->` is processor-defined
+    // and not an ISO predicate-indicator name.  A bare `-->` (not parenthesized)
+    // followed by `/` would be an invalid strict-ISO predicate indicator.
+    // However, `(-->)/2` is valid: the parentheses make `-->` an ordinary atom
+    // argument, and ISO 7.10.3 does not restrict which atoms may appear as the
+    // name in a Name/Arity indicator — only the write-term rules govern spelling.
+    // Only reject the bare-operator form so (-->)/2 succeeds per #379.
+    if (this.strictIso && leftIsBareOperatorAtom && left.name === '-->' &&
+        this.operatorTokenName() === '/') {
+      throw new Error(`parse line ${this.token.line}: operator atom --> is not permitted in a strict ISO predicate indicator`);
+    }
     let strictPostfixPrecedence = null;
     while (true) {
       const op = this.token.type === TOK.COMMA && allowComma

package/src/program-analysis.js

@@ -8,7 +8,11 @@ import {
 
 export function componentHasNegativeEdge(start, deps, negativeEdges) {
   const forward = reachableIndexes(start, deps);
-  const component = new Set([...forward].filter((index) => reachableIndexes(index, deps).has(start)));
+  // A node is in the same SCC as `start` iff it can also reach `start`.
+  // Rather than calling reachableIndexes() per-node (O(n^2)), compute the
+  // reverse-reachability set from `start` over the transposed graph once.
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = new Set([...forward].filter((index) => backward.has(index)));
   return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
 }
 
@@ -27,7 +31,8 @@ export function clauseIsDirectRecursive(clause, group) {
 
 export function componentHasCut(start, deps, groups) {
   const forward = reachableIndexes(start, deps);
-  const component = [...forward].filter((index) => reachableIndexes(index, deps).has(start));
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = [...forward].filter((index) => backward.has(index));
   return component.some((index) => {
     const group = groups[index];
     const directRecursive = group.clauses.some((clause) => clauseIsDirectRecursive(clause, group));
@@ -50,6 +55,34 @@ export function reachableIndexes(start, deps) {
   return seen;
 }
 
+// Returns the set of nodes in `candidates` that can reach `target` by
+// traversing `deps` in reverse.  This is equivalent to asking which nodes
+// in the forward-reachable set from `target` also have `target` in their
+// own forward-reachable set, but computed in a single BFS over the
+// transposed graph rather than one BFS per candidate node.
+function reachableIndexesTransposed(target, deps, candidates) {
+  // Build a transposed adjacency list restricted to the candidate set.
+  const reverse = new Map();
+  for (const from of candidates) {
+    if (!reverse.has(from)) reverse.set(from, []);
+    for (const to of deps[from]) {
+      if (!candidates.has(to)) continue;
+      let bucket = reverse.get(to);
+      if (bucket == null) { bucket = []; reverse.set(to, bucket); }
+      bucket.push(from);
+    }
+  }
+  const seen = new Set();
+  const stack = [target];
+  while (stack.length) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    for (const prev of reverse.get(current) ?? []) if (!seen.has(prev)) stack.push(prev);
+  }
+  return seen;
+}
+
 
 export function isFiniteDatalogArgument(term) {
   return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';

package/src/solver.js

@@ -2,7 +2,7 @@
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
   ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
-  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
+  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
@@ -2692,11 +2692,14 @@ function matchScalarFact(goal, head, env) {
 
 function derefScalarMatch(term, env, names, values) {
   let current = term;
-  for (let guard = 0; current?.type === 'var' && guard < 128; guard++) {
+  const seen = new Set();
+  while (current?.type === 'var') {
+    if (seen.has(current.name)) break;
+    seen.add(current.name);
     const localIndex = names.indexOf(current.name);
-    if (localIndex >= 0) current = values[localIndex];
-    else if (env.has(current.name)) current = env.get(current.name);
-    else break;
+    if (localIndex >= 0) { current = values[localIndex]; continue; }
+    if (env.has(current.name)) { current = env.get(current.name); continue; }
+    break;
   }
   return current;
 }
@@ -3092,12 +3095,11 @@ function matchGroundBinaryClause(goal, clause) {
   return { nextGoal: compound(bodyGoal.name, bodyArgs) };
 }
 
-function isScalarTerm(term) {
-  return term && (term.type === 'atom' || term.type === 'string' || term.type === 'number');
-}
+// isScalar is imported from term.js; use it as the canonical scalar test.
+const isScalarTerm = isScalar;
 
 function sameScalarTerm(left, right) {
-  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type &&
+  return isScalar(left) && isScalar(right) && left.type === right.type &&
     (left.type === 'number' ? sameNumberValue(left.name, right.name) : left.name === right.name);
 }
 
@@ -3131,9 +3133,9 @@ function sameResolvedGroundTerm(left, right, env) {
 
 function groundChainKey(term) {
   if (term?.type === COMPOUND) {
-    let out = `${term.name}/${term.arity}`;
-    for (let i = 0; i < term.arity; i++) out += `${groundChainKey(term.args[i])}`;
-    return out;
+    const parts = [`${term.name}/${term.arity}`];
+    for (let i = 0; i < term.arity; i++) parts.push(groundChainKey(term.args[i]));
+    return parts.join('');
   }
   return `${term?.type ?? ''}:${term?.name ?? ''}`;
 }

package/src/write.js

@@ -5,7 +5,6 @@ import {
 } from './term.js';
 
 const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
-const dottedGraphicAtomCharacters = graphicAtomCharacters;
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -60,7 +59,7 @@ function writeAtom(name) {
 
 function isDottedGraphicAtom(name) {
   return name.includes('.') && [...name].some((ch) => ch !== '.') && !name.startsWith('/*') &&
-    [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
+    [...name].every((ch) => graphicAtomCharacters.has(ch));
 }
 
 function compactBoundaryNeedsSpace(left, right) {

package/test/conformance/NEUMERKEL-LATEST.md

@@ -1,21 +1,22 @@
 # EyeProlog — latest Neumerkel conformity
 
-Status: **PASS** — **665/665** discovered upstream cases passed.
+Status: **PASS** — **686/686** 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.
+`npm test` fetches the seven 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.
 
 | Suite | Passed | Total |
 |---|---:|---:|
-| syntax | 366 | 366 |
-| number_chars/2 | 78 | 78 |
+| syntax | 379 | 379 |
+| number_chars/2 | 86 | 86 |
 | 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** |
+| **Total** | **686** | **686** |
 
 ## Upstream sources
 
@@ -29,6 +30,9 @@ still match the live suites. Counts are output from upstream, not hard-coded tes
 
 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.
+A normal test run warns when this tracked report is stale. Refresh directly from live
+upstream with `npm run conformance:update:neumerkel`, or sync the exact successful
+snapshot already fetched by `npm test` with `npm run conformance:sync:neumerkel`.
+`npm run conformance:check:neumerkel` verifies the tracked report against that last
+successful live snapshot without fetching upstream a second time.
 

package/test/conformance/NEUMERKEL-LIVE.md

@@ -15,7 +15,11 @@ counts.
 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.
+executed automatically and a removed row disappears automatically. The syntax
+extractor keys the expected result from TU Wien's labelled `Codex` column rather
+than assuming a fixed cell position, and cross-checks the discovered inventory
+against the total declared by the live page so hand-edited HTML cannot silently
+reduce coverage.
 
 ## Tracked GitHub evidence
 
@@ -23,18 +27,22 @@ 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:
+A normal live run always executes the current upstream inventory. If the tracked
+Markdown no longer matches, the test still reflects engine conformance and prints a
+warning with the refresh command:
 
 ```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.
+change. After a successful `npm test`, `npm run conformance:sync:neumerkel` writes
+the tracked report from the exact cached source bytes that just passed, avoiding a
+second network fetch. `npm run conformance:check:neumerkel` verifies the tracked
+report against that same last successful snapshot. The npm version lifecycle
+uses this race-free sync path and stages the generated reports into the release
+commit. 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
 
@@ -55,8 +63,10 @@ fetch, use:
 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 cached command never claims to check the latest upstream suites by itself.
+The release flow first performs the canonical live `npm test`, then uses those exact
+just-fetched bytes only to synchronize and verify the tracked evidence without
+contacting upstream twice.
 
 The vendored WG17 syntax matrix remains useful as a deterministic reviewed
 regression snapshot, but it is secondary to this live gate: passing the snapshot

package/test/conformance/README.md

@@ -89,18 +89,20 @@ npm run test:conformance          # live Neumerkel + local ISO/conformance layer
 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 conformance:check:neumerkel # verify tracked report against last successful live snapshot
 npm run test:iso                  # Part 1 + Corrigenda strict-core processor gate
 npm run test:wg17                 # vendored reviewed WG17 syntax regression
 ```
 
 `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).
+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. If the stable, tracked [NEUMERKEL-LATEST.md](NEUMERKEL-LATEST.md) is stale, normal tests warn rather than turning a passing engine run into a failure. `npm run conformance:update:neumerkel` performs a fresh live run and refreshes the report; after `npm test`, `npm run conformance:sync:neumerkel` refreshes it from the exact successful cached snapshot; and `npm run conformance:check:neumerkel` verifies that snapshot without a second network fetch. Exact bytes, SHA-256 hashes, timestamps, and HTTP validators stay under Git-ignored `.cache/neumerkel/` for audit/reproduction only. See [NEUMERKEL-LIVE.md](NEUMERKEL-LIVE.md).
 
 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 conformance:update:wg17
 npm run conformance:update:neumerkel
+npm run conformance:sync:neumerkel
 npm run test:wg17
 ```
 
@@ -134,7 +136,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 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.
+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; release/report checks separately verify 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/neumerkel.mjs

@@ -337,22 +337,36 @@ export async function executeNeumerkel({ reporter, mode = 'live', cacheDir = def
   reporter.section(`Neumerkel conformity (${mode === 'live' && sourceDir == null ? 'live upstream' : sourceDir != null ? 'source fixtures' : 'cached'})`);
 
   const syntaxCases = materializeSyntaxCases(sources.get('syntax').text);
+  const syntaxFailures = [];
+  let syntaxPassed = 0;
   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)}`);
-      }
-    });
+    try {
+      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)}`);
+        }
+      });
+      syntaxPassed++;
+    } catch (error) {
+      // Upstream changes often arrive in small clusters. Keep running the
+      // syntax inventory so one live test run exposes every new mismatch
+      // instead of forcing a fix/rerun cycle for each row.
+      syntaxFailures.push(error);
+    }
+  }
+  summary.syntax = { passed: syntaxPassed, total: syntaxCases.length };
+  if (syntaxFailures.length > 0) {
+    throw new AggregateError(
+      syntaxFailures,
+      `${syntaxFailures.length} live Neumerkel syntax case${syntaxFailures.length === 1 ? '' : 's'} failed`,
+    );
   }
-  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 result = reporter.batch(`${key.replace('_', ' ')} live corpus`, () =>
+      ensureQuadSuccess(key, sources.get(key)));
+    summary[key] = { passed: result.passed, total: result.total };
   }
 
   const difCases = parseDifCases(sources.get('dif').text);
@@ -440,8 +454,9 @@ export function formatNeumerkelMarkdown({ summary }) {
     `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.',
+    '`npm test` fetches the seven 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.',
     '',
     '| Suite | Passed | Total |',
     '|---|---:|---:|',
@@ -460,8 +475,11 @@ export function formatNeumerkelMarkdown({ summary }) {
     '',
     '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.',
+    'A normal test run warns when this tracked report is stale. Refresh directly from live',
+    'upstream with `npm run conformance:update:neumerkel`, or sync the exact successful',
+    'snapshot already fetched by `npm test` with `npm run conformance:sync:neumerkel`.',
+    '`npm run conformance:check:neumerkel` verifies the tracked report against that last',
+    'successful live snapshot without fetching upstream a second time.',
     '',
   );
   return `${lines.join('\n')}\n`;

package/test/run-conformance-report.mjs

@@ -84,8 +84,9 @@ export function formatConformanceReport(report = buildConformanceReport()) {
     '## 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.',
+    '`npm test` fetches all seven 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

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 import { NEUMERKEL_SOURCES, formatNeumerkelMarkdown, materializeSyntaxCases, parseCleanupCases, parseDifCases } from './neumerkel.mjs';
+import { executeWg17Item, matchesUpstreamExpectation } from './run-wg17.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
 
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
 function syntaxHtml(count = 101) {
   const rows = [];
   for (let id = 1; id <= count; id++) {
@@ -12,6 +18,13 @@ function syntaxHtml(count = 101) {
   return `<table>${rows.join('')}</table>`;
 }
 
+function syntaxHtmlWithBareAnchors() {
+  const rows = [];
+  for (let id = 1; id <= 366; id++) rows.push(`<tr><td><a name=${id}>${id}</a><td>true.<td>succeeds`);
+  for (let id = 367; id <= 376; id++) rows.push(`<td><a name=${id}>${id}</a><td>true.<td>succeeds`);
+  return `<table><tr><td>number of conforming queries<td>376/376${rows.join('')}</table>`;
+}
+
 export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
   reporter.section('Neumerkel harness');
 
@@ -27,6 +40,57 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
     if (!cases[1].input.includes('op(9,fy,x)')) throw new Error('/**/ setup was not reconstructed');
   });
 
+  reporter.test('syntax discovery includes bare anchored rows appended without tr', () => {
+    const cases = materializeSyntaxCases(syntaxHtmlWithBareAnchors());
+    if (cases.length !== 376) throw new Error(`expected 376 cases, got ${cases.length}`);
+    if (cases.at(-1)?.id !== 376) throw new Error('last bare anchored syntax row was not discovered');
+  });
+
+  reporter.test('syntax discovery uses the Codex-labelled expected cell on malformed appended rows', () => {
+    const rows = [];
+    for (let id = 1; id <= 100; id++) rows.push(`<tr><td>${id}<td>true.<td class=codx>succeeds`);
+    // A hand-edited row can acquire an extra cell before the semantic Codex
+    // column. Positional extraction would incorrectly read "syntax err.".
+    rows.push('<td><a name=101>101</a><td>writeq(a).<td>syntax err.<td class=codx>a<td>OK');
+    const cases = materializeSyntaxCases(`<table>${rows.join('')}</table>`);
+    const item = cases.find(({ id }) => id === 101);
+    if (item?.expected !== 'a') {
+      throw new Error(`expected Codex-labelled result, got ${JSON.stringify(item)}`);
+    }
+  });
+
+  reporter.test('latest strict syntax allows Neumerkel #379 parenthesized --> atom', () => {
+    // Upstream Codex expectation for #379: writeq((-->)/2). -> (-->)/2
+    // (-->)/2 is valid: parentheses make --> an ordinary atom; only bare
+    // --> followed by / in a predicate indicator is processor-defined syntax.
+    const item = {
+      id: 379,
+      query: 'writeq((-->)/2).',
+      input: 'writeq((-->)/2).',
+      readCount: 1,
+      expected: '(-->)/2',
+    };
+    const actual = executeWg17Item(item);
+    if (!matchesUpstreamExpectation(item.expected, actual, item)) {
+      throw new Error(`Neumerkel #379 did not match: ${JSON.stringify(actual)}`);
+    }
+  });
+
+  reporter.test('syntax discovery fails loudly when a labelled live row loses its Codex cell', () => {
+    const rows = [];
+    for (let id = 1; id <= 100; id++) rows.push(`<tr><td>${id}<td>true.<td class=codx>succeeds`);
+    rows.push('<td><a name=101>101</a><td>true.<td>succeeds');
+    let caught = null;
+    try {
+      materializeSyntaxCases(`<table>${rows.join('')}</table>`);
+    } catch (error) {
+      caught = error;
+    }
+    if (!caught || !String(caught.message).includes('no labelled Codex cell')) {
+      throw new Error(`missing Codex column was not rejected: ${caught?.message ?? 'no error'}`);
+    }
+  });
+
   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') {
@@ -36,7 +100,7 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
 
   reporter.test('tracked Markdown report records dynamic counts without volatile metadata', () => {
     const summary = {
-      syntax: { passed: 366, total: 366 },
+      syntax: { passed: 376, total: 376 },
       number_chars: { passed: 78, total: 78 },
       variable_names: { passed: 75, total: 75 },
       dif: { passed: 26, total: 26 },
@@ -48,7 +112,7 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
       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('**675/675**')) 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')) {
@@ -56,6 +120,23 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
     }
   });
 
+  reporter.test('release workflow reuses the successful live snapshot instead of refetching', () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    const scripts = pkg.scripts ?? {};
+    if (scripts['conformance:sync:neumerkel'] !== 'node test/run-neumerkel.mjs --cached --update-report') {
+      throw new Error('Neumerkel sync must update from the cached successful live snapshot');
+    }
+    if (scripts['conformance:check:neumerkel'] !== 'node test/run-neumerkel.mjs --cached --verify-report') {
+      throw new Error('Neumerkel report check must not refetch live upstream');
+    }
+    if (!String(scripts.preversion ?? '').includes('conformance:sync:neumerkel')) {
+      throw new Error('preversion must synchronize the tracked report from the successful npm test snapshot');
+    }
+    if (String(scripts.preversion ?? '').includes('conformance:check:neumerkel')) {
+      throw new Error('preversion must not perform a second report check/fetch cycle after synchronization');
+    }
+  });
+
   reporter.test('cleanup discovery follows the reference one-line example protocol', () => {
     const html = `<pre>
 setup_call_cleanup(fail,_,_).

package/test/run-neumerkel.mjs

@@ -10,12 +10,13 @@ function parseArgs(argv) {
     mode: 'live',
     sourceDir: process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR ?? null,
     updateReport: false,
-    verifyReport: true,
+    verifyReport: false,
   };
   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 === '--verify-report') options.verifyReport = 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');
@@ -28,16 +29,16 @@ function parseArgs(argv) {
 
 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',
+    'Usage: npm run test:neumerkel -- [--cached] [--source-dir DIR] [--verify-report] [--update-report]\n\n' +
+    'Default: fetch all seven 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',
   );
 }
 
 export async function runNeumerkel(reporter, options = {}) {
-  const effective = { verifyReport: true, updateReport: false, ...options };
+  const effective = { verifyReport: false, updateReport: false, ...options };
   if (effective.sourceDir == null && process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR) {
     effective.sourceDir = path.resolve(process.env.EYEPROLOG_NEUMERKEL_SOURCE_DIR);
   }
@@ -48,17 +49,17 @@ export async function runNeumerkel(reporter, options = {}) {
     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) {
+  } else {
     const committed = fs.existsSync(result.reportPath) ? fs.readFileSync(result.reportPath, 'utf8') : null;
     if (committed !== result.reportText) {
-      throw new Error(
+      const message =
         `tracked Neumerkel report is stale: ${relativeReportPath}\n` +
-        'Run npm run conformance:update:neumerkel and commit the updated report.',
-      );
+        'Run npm run conformance:update:neumerkel and commit the updated report.';
+      if (effective.verifyReport) throw new Error(message);
+      reporter.stdout.write(`WARN ${message}\n`);
+    } else {
+      reporter.stdout.write(`Neumerkel report: ${relativeReportPath}\n`);
     }
-    reporter.stdout.write(`Neumerkel report: ${relativeReportPath}\n`);
-  } else {
-    reporter.stdout.write(`Neumerkel report verification skipped (${relativeReportPath})\n`);
   }
   return result;
 }
@@ -85,6 +86,20 @@ function quietNeumerkelReporter(reporter) {
         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;
+      }
+    },
   };
 }
 

package/test/run-regression.mjs

@@ -1955,6 +1955,37 @@ c4 ?- call((!;1)).
         assertIncludes(caught.message, 'operator atom', 'syntax rejection');
       },
     },
+    {
+      name: 'ISO predicate indicators require parentheses around bare operator atoms',
+      run: () => {
+        // Bare --> /2 (without parens) is still rejected in all modes because
+        // --> is an infix/prefix operator atom that cannot appear as a bare operand.
+        let caught = null;
+        try {
+          parseGoalText('writeq(--> /2)');
+        } catch (error) {
+          caught = error;
+        }
+        if (!caught) throw new Error('bare operator predicate indicator unexpectedly parsed');
+        assertIncludes(caught.message, 'operator atom', 'bare indicator syntax rejection');
+        // (-->)/2 with parentheses is legal in both normal and strict ISO modes.
+        // Neumerkel #379: upstream Codex expectation is (-->)/2 -> (-->)/2 (success).
+        // Parentheses make --> an ordinary atom argument; ISO 7.10.3 does not
+        // restrict which atoms may appear as the name in a Name/Arity indicator.
+        parseGoalText('writeq((-->)/2)');
+        assertEqual(
+          run('', { goal: 'writeq((-->)/2)' }).stdout,
+          '(-->)/2writeq((-->) / 2).\n',
+          'parenthesized operator indicator stays legal outside strict ISO',
+        );
+        parseGoalText('writeq((-->)/2)', { isoStrict: true });
+        assertEqual(
+          run('', { isoStrict: true, goal: 'writeq((-->)/2)' }).stdout,
+          '(-->)/2writeq((-->) / 2).\n',
+          'Neumerkel #379: parenthesized --> is legal in strict ISO',
+        );
+      },
+    },
     {
       name: 'CLP(Z) operator declarations avoid unnecessary quoted atoms',
       run: () => {

package/tools/upgrade-wg17.mjs

@@ -58,6 +58,28 @@ function deletedRow(rowHtml, idCellHtml) {
     /class\s*=\s*["'][^"']*\b(?:deleted|obsolete|removed)\b/i.test(rowHtml);
 }
 
+function cellsFromChunk(body) {
+  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({
+      openTag: cellStart[0],
+      body: body.slice(cellBodyStart, cellEnd),
+    });
+  }
+  return cells;
+}
+
+function cellHasClass(cell, className) {
+  const escaped = className.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const quoted = new RegExp(`\\bclass\\s*=\\s*[\"']([^\"']*)[\"']`, 'i').exec(cell.openTag)?.[1] ?? '';
+  if (quoted.split(/\s+/).some((part) => part.toLowerCase() === className.toLowerCase())) return true;
+  return new RegExp(`\\bclass\\s*=\\s*${escaped}(?:\\s|>|$)`, 'i').test(cell.openTag);
+}
+
 function htmlTableRows(html) {
   // TU Wien intentionally serves very small, old-style HTML. In valid HTML,
   // </td> and </tr> are optional, and the conformity page currently relies
@@ -73,38 +95,82 @@ function htmlTableRows(html) {
     const rowEnd = explicitEnd < 0 ? nextRow : bodyStart + explicitEnd;
     const rowHtml = html.slice(rowStart.index, rowEnd);
     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({ rowHtml, cells });
+    rows.push({ start: rowStart.index, rowHtml, cells: cellsFromChunk(body) });
+  }
+  return rows;
+}
+
+function htmlAnchoredSyntaxRows(html) {
+  // The conformity page is hand-edited old-style HTML. New rows are sometimes
+  // appended as bare `<td><a name=N>` anchors without a surrounding `<tr>`.
+  // Treat every numbered first-cell anchor as a row boundary so new upstream
+  // cases cannot be silently glued to the previous row.
+  const anchors = [...html.matchAll(/<td\b[^>]*>\s*<a\b[^>]*\bname\s*=\s*["']?\d+["']?[^>]*>/gi)];
+  const rows = [];
+  for (let index = 0; index < anchors.length; index++) {
+    const start = anchors[index].index;
+    const end = anchors[index + 1]?.index ?? html.length;
+    const rowHtml = html.slice(start, end);
+    rows.push({ start, rowHtml, cells: cellsFromChunk(rowHtml) });
   }
   return rows;
 }
 
+function declaredSyntaxTotal(html) {
+  const marker = html.search(/number of conforming queries/i);
+  if (marker < 0) return null;
+  const text = decodeHtmlEntities(html.slice(marker, marker + 2000).replace(/<[^>]+>/g, ' '));
+  const match = text.match(/(\d+)\s*\/\s*(\d+)/);
+  return match == null ? null : Number(match[2]);
+}
+
 export function parseWg17SyntaxTable(html) {
   const cases = [];
   const seen = new Set();
-  for (const { rowHtml, cells } of htmlTableRows(html)) {
-    if (cells.length < 3 || deletedRow(rowHtml, cells[0])) continue;
-
-    const idText = htmlCellText(cells[0]).replace(/^#\s*/, '');
+  // Real TU Wien conformity rows label the standards/Codex expectation. If
+  // the page uses that label anywhere, require it for every numbered test
+  // row instead of silently falling back to a physical column position.
+  const labelledCodexPage = /<t[dh]\b[^>]*\bclass\s*=\s*(?:["'][^"']*\bcodx\b[^"']*["']|codx(?:\s|>|$))/i.test(html);
+  // Merge ordinary `<tr>` rows with numbered first-cell anchors in document
+  // order. The anchor view supplies hand-appended rows that omit `<tr>`; the
+  // normal view still handles fixtures/pages without named anchors.
+  const rows = [...htmlTableRows(html), ...htmlAnchoredSyntaxRows(html)]
+    .sort((a, b) => a.start - b.start);
+  const byId = new Map();
+  for (const { rowHtml, cells } of rows) {
+    if (cells.length < 3 || deletedRow(rowHtml, cells[0].body)) continue;
+
+    const idText = htmlCellText(cells[0].body).replace(/^#\s*/, '');
     const idMatch = idText.match(/^(\d+)$/);
     if (idMatch == null) continue;
     const id = Number(idMatch[1]);
-    if (seen.has(id)) throw new Error(`duplicate active WG17 syntax id #${id} in upstream table`);
 
     // TU Wien uses non-breaking spaces for table presentation/indentation.
     // They are not part of the Prolog source being specified, so normalize
     // them to ordinary spaces before snapshotting/comparing rows.
-    const query = htmlCellText(cells[1]).replace(/\u00a0/g, ' ');
-    const expected = htmlCellText(cells[2]).replace(/\u00a0/g, ' ').replace(/[²³°]/g, '').replace(/[ \t\n]+/g, ' ').trim();
+    const query = htmlCellText(cells[1].body).replace(/\u00a0/g, ' ');
+    // Do not assume the Codex/expected result is physically the third cell.
+    // The live TU Wien page is hand-edited old-style HTML and newly appended
+    // rows can have malformed/extra cells.  The semantic column is explicitly
+    // marked class=codx upstream, so prefer that marker and only fall back to
+    // position 3 for small synthetic fixtures/older snapshots without classes.
+    const codexCell = cells.find((cell) => cellHasClass(cell, 'codx'));
+    if (labelledCodexPage && codexCell == null) {
+      throw new Error(`WG17 syntax row #${id} has no labelled Codex cell; upstream HTML format may have changed`);
+    }
+    const expectedCell = codexCell ?? cells[2];
+    const expected = htmlCellText(expectedCell.body).replace(/\u00a0/g, ' ').replace(/[²³°]/g, '').replace(/[ \t\n]+/g, ' ').trim();
     if (query.length === 0 || expected.length === 0) continue;
-    cases.push({ id, query, expected });
+    if (seen.has(id)) {
+      const previous = byId.get(id);
+      if (previous.query !== query || previous.expected !== expected) {
+        throw new Error(`duplicate active WG17 syntax id #${id} in upstream table`);
+      }
+      continue;
+    }
+    const item = { id, query, expected };
+    cases.push(item);
+    byId.set(id, item);
     seen.add(id);
   }
   if (cases.length < 100) {
@@ -115,6 +181,13 @@ export function parseWg17SyntaxTable(html) {
       `(saw ${trCount} row starts and ${tdCount} cell starts); upstream HTML format may have changed`,
     );
   }
+  const declared = declaredSyntaxTotal(html);
+  if (declared != null && cases.length !== declared) {
+    throw new Error(
+      `WG17 syntax inventory mismatch: upstream declares ${declared} active queries but parser discovered ${cases.length}; ` +
+      'upstream HTML format may have changed',
+    );
+  }
   return cases;
 }