eyeprolog 1.5.72 → 1.5.75

package/README.md

@@ -84,7 +84,7 @@ The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-gr
 The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing), [explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration), [operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response), [software supply-chain vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response), and a [scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
 
 ## Benchmarks
-EyeProlog has 19 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+EyeProlog has 19 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark -- --save .benchmarks/baseline.json`; use `node test/run-benchmark-tests.mjs` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `node test/lips-benchmark.mjs`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `node test/lips-benchmark.mjs` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 For the project policy on post-ISO-standard and WG17 compatibility features such as digit separators, see [ISO/WG17 compatibility extensions](test/conformance/ISO-WG17-EXTENSIONS.md).
 ## Development
 ```sh
@@ -93,5 +93,13 @@ 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. 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`.
+The npm command list is deliberately small:
+
+- `npm test` (or `npm run test`): run the release gate, including live upstream conformity checks.
+- `npm run conformance:update:wg17`: update the vendored WG17 syntax cases and their inventory documentation.
+- `npm run generate`: rebuild generated library and book files.
+- `npm run benchmark`: run the wall-clock benchmarks.
+
+Use `npm test -- --offline` for a network-free local pass. Focused checks remain available directly, for example `node test/run-regression.mjs docs` or `node test/run-wg17.mjs`; see [test runners](test/README.md). The automatic version hooks still run the release gate, refresh and stage conformance reports, and push the release. Detailed upstream report maintenance is documented in the [conformance guide](test/conformance/README.md).
+
 EyeProlog is released under the [MIT License](LICENSE.md).

package/examples/deck/symbiotic-knowledge-graphs.md

@@ -291,7 +291,7 @@ rdf-to-prolog \
 Run the checked EyeProlog example:
 
 ```sh
-npm run test:examples
+node test/run-examples.mjs
 ```
 
 Materialize only the RDF-shaped results:

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.72",
+  "version": "1.5.75",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,36 +46,10 @@
   },
   "scripts": {
     "test": "node test/run-all.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",
-    "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:regression": "node test/run-regression.mjs",
-    "test:examples": "node test/run-examples.mjs",
-    "test:interop": "node test/run-interop.mjs",
-    "test:playground": "node test/run-playground.mjs",
-    "test:architecture": "node test/run-architecture.mjs",
-    "test:openrulebench": "node test/run-openrulebench.mjs",
-    "test:benchmark": "node test/run-benchmark-tests.mjs",
+    "conformance:update:wg17": "node tools/upgrade-wg17.mjs",
     "benchmark": "node test/benchmark.mjs",
-    "benchmark:lips": "node test/lips-benchmark.mjs",
-    "benchmark:baseline": "node test/benchmark.mjs --save .benchmarks/baseline.json",
-    "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",
-    "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:check:neumerkel": "node test/run-neumerkel.mjs --cached --verify-report",
-    "conformance:sync:neumerkel": "node test/run-neumerkel.mjs --cached --update-report",
-    "test:http-json": "node test/run-http-json.mjs",
-    "test:iso-part2-amendment": "node test/run-iso-part2-amendment.mjs"
+    "preversion": "npm test && node test/run-neumerkel.mjs --cached --update-report && node test/run-conformance-report.mjs conformance-report.md && git add test/conformance/NEUMERKEL-LATEST.md conformance-report.md",
+    "postversion": "git push origin HEAD --follow-tags"
   }
 }

package/src/repl.js

@@ -773,6 +773,18 @@ function formatAnswer(engine, state, variables, env) {
     doubleBar: !state.strictIso,
   };
   let generated = 0;
+  // Names generated for otherwise-anonymous variables (`_A`, `_B`, ...) must
+  // never collide with a name the query itself is already using for a
+  // *different* variable (e.g. a query literally naming `_A`) — printing an
+  // internal fresh variable as `_A` right next to the user's own `_A` binding
+  // falsely suggests they are the same variable (issue #108).
+  const usedDisplayNames = new Set(names.values());
+  const nextGeneratedName = () => {
+    let candidate;
+    do { candidate = `_${letterName(generated++)}`; } while (usedDisplayNames.has(candidate));
+    usedDisplayNames.add(candidate);
+    return candidate;
+  };
 
   // Meta-predicate wrappers can make a query variable alias an internal fresh
   // variable. Keep residual constraints tied to the query's visible name.
@@ -780,7 +792,7 @@ function formatAnswer(engine, state, variables, env) {
     const root = engine.deref(variable, env);
     if (root.type === 'var' && !names.has(root.name)) names.set(root.name, variable.name);
   }
-  for (const variable of variables) collectUnboundVariables(engine, variable, env, names, () => `_${letterName(generated++)}`);
+  for (const variable of variables) collectUnboundVariables(engine, variable, env, names, nextGeneratedName);
   for (const variable of variables) {
     const value = engine.deref(variable, env);
     if (value.type === 'var' &&
@@ -796,7 +808,7 @@ function formatAnswer(engine, state, variables, env) {
   for (const constraint of env.variableConstraints?.() ?? []) {
     const residual = constraint.residualGoal?.(env);
     if (residual == null) continue;
-    collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+    collectUnboundVariables(engine, residual, env, names, nextGeneratedName);
     bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
   // Residual attributes are part of the answer even when the attributed
@@ -821,9 +833,9 @@ function formatAnswer(engine, state, variables, env) {
   for (const root of attributeRoots) {
     if (projectedAttributeRoots.has(root.name) || !env.hasPrologAttributes?.(root.name)) continue;
     projectedAttributeRoots.add(root.name);
-    if (!names.has(root.name)) names.set(root.name, `_${letterName(generated++)}`);
+    if (!names.has(root.name)) names.set(root.name, nextGeneratedName());
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
-      collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+      collectUnboundVariables(engine, residual, env, names, nextGeneratedName);
       bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
     }
   }

package/test/README.md

@@ -0,0 +1,33 @@
+# Test runners
+
+Normally, run `npm test`. Use `npm test -- --offline` to skip live upstream fetching.
+`npm run conformance:update:wg17` refreshes the vendored WG17 snapshot.
+
+For development, run a focused check directly from the repository root:
+
+```sh
+node test/run-regression.mjs        # all regression sections
+node test/run-regression.mjs docs   # documentation checks only
+node test/run-conformance-all.mjs   # conformance layers; accepts --offline
+node test/run-wg17.mjs              # vendored WG17 syntax
+node test/run-iso-strict.mjs        # strict ISO core
+node test/run-iso-part2-amendment.mjs
+node test/run-neumerkel.mjs         # live upstream; --cached reproduces last fetch
+node test/run-neumerkel-tests.mjs   # upstream-fetch harness
+node test/run-examples.mjs
+node test/run-playground.mjs
+node test/run-architecture.mjs
+node test/run-openrulebench.mjs
+node test/run-http-json.mjs
+node test/run-interop.mjs           # requires the comparison engines
+node test/run-benchmark-tests.mjs   # benchmark harness
+```
+
+These runners retain their existing options; there is no separate npm alias for
+each one. Focused checks do not replace the full release gate.
+
+For performance measurements, use `npm run benchmark`. Save a local baseline with
+`npm run benchmark -- --save .benchmarks/baseline.json`, or run
+`node test/lips-benchmark.mjs` for the classic LIPS measurement.
+
+See the [conformance guide](conformance/README.md) for report maintenance.

package/test/benchmark.mjs

@@ -102,7 +102,7 @@ if (baselinePath != null) {
   const loaded = JSON.parse(await fs.readFile(baselinePath, 'utf8'));
   if (loaded.format === 2) baseline = loaded;
   else {
-    baselineWarning = `Ignoring legacy timing baseline format ${loaded.format ?? 'unknown'}; regenerate it with npm run benchmark:baseline.`;
+    baselineWarning = `Ignoring legacy timing baseline format ${loaded.format ?? 'unknown'}; regenerate it with npm run benchmark -- --save .benchmarks/baseline.json.`;
     baselinePath = null;
   }
 }
@@ -296,10 +296,10 @@ if (options.json) {
 
   process.stdout.write(`\n${results.length} benchmarks; ${options.runs} measured batch${options.runs === 1 ? '' : 'es'} each after ${options.warmup} warm-up batch${options.warmup === 1 ? '' : 'es'}, calibrated after one priming execution toward ${options.targetMs} ms per batch.\n`);
   if (baselineWarning) process.stdout.write(`${baselineWarning}\n`);
-  if (baselinePath == null && !baselineWarning) process.stdout.write('No timing baseline found; run npm run benchmark:baseline to create .benchmarks/baseline.json.\n');
+  if (baselinePath == null && !baselineWarning) process.stdout.write('No timing baseline found; run npm run benchmark -- --save .benchmarks/baseline.json to create .benchmarks/baseline.json.\n');
   if (options.save != null) process.stdout.write(`Saved timing baseline: ${path.relative(root, options.save)}\n`);
   process.stdout.write('Change compares the current median/op directly with the saved baseline median/op; the measured range is shown separately.\n');
-  process.stdout.write('The classic-nrev LIPS column is a quick wall-clock estimate. Use npm run benchmark:lips for the Quintus-style dummy-subtracted CPU measurement.\n');
+  process.stdout.write('The classic-nrev LIPS column is a quick wall-clock estimate. Use node test/lips-benchmark.mjs for the Quintus-style dummy-subtracted CPU measurement.\n');
   if (summary.comparable > 0) {
     process.stdout.write('Suite score is the geometric mean of current/baseline ratios, so every benchmark has equal relative weight; Time-weighted total compares summed medians and is dominated by longer workloads.\n');
   }

package/test/conformance/ISO-COMPLIANCE.md

@@ -286,14 +286,14 @@ 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
+node test/run-conformance-all.mjs
+node test/run-neumerkel.mjs
+node test/run-iso-strict.mjs
+node test/run-wg17.mjs
+npm test -- --offline
 ```
 
-`test:offline` is a development/reproduction aid; it is not sufficient for a
+`npm 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.
 

package/test/conformance/NEUMERKEL-LATEST.md

@@ -31,8 +31,8 @@ Counts are output from upstream, not hard-coded test constants.
 Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under
 Git-ignored `.cache/neumerkel/` for local inspection/reproduction and are intentionally not committed.
 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
+upstream with `node test/run-neumerkel.mjs --update-report`, or sync the exact successful
+snapshot already fetched by `npm test` with `node test/run-neumerkel.mjs --cached --update-report`.
+`node test/run-neumerkel.mjs --cached --verify-report` verifies the tracked report against that last
 successful live snapshot without fetching upstream a second time.
 

package/test/conformance/NEUMERKEL-LIVE.md

@@ -4,7 +4,7 @@ EyeProlog treats Ulrich Neumerkel's current ISO/WG17 conformity material as a
 moving upstream release gate, not as a frozen snapshot with permanent case
 counts.
 
-`npm run test:neumerkel` fetches these seven TU Wien sources on every live run:
+`node test/run-neumerkel.mjs` 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;
@@ -32,13 +32,13 @@ Markdown no longer matches, the test still reflects engine conformance and print
 warning with the refresh command:
 
 ```sh
-npm run conformance:update:neumerkel
+node test/run-neumerkel.mjs --update-report
 ```
 
 Commit the resulting `test/conformance/NEUMERKEL-LATEST.md` after reviewing the
-change. After a successful `npm test`, `npm run conformance:sync:neumerkel` writes
+change. After a successful `npm test`, `node test/run-neumerkel.mjs --cached --update-report` 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
+second network fetch. `node test/run-neumerkel.mjs --cached --verify-report` 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,
@@ -53,14 +53,14 @@ Git-ignored: it is an inspection/reproduction cache, not published project evide
 Use:
 
 ```sh
-npm run test:neumerkel
+node test/run-neumerkel.mjs
 ```
 
 for the canonical live check. For offline reproduction of the exact last live
 fetch, use:
 
 ```sh
-npm run test:neumerkel:cached
+node test/run-neumerkel.mjs --cached
 ```
 
 The cached command never claims to check the latest upstream suites by itself.

package/test/conformance/README.md

@@ -83,39 +83,39 @@ npm test
 For an offline-only development pass:
 
 ```sh
-npm run test:offline
+npm test -- --offline
 ```
 
 The conformance commands are:
 
 ```sh
-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 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:iso-part2-amendment  # 2013 Part 2 amendment module requirements
-npm run test:wg17                 # vendored reviewed WG17 syntax regression
+node test/run-conformance-all.mjs          # live Neumerkel + local ISO/conformance layers
+node test/run-conformance-all.mjs --offline  # same local layers, no network
+node test/run-neumerkel.mjs            # the seven live upstream suites only
+node test/run-neumerkel.mjs --cached     # exact last fetched bytes; reproduction only
+node test/run-neumerkel.mjs --cached --verify-report # verify tracked report against last successful live snapshot
+node test/run-iso-strict.mjs                  # Part 1 + Corrigenda strict-core processor gate
+node test/run-iso-part2-amendment.mjs  # 2013 Part 2 amendment module requirements
+node test/run-wg17.mjs                 # 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. 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 inspection/reproduction only. See [NEUMERKEL-LIVE.md](NEUMERKEL-LIVE.md).
+`node test/run-neumerkel.mjs` 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. 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. `node test/run-neumerkel.mjs --update-report` performs a fresh live run and refreshes the report; after `npm test`, `node test/run-neumerkel.mjs --cached --update-report` refreshes it from the exact successful cached snapshot; and `node test/run-neumerkel.mjs --cached --verify-report` verifies that snapshot without a second network fetch. Exact bytes, SHA-256 hashes, timestamps, and HTTP validators stay under Git-ignored `.cache/neumerkel/` for inspection/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:
+The vendored WG17 syntax snapshot is intentionally secondary. Update it with `npm run conformance:update:wg17`. For focused upstream report maintenance and verification:
 
 ```sh
 npm run conformance:update:wg17
-npm run conformance:update:neumerkel
-npm run conformance:sync:neumerkel
-npm run test:wg17
+node test/run-neumerkel.mjs --update-report
+node test/run-neumerkel.mjs --cached --update-report
+node test/run-wg17.mjs
 ```
 
 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 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.
+Regenerate the top-level local-corpus report with `node test/run-conformance-report.mjs conformance-report.md`. 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.
 
 Run a matching local file-based conformance subset directly with:
 

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

@@ -46,6 +46,6 @@ None.
 
 ## Maintenance
 
-1. Run `npm run conformance:update` to reconcile the dated fixture with upstream.
+1. Run `npm run conformance:update:wg17` 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.
+3. Run `node test/run-wg17.mjs` and keep this generated status page synchronized.

package/test/neumerkel.mjs

@@ -59,8 +59,8 @@ async function fetchOne(source) {
   } 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.',
+      'The canonical conformance gate requires network access; use npm test -- --offline ' +
+      'for a network-free local run or node test/run-neumerkel.mjs --cached to reproduce the last live fetch.',
       { cause: error },
     );
   }
@@ -88,7 +88,7 @@ async function fetchOne(source) {
 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`);
+    throw new Error(`Neumerkel cache is incomplete: missing ${path.relative(packageRoot, filename)}; run node test/run-neumerkel.mjs online first`);
   }
   const bytes = new Uint8Array(fs.readFileSync(filename));
   return {
@@ -476,9 +476,9 @@ export function formatNeumerkelMarkdown({ summary }) {
     'Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under',
     'Git-ignored `.cache/neumerkel/` for local inspection/reproduction and are intentionally not committed.',
     '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',
+    'upstream with `node test/run-neumerkel.mjs --update-report`, or sync the exact successful',
+    'snapshot already fetched by `npm test` with `node test/run-neumerkel.mjs --cached --update-report`.',
+    '`node test/run-neumerkel.mjs --cached --verify-report` verifies the tracked report against that last',
     'successful live snapshot without fetching upstream a second time.',
     '',
   );

package/test/regression/cases-documentation-sync.mjs

@@ -649,7 +649,10 @@ ${profile}`;
         const publishIndex = publishWorkflow.indexOf('run: npm publish');
         assertEqual(testIndex >= 0 && testIndex < publishIndex, true, 'publish workflow test gate');
         assertEqual(packIndex >= 0 && packIndex < publishIndex, true, 'publish workflow package gate');
-        assertEqual(pkg.scripts?.['test:openrulebench'], 'node test/run-openrulebench.mjs', 'OpenRuleBench test script');
+        assertArrayEqual(Object.keys(pkg.scripts).sort(), ['benchmark', 'conformance:update:wg17', 'generate', 'postversion', 'preversion', 'test'], 'small npm command surface');
+        assertEqual(pkg.scripts.test, 'node test/run-all.mjs', 'full release gate');
+        const runner = fs.readFileSync(path.join(packageRoot, 'test', 'run-all.mjs'), 'utf8');
+        assertIncludes(runner, 'runOpenRuleBenchChecks(reporter)', 'OpenRuleBench remains in release gate');
       },
     },
     {

package/test/regression/cases-regression.mjs

@@ -28,6 +28,18 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'top level never mints a generated variable name that collides with a query variable\'s own name (issue #108)',
+      run: () => {
+        const result = runCli([], { input: 'length(L,1),_A=99.\nhalt.\n' });
+        assertEqual(result.status, 0, result.stderr);
+        // `_A` is a real query variable here, not the top level's own first
+        // generated name. Printing the anonymous variable inside L as `_A` as
+        // well would misleadingly suggest it is the same variable as the
+        // query's own `_A`, which is bound to 99 and unrelated to L.
+        assertIncludes(result.stdout, '?-    L = [_B], _A = 99.\n', 'generated name skips the query\'s own _A');
+      },
+    },
     {
       name: 'REPL current_input/1 and current_output/1 fail on closed stream handles (issue #107)',
       run: () => {

package/test/run-neumerkel-tests.mjs

@@ -123,17 +123,13 @@ 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')) {
+    const releaseSteps = String(scripts.preversion ?? '').split(' && ');
+    if (releaseSteps[0] !== 'npm test' || releaseSteps[1] !== 'node test/run-neumerkel.mjs --cached --update-report') {
       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');
+    if (releaseSteps[2] !== 'node test/run-conformance-report.mjs conformance-report.md' ||
+        releaseSteps[3] !== 'git add test/conformance/NEUMERKEL-LATEST.md conformance-report.md' || releaseSteps.length !== 4) {
+      throw new Error('preversion must generate and stage both reports without another fetch');
     }
   });
 

package/test/run-neumerkel.mjs

@@ -29,7 +29,7 @@ function parseArgs(argv) {
 
 function printHelp() {
   process.stdout.write(
-    'Usage: npm run test:neumerkel -- [--cached] [--source-dir DIR] [--verify-report] [--update-report]\n\n' +
+    'Usage: node test/run-neumerkel.mjs [--cached] [--source-dir DIR] [--verify-report] [--update-report]\n\n' +
     'Default: fetch all seven current Neumerkel conformity sources live and run\n' +
     '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' +
@@ -54,7 +54,7 @@ export async function runNeumerkel(reporter, options = {}) {
     if (committed !== result.reportText) {
       const message =
         `tracked Neumerkel report is stale: ${relativeReportPath}\n` +
-        'Run npm run conformance:update:neumerkel and commit the updated report.';
+        'Run node test/run-neumerkel.mjs --update-report and commit the updated report.';
       if (effective.verifyReport) throw new Error(message);
       reporter.stdout.write(`WARN ${message}\n`);
     } else {

package/the-art-of-eyeprolog.md

@@ -7034,7 +7034,7 @@ library dependency should be explicit. `--iso-strict` always disables EyeProlog
 library autoloading, so strict ISO execution never gains procedures from this
 implementation convenience.
 
-`-w` / `--warnings` reports explicit dependencies on non-profile libraries and calls to non-profile predicates from otherwise common modules. `--portable` turns those diagnostics into a failing run, making the conservative profile suitable for continuous integration. Cross-engine portability can be exercised with `npm run test:interop` when EyeProlog, Trealla, and Scryer are installed.
+`-w` / `--warnings` reports explicit dependencies on non-profile libraries and calls to non-profile predicates from otherwise common modules. `--portable` turns those diagnostics into a failing run, making the conservative profile suitable for continuous integration. Cross-engine portability can be exercised with `node test/run-interop.mjs` when EyeProlog, Trealla, and Scryer are installed.
 
 ### Specialized library implementation notes
 
@@ -10339,7 +10339,7 @@ hand.
 Run all 210 normal answer goldens and the 61 selected proof goldens with:
 
 ```sh
-npm run test:examples
+node test/run-examples.mjs
 ```
 
 Run the complete conformance, regression, example, and proof corpus
@@ -10354,8 +10354,8 @@ and fast:
 
 ```sh
 npm run benchmark
-npm run benchmark:baseline
-npm run benchmark:lips
+npm run benchmark -- --save .benchmarks/baseline.json
+node test/lips-benchmark.mjs
 ```
 
 The benchmark suite contains 19 representative workloads and stores their
@@ -10368,7 +10368,7 @@ warm-up batch, five measured batches are reported as milliseconds per workload
 execution. Naturally long workloads keep a batch size of one.
 
 The classic `examples/bench.pl` workload also has a dedicated LIPS harness.
-`npm run benchmark:lips` follows the 1984 Quintus method more closely than the
+`node test/lips-benchmark.mjs` follows the 1984 Quintus method more closely than the
 generic runner: `dobench/1` and `dodummy/1` execute failure-driven loops inside
 Prolog, the dummy CPU time is subtracted, and the remaining time is converted
 using 496 procedure calls for one reversal of the 30-element list. Node's
@@ -10409,9 +10409,9 @@ lists, terms, atoms, variables, negation, queries, rules, and
 syntax. Separate corpora cover expected errors, warnings, and proofs:
 
 ```sh
-npm run test:conformance
-npm run test:iso
-npm run test:wg17
+node test/run-conformance-all.mjs
+node test/run-iso-strict.mjs
+node test/run-wg17.mjs
 node test/run-conformance-report.mjs
 ```
 
@@ -10452,7 +10452,7 @@ The repository exposes several forms of executable evidence:
 Run the browser contract independently with:
 
 ```sh
-npm run test:playground
+node test/run-playground.mjs
 ```
 
 ### Supported ISO Prolog implementation

package/tools/generate-library-autoload-index.mjs

@@ -97,7 +97,7 @@ const text = `// Generated by tools/generate-library-autoload-index.mjs.\n` +
 if (process.argv.includes('--check')) {
   const current = fs.existsSync(outputFile) ? fs.readFileSync(outputFile, 'utf8') : '';
   if (current !== text) {
-    console.error(`${path.relative(root, outputFile)} is stale; run npm run generate:autoload`);
+    console.error(`${path.relative(root, outputFile)} is stale; run npm run generate`);
     process.exit(1);
   }
   console.log(`${path.relative(root, outputFile)} is up to date`);

package/tools/generate-predicate-reference.mjs

@@ -209,7 +209,7 @@ const wanted = expectedBook(book, generated);
 
 if (process.argv.includes('--check')) {
   if (wanted !== book) {
-    console.error(`${path.relative(root, bookFile)} predicate reference is stale; run npm run generate:reference`);
+    console.error(`${path.relative(root, bookFile)} predicate reference is stale; run npm run generate`);
     process.exit(1);
   }
   console.log(`${path.relative(root, bookFile)} predicate reference is up to date (${surface.indicators.length} predicates)`);

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

@@ -134,9 +134,9 @@ ${untracedIds.length === 0 ? 'None.' : `${formatRanges(untracedIds)}.`}
 
 ## Maintenance
 
-1. Run \`npm run conformance:update\` to reconcile the dated fixture with upstream.
+1. Run \`npm run conformance:update:wg17\` 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.
+3. Run \`node test/run-wg17.mjs\` 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 conformance:update and update the file.\n');
+      process.stderr.write('WG17 syntax status is stale; run npm run conformance:update:wg17 and update the file.\n');
       process.exitCode = 1;
     }
   } else {

package/tools/upgrade-wg17.mjs

@@ -457,7 +457,7 @@ function parseArgs(argv) {
 }
 
 function printHelp() {
-  process.stdout.write(`Usage: npm run conformance:update -- [--check] [--source URL_OR_FILE]\n\n` +
+  process.stdout.write(`Usage: npm run conformance:update:wg17 -- [--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`);
@@ -477,7 +477,7 @@ export async function upgradeWg17({ check = false, source = syntaxSource } = {})
 
   if (check) {
     if (semanticChanges > 0) {
-      process.stderr.write('WG17 snapshot is stale; run npm run conformance:update.\n');
+      process.stderr.write('WG17 snapshot is stale; run npm run conformance:update:wg17.\n');
       process.exitCode = 1;
       return { changed: true, ...reconciliation };
     }
@@ -524,7 +524,7 @@ export async function upgradeWg17({ check = false, source = syntaxSource } = {})
   process.stdout.write(`Updated WG17 snapshot (${fixture.cases.length} cases).\n`);
   if (upstreamAssertions.length > 0) {
     process.stdout.write(
-      `Direct upstream assertions used by test:wg17: ${formatIdList(upstreamAssertions)}\n`,
+      `Direct upstream assertions used by the WG17 runner: ${formatIdList(upstreamAssertions)}\n`,
     );
   }
   return { changed: semanticChanges > 0, upstreamAssertions, ...reconciliation };