eyeprolog 1.2.30 → 1.2.32

package/README.md

@@ -105,8 +105,9 @@ modules, DCGs, quads, libraries, proofs, and the other documented extensions.
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
 The separate [WG17 syntax ledger](test/conformance/WG17-SYNTAX-STATUS.md)
-records executable dispositions for all 366 active upstream syntax cases
-(100% traced) and runs as part of `npm test`.
+records executable dispositions for the vendored active upstream WG17 syntax
+cases and runs as part of `npm test`. Reviewed cases can pin exact outcomes;
+newly upgraded cases run directly against the upstream Codex expectation.
 EyeProlog does not yet claim independent certification or closure of every
 normative Part 1 requirement.
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.30",
+  "version": "1.2.32",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,10 +50,12 @@
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
-    "test:wg17-syntax": "node test/run-wg17-syntax.mjs",
+    "test:wg17": "node test/run-wg17.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.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"

package/test/conformance/ISO-COMPLIANCE.md

@@ -18,7 +18,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
-| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the [complete 366-case WG17 syntax matrix](WG17-SYNTAX-STATUS.md). Wider shall-by-shall text-processing audit remains open. |
+| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the [complete vendored WG17 syntax matrix](WG17-SYNTAX-STATUS.md). Wider shall-by-shall text-processing audit remains open. |
 | 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. A normative goal-semantics ledger is still being expanded. |
 | 5.1(c) reject nonconforming text/read-terms | audit | Dedicated syntax-error cases and strict-core extension rejection. Exhaustive lexical rejection coverage remains open. |
 | 5.1(d) document permitted variations | audit | Major implementation-defined choices are documented in *The Art of EyeProlog*. Every occurrence of “implementation defined/dependent/specific” in Part 1 still needs a final documentation cross-check. |
@@ -30,7 +30,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete 366-case WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, and writer/read-back regressions. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, and writer/read-back regressions. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. Public/private and multi-text requirements still need complete mapping. |
@@ -75,7 +75,7 @@ A release intended to advance ISO conformance must pass all of:
 npm test
 npm run test:iso-strict
 npm run test:conformance
-npm run test:wg17-syntax
+npm run test:wg17
 ```
 
 The unified `npm test` gate includes the strict-core suite. Expected conformance

package/test/conformance/README.md

@@ -10,7 +10,7 @@ and proof output test the behavior of the JavaScript implementation.
 [ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
 corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
 executable cases. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
-complete one-to-one trace for all 366 active upstream syntax cases.
+complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
@@ -69,12 +69,28 @@ Run the Part 1 + Corrigenda strict-core processor gate:
 npm run test:iso-strict
 ```
 
-Run the complete WG17 syntax matrix independently:
+Run all vendored WG17 conformity matrices independently:
 
 ```sh
-npm run test:wg17-syntax
+npm run test:wg17
 ```
 
+Refresh the WG17 snapshot from the TU Wien conformity tables before a release
+or whenever upstream changes:
+
+```sh
+npm run wg17:upgrade
+npm run test:wg17
+```
+
+`wg17:upgrade` reconciles the upstream inventory by identifier: unchanged cases
+keep their reviewed exact outcomes, removed cases disappear, and new or
+semantically changed cases are executed directly against the upstream Codex
+expectation. This means `npm run test:wg17` can test an upgraded snapshot
+immediately without first copying EyeProlog's current behaviour into an
+expected result. Normal `npm test` remains offline and uses only the committed
+snapshot.
+
 Summarize conformance coverage by category:
 
 ```sh

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

@@ -1,12 +1,12 @@
 # WG17 syntax traceability status
 
 Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)  
-Upstream inventory checked: 2026-08-15
+Upstream inventory checked: 2026-08-16
 
-This ledger counts an upstream case only when its WG17 identifier, query,
-expected ISO disposition, and observed EyeProlog outcome are stored in the
-offline executable matrix. Semantically similar parser tests are not inferred
-as coverage.
+This ledger counts an upstream case when its WG17 identifier, query, and
+expected ISO disposition are stored in the offline executable matrix. Existing
+cases may pin an exact reviewed EyeProlog outcome; newly upgraded cases are
+executed directly against the upstream Codex expectation.
 
 ## Current standing
 
@@ -18,15 +18,15 @@ as coverage.
 | Deleted upstream identifiers | #20, #273 |
 
 The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
-three upstream `waits` cases are checked through EyeProlog's interactive input
-hook; the other 363 cases are checked for their exact stored
-success output, bindings, failure, or ISO error category.
+3 upstream `waits` cases are checked through EyeProlog's interactive input
+hook. 1 case uses the upstream Codex expectation directly; the remaining
+365 cases retain exact stored outcomes for stronger regression checking.
 
 ## Traceable evidence
 
 | Executable evidence | Referenced IDs | WG17 cases |
 | --- | ---: | --- |
-| [complete offline executable matrix](../run-wg17-syntax.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
+| [complete offline executable matrix](../run-wg17.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
 
 The evidence groups overlap. Their union is **366** active cases:
 #1–#19, #21–#272, #274–#368.
@@ -37,6 +37,6 @@ None.
 
 ## Maintenance
 
-1. Refresh the dated fixture when the upstream table changes.
-2. Review any changed ISO expectation before updating an observed snapshot.
-3. Keep this generated status page synchronized in the release gate.
+1. Run `npm run wg17:upgrade` 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/conformance/wg17-syntax-cases.json

@@ -1,6 +1,6 @@
 {
   "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
-  "checkedOn": "2026-08-15",
+  "checkedOn": "2026-08-16",
   "protocol": "Each query is read and executed in strict ISO mode; /**/ rows reuse the preceding setup.",
   "cases": [
     {
@@ -5551,14 +5551,13 @@
     },
     {
       "id": 368,
-      "query": "Finis ().",
-      "input": "Finis ().",
+      "query": "writeq(?).",
+      "input": "writeq(?).",
       "readCount": 1,
-      "expected": "syntax err.",
-      "outcome": {
-        "type": "error",
-        "formal": "syntax_error(read_term)"
-      }
+      "expected": "?",
+      "assertion": "upstream"
     }
-  ]
+  ],
+  "sourceRevision": "1.300",
+  "sourceSha256": "d7ca05e90cfafe786d5edca4783e691a356a35508c50b62f5a99bd9057e2cd05"
 }

package/test/conformance/wg17-syntax-coverage.json

@@ -1,18 +1,21 @@
 {
   "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
-  "checkedOn": "2026-08-15",
+  "checkedOn": "2026-08-16",
   "upstream": {
     "firstId": 1,
     "lastId": 368,
-    "deletedIds": [20, 273],
+    "deletedIds": [
+      20,
+      273
+    ],
     "activeCases": 366
   },
   "evidence": [
     {
       "name": "complete offline executable matrix",
       "path": "test/conformance/wg17-syntax-cases.json",
-      "link": "../run-wg17-syntax.mjs",
-      "ids": "all-active"
+      "link": "../run-wg17.mjs",
+      "ids": "all-executable"
     }
   ]
 }

package/test/run-all.mjs

@@ -9,14 +9,14 @@ import { runIsoStrict } from './run-iso-strict.mjs';
 import { runPlayground } from './run-playground.mjs';
 import { runExamples } from './run-examples.mjs';
 import { runBookExamples } from './run-book-examples.mjs';
-import { runWg17Syntax } from './run-wg17-syntax.mjs';
+import { runWg17 } from './run-wg17.mjs';
 
 const reporter = new TestReporter();
 
 try {
   runConformance(reporter);
   runIsoStrict(reporter);
-  runWg17Syntax(reporter);
+  runWg17(reporter);
   runRegression(reporter);
   await runPlayground(reporter);
   runExamples(reporter);

package/test/run-regression.mjs

@@ -46,6 +46,8 @@ import { buildConformanceReport, formatConformanceReport } from './run-conforman
 import { proofExamples } from './run-examples.mjs';
 import { goalsFromSource } from './goal-metadata.mjs';
 import { renderWg17SyntaxStatus } from '../tools/report-wg17-syntax-coverage.mjs';
+import { parseWg17SyntaxTable } from '../tools/upgrade-wg17.mjs';
+import { matchesUpstreamExpectation } from './run-wg17.mjs';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..');
@@ -2166,6 +2168,49 @@ function documentationSyncCases() {
         assertEqual(fs.readFileSync(filename, 'utf8'), renderWg17SyntaxStatus(), 'WG17 syntax status');
       },
     },
+    {
+      name: 'WG17 upgrader accepts omitted HTML table end tags',
+      run: () => {
+        // HTML permits </td> and </tr> to be omitted. TU Wien uses this
+        // compact form, so the upgrader must not depend on explicit closes.
+        const rows = Array.from({ length: 120 }, (_, index) =>
+          `<tr><td>${index + 1}<td><code>write(${index + 1}).</code><td>ok`).join('\n');
+        const html = `<table><tr><th>#<th>Query<th>Codex${rows}</table>`;
+        const parsed = parseWg17SyntaxTable(html);
+        assertEqual(parsed.length, 120, 'parsed row count');
+        assertEqual(parsed[0].id, 1, 'first id');
+        assertEqual(parsed[0].query, 'write(1).', 'first query');
+        assertEqual(parsed.at(-1).id, 120, 'last id');
+      },
+    },
+    {
+      name: 'WG17 upgrader normalizes presentation non-breaking spaces',
+      run: () => {
+        const rows = Array.from({ length: 120 }, (_, index) =>
+          `<tr><td>${index + 1}<td>set_prolog_flag(&nbsp;double_quotes,chars).<td>succeeds`).join('\n');
+        const html = `<table><tr><th>#<th>Query<th>Codex${rows}</table>`;
+        const parsed = parseWg17SyntaxTable(html);
+        assertEqual(parsed[0].query, 'set_prolog_flag( double_quotes,chars).', 'normalized query');
+      },
+    },
+    {
+      name: 'WG17 direct upstream assertions are executable without local outcomes',
+      run: () => {
+        assertEqual(matchesUpstreamExpectation('succeeds', { type: 'success', stages: [] }), true, 'succeeds');
+        assertEqual(matchesUpstreamExpectation('fails', { type: 'failure' }), true, 'fails');
+        assertEqual(matchesUpstreamExpectation('waits', { type: 'waits' }), true, 'waits');
+        assertEqual(
+          matchesUpstreamExpectation('syntax err.', { type: 'error', formal: 'syntax_error(read_term)' }),
+          true,
+          'syntax error',
+        );
+        assertEqual(
+          matchesUpstreamExpectation("'a b'", { type: 'success', stages: [{ output: "'a b'", variables: '[]' }] }),
+          true,
+          'observable output',
+        );
+      },
+    },
     {
       name: 'book builtins match runtime registry',
       run: () => assertArrayEqual(bookBuiltinNames(), registeredBuiltinNames(), 'builtins'),

package/test/run-wg17.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// Aggregate all vendored WG17 conformity suites behind one stable entry point.
+// The current upstream conformity table is syntax-focused; additional WG17
+// suites can be added here without changing npm/CI commands.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  Env, Program, Solver, parseGoalText, run,
+} from '../src/index.js';
+import { TestReporter, isMainModule } from './test-style.mjs';
+
+const testRoot = path.dirname(fileURLToPath(import.meta.url));
+const fixturePath = path.join(testRoot, 'conformance', 'wg17-syntax-cases.json');
+
+function runnerStage(index, maximum) {
+  if (index > maximum) return `write('\\n<WG17-COMPLETE>')`;
+  return `read_term(G${index}, [variable_names(V${index})]), ` +
+    `(G${index} == end_of_file -> write('\\n<WG17-COMPLETE>') ; (` +
+    `write('\\n<WG17-BEGIN-${index}>'), call(G${index}), ` +
+    `write('<WG17-VARS>'), writeq(V${index}), write('<WG17-END>'), ` +
+    `${runnerStage(index + 1, maximum)}))`;
+}
+
+function capturedStages(stdout) {
+  const complete = stdout.indexOf('<WG17-COMPLETE>');
+  if (complete < 0) return null;
+  const captured = stdout.slice(0, complete);
+  return [...captured.matchAll(/<WG17-BEGIN-(\d+)>([\s\S]*?)<WG17-VARS>([\s\S]*?)<WG17-END>/g)]
+    .map((match) => ({ output: match[2], variables: match[3] }));
+}
+
+function executeFinite(item) {
+  try {
+    const result = run('', {
+      isoStrict: true,
+      goal: runnerStage(1, item.readCount ?? 16),
+      ioOptions: { input: `${item.input}\n` },
+    });
+    const stages = capturedStages(result.stdout);
+    return stages == null ? { type: 'failure' } : { type: 'success', stages };
+  } catch (error) {
+    return { type: 'error', formal: error?.formal ?? null };
+  }
+}
+
+function executeWait(item) {
+  const program = Program.parse('', { isoStrict: true });
+  const solver = new Solver(program, {
+    isoStrict: true,
+    ioOptions: { input: item.input },
+  });
+  const stream = solver.io.resolve('user_input');
+  let requests = 0;
+  stream.interactiveReadTerm = () => {
+    requests++;
+    return null;
+  };
+  const goal = parseGoalText('read_term(G, [])', {
+    isoStrict: true,
+    operatorDefinitions: [...program.operators.values()],
+  });
+  try {
+    [...solver.solve([goal], new Env(), 0)];
+  } catch (_) {
+    // Returning null from the hook models EOF after EyeProlog has asked the
+    // interactive source for the continuation that the upstream case awaits.
+  }
+  return requests === 1 ? { type: 'waits' } : { type: 'did_not_wait', requests };
+}
+
+function canonicalUpstreamExpected(expected) {
+  return String(expected)
+    .replace(/[²³°]/g, '')
+    .replace(/\u00a0/g, ' ')
+    .replace(/[ \t\n]+/g, ' ')
+    .trim();
+}
+
+function observableOutput(actual) {
+  if (actual.type !== 'success') return null;
+  return actual.stages.map(({ output }) => output).join('');
+}
+
+export function matchesUpstreamExpectation(expectedText, actual) {
+  const expected = canonicalUpstreamExpected(expectedText);
+
+  if (/^waits$/i.test(expected)) return actual.type === 'waits';
+  if (/^succeeds(?:\b|$)/i.test(expected)) return actual.type === 'success';
+  if (/^fails(?:\b|$)/i.test(expected)) return actual.type === 'failure';
+
+  if (/^syntax\s*err\.?$/i.test(expected)) {
+    return actual.type === 'error' && /^syntax_error\(/.test(actual.formal ?? '');
+  }
+  if (/^repr\.\s*err\.?$/i.test(expected)) {
+    return actual.type === 'error' && /^representation_error\(/.test(actual.formal ?? '');
+  }
+  if (/^syntax\/repr\.\s*err\.?$/i.test(expected)) {
+    return actual.type === 'error' &&
+      /^(?:syntax_error|representation_error)\(/.test(actual.formal ?? '');
+  }
+  if (/^syntax\s*err\.\/waits$/i.test(expected)) {
+    return actual.type === 'waits' ||
+      (actual.type === 'error' && /^syntax_error\(/.test(actual.formal ?? ''));
+  }
+
+  // Most new WG17 rows are observable write/read examples.  For those, the
+  // Codex cell itself is the expected output, so no hand-written local
+  // outcome is needed before the case can be executed.
+  const output = observableOutput(actual);
+  if (output != null && canonicalUpstreamExpected(output) === expected) return true;
+
+  return false;
+}
+
+function usesWaitMatcher(expectedText) {
+  const expected = canonicalUpstreamExpected(expectedText);
+  return /^waits$/i.test(expected);
+}
+
+function compactTestText(value, maximum) {
+  const text = String(value ?? '')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t')
+    .replace(/[ ]+/g, ' ')
+    .trim();
+  if (text.length <= maximum) return text;
+  return `${text.slice(0, maximum - 1)}…`;
+}
+
+export function wg17TestDescription(item) {
+  const query = compactTestText(item.query ?? item.input, 56);
+  const expected = compactTestText(item.expected, 28);
+  return `#${item.id} ${query} -> ${expected}`;
+}
+
+function assertOutcome(item) {
+  if (item.outcome != null) {
+    const actual = item.outcome.type === 'waits' ? executeWait(item) : executeFinite(item);
+    if (JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
+      throw new Error(
+        `WG17 #${item.id} (${item.expected})\n` +
+        `expected ${JSON.stringify(item.outcome)}\n` +
+        `actual   ${JSON.stringify(actual)}`,
+      );
+    }
+    return;
+  }
+
+  const actual = usesWaitMatcher(item.expected) ? executeWait(item) : executeFinite(item);
+  if (!matchesUpstreamExpectation(item.expected, actual)) {
+    throw new Error(
+      `WG17 #${item.id} (${item.expected})\n` +
+      `upstream expectation did not match\n` +
+      `actual ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+function readWg17SyntaxFixture() {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+  if (!Array.isArray(fixture.cases) || fixture.cases.length === 0) {
+    throw new Error('WG17 syntax fixture has no cases');
+  }
+  const ids = new Set();
+  for (const item of fixture.cases) {
+    if (!Number.isInteger(item.id) || ids.has(item.id)) {
+      throw new Error(`invalid or duplicate WG17 syntax id #${item.id}`);
+    }
+    ids.add(item.id);
+  }
+  return fixture;
+}
+
+function runWg17Syntax(reporter = new TestReporter()) {
+  const fixture = readWg17SyntaxFixture();
+
+  reporter.section('WG17 syntax');
+  for (const item of fixture.cases) {
+    reporter.test(wg17TestDescription(item), () => assertOutcome(item));
+  }
+  reporter.sectionTotal('WG17 syntax');
+}
+
+const suites = [runWg17Syntax];
+
+export function runWg17(reporter = new TestReporter()) {
+  for (const runSuite of suites) runSuite(reporter);
+}
+
+if (isMainModule(import.meta.url)) {
+  const reporter = new TestReporter();
+  try {
+    runWg17(reporter);
+    reporter.totalLine();
+  } catch (error) {
+    process.stderr.write(`${error?.stack ?? error}\n`);
+    process.exitCode = 1;
+  }
+}

package/the-art-of-eyeprolog.md

@@ -7060,7 +7060,9 @@ syntax. Separate corpora cover expected errors, warnings, and proofs:
 ```sh
 npm run test:conformance
 npm run test:iso-strict
-npm run test:wg17-syntax
+npm run test:wg17
+# Refresh the vendored TU Wien WG17 inventory when upstream changes:
+npm run wg17:upgrade
 node test/run-conformance-report.mjs
 ```
 
@@ -7069,8 +7071,9 @@ Part 1 conformance audit. It distinguishes implemented/tested families from
 requirements whose normative `shall` clauses, option combinations, or error
 precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
-`test/conformance/WG17-SYNTAX-STATUS.md` separately traces all 366 active
-upstream syntax cases to exact strict-reader outcomes, with no untraced case.
+`test/conformance/WG17-SYNTAX-STATUS.md` separately traces the vendored active
+upstream syntax cases. Reviewed cases can pin exact strict-reader outcomes, while
+newly upgraded cases execute directly against the upstream Codex expectation.
 
 The complete suite must pass before release. The file-based conformance corpus
 contains 791 cases, including 386 focused ISO

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

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const manifestPath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-coverage.json');
 const statusPath = path.join(packageRoot, 'test', 'conformance', 'WG17-SYNTAX-STATUS.md');
+const fixturePath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-cases.json');
 
 export function readWg17SyntaxCoverage() {
   const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
@@ -25,10 +26,12 @@ export function readWg17SyntaxCoverage() {
   const evidenceEntries = [];
   for (const evidence of manifest.evidence) {
     if (!evidence.name || !evidence.path || !evidence.link ||
-        (!Array.isArray(evidence.ids) && evidence.ids !== 'all-active')) {
+        (!Array.isArray(evidence.ids) && !['all-active', 'all-reviewed', 'all-executable'].includes(evidence.ids))) {
       throw new Error('invalid WG17 evidence entry');
     }
-    const evidenceIds = evidence.ids === 'all-active' ? activeIds : evidence.ids;
+    const evidenceIds = evidence.ids === 'all-active' ? activeIds :
+      ['all-reviewed', 'all-executable'].includes(evidence.ids)
+        ? executableWg17Ids(evidence.path, active) : evidence.ids;
     const evidenceFilename = path.join(packageRoot, evidence.path);
     if (!fs.existsSync(evidenceFilename)) throw new Error(`missing WG17 evidence file ${evidence.path}`);
     const referenced = referencedWg17Ids(fs.readFileSync(evidenceFilename, 'utf8'));
@@ -52,6 +55,16 @@ export function readWg17SyntaxCoverage() {
   };
 }
 
+
+function executableWg17Ids(relativePath, active) {
+  const filename = path.join(packageRoot, relativePath);
+  if (path.resolve(filename) !== path.resolve(fixturePath)) return [];
+  const fixture = JSON.parse(fs.readFileSync(filename, 'utf8'));
+  return fixture.cases
+    .filter((item) => typeof item.expected === 'string' && item.expected.length > 0 && active.has(item.id))
+    .map(({ id }) => id);
+}
+
 function referencedWg17Ids(source) {
   const ids = new Set();
   for (const match of source.matchAll(/#(\d+)(?:-(\d+))?/g)) {
@@ -65,6 +78,10 @@ function referencedWg17Ids(source) {
 
 export function renderWg17SyntaxStatus() {
   const { manifest, evidenceEntries, activeIds, coveredIds, untracedIds } = readWg17SyntaxCoverage();
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+  const waits = fixture.cases.filter((item) =>
+    item.outcome?.type === 'waits' || (item.outcome == null && /^waits$/i.test(item.expected ?? ''))).length;
+  const direct = fixture.cases.filter((item) => item.outcome == null).length;
   const percentage = (100 * coveredIds.length / activeIds.length).toFixed(1);
   const evidenceRows = evidenceEntries.map((evidence) =>
     `| [${evidence.name}](${evidence.link}) | ${evidence.ids.length} | ${formatRanges(evidence.ids)} |`);
@@ -74,10 +91,10 @@ export function renderWg17SyntaxStatus() {
 Source: [Conformity Testing I: Syntax](${manifest.source})  
 Upstream inventory checked: ${manifest.checkedOn}
 
-This ledger counts an upstream case only when its WG17 identifier, query,
-expected ISO disposition, and observed EyeProlog outcome are stored in the
-offline executable matrix. Semantically similar parser tests are not inferred
-as coverage.
+This ledger counts an upstream case when its WG17 identifier, query, and
+expected ISO disposition are stored in the offline executable matrix. Existing
+cases may pin an exact reviewed EyeProlog outcome; newly upgraded cases are
+executed directly against the upstream Codex expectation.
 
 ## Current standing
 
@@ -89,9 +106,9 @@ as coverage.
 | Deleted upstream identifiers | ${formatRanges(manifest.upstream.deletedIds)} |
 
 The matrix runs in strict ISO stream-reader mode as part of \`npm test\`. The
-three upstream \`waits\` cases are checked through EyeProlog's interactive input
-hook; the other ${activeIds.length - 3} cases are checked for their exact stored
-success output, bindings, failure, or ISO error category.
+${waits} upstream \`waits\` case${waits === 1 ? '' : 's'} ${waits === 1 ? 'is' : 'are'} checked through EyeProlog's interactive input
+hook. ${direct} case${direct === 1 ? '' : 's'} use${direct === 1 ? 's' : ''} the upstream Codex expectation directly; the remaining
+${coveredIds.length - direct} case${coveredIds.length - direct === 1 ? '' : 's'} retain exact stored outcomes for stronger regression checking.
 
 ## Traceable evidence
 
@@ -108,9 +125,9 @@ ${untracedIds.length === 0 ? 'None.' : `${formatRanges(untracedIds)}.`}
 
 ## Maintenance
 
-1. Refresh the dated fixture when the upstream table changes.
-2. Review any changed ISO expectation before updating an observed snapshot.
-3. Keep this generated status page synchronized in the release gate.
+1. Run \`npm run wg17:upgrade\` 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.
 `;
 }
 
@@ -132,7 +149,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-syntax and update the file.\n');
+      process.stderr.write('WG17 syntax status is stale; run npm run report:wg17 and update the file.\n');
       process.exitCode = 1;
     }
   } else {

package/tools/upgrade-wg17.mjs

@@ -0,0 +1,440 @@
+#!/usr/bin/env node
+// Refresh the vendored WG17 conformity fixtures from their public upstream
+// tables. Normal test runs remain fully offline and deterministic.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const syntaxSource = 'https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing';
+const syntaxFixturePath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-cases.json');
+const syntaxCoveragePath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-coverage.json');
+const syntaxStatusPath = path.join(packageRoot, 'test', 'conformance', 'WG17-SYNTAX-STATUS.md');
+
+const namedEntities = new Map([
+  ['amp', '&'], ['lt', '<'], ['gt', '>'], ['quot', '"'], ['apos', "'"],
+  ['nbsp', '\u00a0'], ['ndash', '–'], ['mdash', '—'], ['minus', '−'],
+  ['hellip', '…'], ['middot', '·'], ['times', '×'], ['laquo', '«'], ['raquo', '»'],
+]);
+
+export function decodeHtmlEntities(text) {
+  return text.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z][a-z0-9]+);/gi, (whole, entity) => {
+    if (entity[0] === '#') {
+      const hex = entity[1]?.toLowerCase() === 'x';
+      const value = Number.parseInt(entity.slice(hex ? 2 : 1), hex ? 16 : 10);
+      if (Number.isInteger(value) && value >= 0 && value <= 0x10ffff) return String.fromCodePoint(value);
+      return whole;
+    }
+    return namedEntities.get(entity.toLowerCase()) ?? whole;
+  });
+}
+
+function withoutPresentationMarkup(html) {
+  return html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<sup\b[^>]*>[\s\S]*?<\/sup>/gi, '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/(?:p|div|pre|li|blockquote)>/gi, '\n')
+    .replace(/<(?:p|div|pre|li|blockquote)\b[^>]*>/gi, '')
+    .replace(/<[^>]+>/g, '');
+}
+
+export function htmlCellText(html) {
+  return decodeHtmlEntities(withoutPresentationMarkup(html))
+    .replace(/\r\n?/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function deletedRow(rowHtml, idCellHtml) {
+  return /<(?:del|s|strike)\b/i.test(idCellHtml) ||
+    /class\s*=\s*["'][^"']*\b(?:deleted|obsolete|removed)\b/i.test(rowHtml);
+}
+
+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
+  // on that. Do not require explicit closing tags here: split on start tags
+  // and let the next cell/row start imply the end of the previous one.
+  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 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 });
+  }
+  return rows;
+}
+
+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*/, '');
+    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(/[ \t\n]+/g, ' ').trim();
+    if (query.length === 0 || expected.length === 0) continue;
+    cases.push({ id, query, expected });
+    seen.add(id);
+  }
+  if (cases.length < 100) {
+    const trCount = [...html.matchAll(/<tr\b/gi)].length;
+    const tdCount = [...html.matchAll(/<t[dh]\b/gi)].length;
+    throw new Error(
+      `only ${cases.length} WG17 syntax rows were found ` +
+      `(saw ${trCount} row starts and ${tdCount} cell starts); upstream HTML format may have changed`,
+    );
+  }
+  return cases;
+}
+
+function canonicalQuery(query) {
+  return String(query).replace(/\r\n?/g, '\n').replace(/\u00a0/g, ' ').trim();
+}
+
+
+function canonicalExpected(expected) {
+  return String(expected).replace(/\s+/g, ' ').trim();
+}
+
+function isLayoutStart(source, index) {
+  if (index >= source.length) return true;
+  const ch = source[index];
+  return /\s/.test(ch) || ch === '%' || (ch === '/' && source[index + 1] === '*');
+}
+
+function firstTermEnd(source) {
+  let quote = null;
+  let lineComment = false;
+  let blockComment = false;
+  let depth = 0;
+
+  for (let index = 0; index < source.length; index++) {
+    const ch = source[index];
+    const next = source[index + 1];
+
+    if (lineComment) {
+      if (ch === '\n') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (ch === '*' && next === '/') {
+        blockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (quote != null) {
+      if (ch === '\\') {
+        index++;
+        continue;
+      }
+      if (ch === quote && next === quote) {
+        index++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+
+    if (ch === '%') {
+      lineComment = true;
+      continue;
+    }
+    if (ch === '/' && next === '*') {
+      blockComment = true;
+      index++;
+      continue;
+    }
+    if (ch === "'" && /\d/.test(source[index - 1] ?? '')) {
+      // Character-code constant such as 0'. or 0'\\n: apostrophe is not a
+      // quoted-atom delimiter. Skip the character (or escaped character).
+      if (next === '\\') index += 2;
+      else index++;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      quote = ch;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{') {
+      depth++;
+      continue;
+    }
+    if (ch === ')' || ch === ']' || ch === '}') {
+      if (depth > 0) depth--;
+      continue;
+    }
+    if (ch === '.' && depth === 0 && isLayoutStart(source, index + 1)) return index + 1;
+  }
+  return -1;
+}
+
+function skipLayoutAndComments(source, start = 0) {
+  let index = start;
+  while (index < source.length) {
+    if (/\s/.test(source[index])) {
+      index++;
+      continue;
+    }
+    if (source[index] === '%') {
+      const newline = source.indexOf('\n', index + 1);
+      if (newline < 0) return source.length;
+      index = newline + 1;
+      continue;
+    }
+    if (source[index] === '/' && source[index + 1] === '*') {
+      const end = source.indexOf('*/', index + 2);
+      if (end < 0) return index;
+      index = end + 2;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+// Return the first complete Prolog term, without its terminating full stop.
+// This is used only to reconstruct the setup denoted by upstream /**/ rows.
+export function firstPrologTerm(source) {
+  const start = skipLayoutAndComments(source, 0);
+  const end = firstTermEnd(source.slice(start));
+  if (end < 0) return source.slice(start).trim().replace(/\.$/, '').trim();
+  return source.slice(start, start + end - 1).trim();
+}
+
+export function countTopLevelTerms(source) {
+  let index = 0;
+  let count = 0;
+  while (true) {
+    index = skipLayoutAndComments(source, index);
+    if (index >= source.length) break;
+    const end = firstTermEnd(source.slice(index));
+    count++;
+    if (end < 0) break;
+    index += end;
+  }
+  return Math.max(1, count);
+}
+
+export function setupInput(query, precedingBaseQuery) {
+  if (!query.includes('/**/')) return query;
+  if (precedingBaseQuery == null) throw new Error(`WG17 query uses /**/ without a preceding setup: ${query}`);
+  const setup = firstPrologTerm(precedingBaseQuery);
+  if (setup.length === 0) throw new Error(`cannot derive WG17 setup from: ${precedingBaseQuery}`);
+  const tail = query.replace('/**/', '');
+  return `(catch((${setup}), _, true) -> true ; true).\n${tail}`;
+}
+
+function reconcileSyntaxCases(upstream, previous) {
+  const previousById = new Map(previous.cases.map((item) => [item.id, item]));
+  const nextCases = [];
+  const added = [];
+  const changed = [];
+  let precedingBaseQuery = null;
+
+  for (const row of upstream) {
+    const old = previousById.get(row.id);
+    const same = old != null &&
+      canonicalQuery(old.query) === canonicalQuery(row.query) &&
+      canonicalExpected(old.expected) === canonicalExpected(row.expected);
+
+    if (same) {
+      nextCases.push(old);
+    } else {
+      const input = setupInput(row.query, precedingBaseQuery);
+      const item = {
+        id: row.id,
+        query: row.query,
+        input,
+        readCount: countTopLevelTerms(input),
+        expected: row.expected,
+        assertion: 'upstream',
+      };
+      nextCases.push(item);
+      if (old == null) added.push(row.id);
+      else changed.push(row.id);
+    }
+
+    if (!row.query.includes('/**/')) precedingBaseQuery = row.query;
+    previousById.delete(row.id);
+  }
+
+  return {
+    cases: nextCases,
+    added,
+    changed,
+    removed: [...previousById.keys()].sort((a, b) => a - b),
+  };
+}
+
+function inventoryFromCases(cases) {
+  const ids = cases.map(({ id }) => id);
+  if (ids.length === 0) throw new Error('WG17 syntax inventory is empty');
+  const firstId = Math.min(...ids);
+  const lastId = Math.max(...ids);
+  const active = new Set(ids);
+  const deletedIds = [];
+  for (let id = firstId; id <= lastId; id++) if (!active.has(id)) deletedIds.push(id);
+  return { firstId, lastId, deletedIds, activeCases: cases.length };
+}
+
+function sourceRevision(html) {
+  const text = htmlCellText(html);
+  const revisions = [...text.matchAll(/\brevision\s+([0-9]+(?:\.[0-9]+)*)/gi)];
+  return revisions.at(-1)?.[1] ?? null;
+}
+
+function dateStamp() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatIdList(ids) {
+  return ids.length === 0 ? 'none' : ids.map((id) => `#${id}`).join(', ');
+}
+
+async function readSource(source) {
+  if (/^https?:\/\//i.test(source)) {
+    const response = await fetch(source, {
+      headers: { 'user-agent': 'EyeProlog-WG17-upgrader/1' },
+      redirect: 'follow',
+    });
+    if (!response.ok) throw new Error(`WG17 fetch failed: ${response.status} ${response.statusText}`);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const header = response.headers.get('content-type') ?? '';
+    return { bytes, html: decodeDocument(bytes, header) };
+  }
+  const filename = path.resolve(source);
+  const bytes = new Uint8Array(fs.readFileSync(filename));
+  return { bytes, html: decodeDocument(bytes, '') };
+}
+
+export function decodeDocument(bytes, contentType = '') {
+  const prefix = Buffer.from(bytes.subarray(0, Math.min(bytes.length, 8192))).toString('latin1');
+  const headerCharset = contentType.match(/charset\s*=\s*["']?([^;"'\s]+)/i)?.[1];
+  const metaCharset = prefix.match(/<meta[^>]+charset\s*=\s*["']?([^"'\s/>;]+)/i)?.[1] ??
+    prefix.match(/<meta[^>]+content\s*=\s*["'][^"']*charset\s*=\s*([^;"'\s>]+)/i)?.[1];
+  const label = headerCharset ?? metaCharset ?? 'utf-8';
+  try {
+    return new TextDecoder(label).decode(bytes);
+  } catch (_) {
+    return new TextDecoder('windows-1252').decode(bytes);
+  }
+}
+
+function parseArgs(argv) {
+  const options = { check: false, source: syntaxSource };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === '--check') options.check = true;
+    else if (arg === '--source') {
+      if (argv[index + 1] == null) throw new Error('--source requires a URL or filename');
+      options.source = 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 wg17:upgrade -- [--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.\n`);
+}
+
+export async function upgradeWg17({ check = false, source = syntaxSource } = {}) {
+  const previous = JSON.parse(fs.readFileSync(syntaxFixturePath, 'utf8'));
+  const { bytes, html } = await readSource(source);
+  const upstream = parseWg17SyntaxTable(html);
+  const reconciliation = reconcileSyntaxCases(upstream, previous);
+  const semanticChanges = reconciliation.added.length + reconciliation.changed.length + reconciliation.removed.length;
+
+  process.stdout.write(`WG17 syntax: ${upstream.length} active upstream cases\n`);
+  process.stdout.write(`  added:   ${formatIdList(reconciliation.added)}\n`);
+  process.stdout.write(`  changed: ${formatIdList(reconciliation.changed)}\n`);
+  process.stdout.write(`  removed: ${formatIdList(reconciliation.removed)}\n`);
+
+  if (check) {
+    if (semanticChanges > 0) {
+      process.stderr.write('WG17 snapshot is stale; run npm run wg17:upgrade.\n');
+      process.exitCode = 1;
+      return { changed: true, ...reconciliation };
+    }
+    process.stdout.write('WG17 snapshot matches the upstream test inventory.\n');
+    return { changed: false, ...reconciliation };
+  }
+
+  const checkedOn = dateStamp();
+  const fixture = {
+    ...previous,
+    source: syntaxSource,
+    checkedOn,
+    sourceRevision: sourceRevision(html),
+    sourceSha256: crypto.createHash('sha256').update(bytes).digest('hex'),
+    protocol: 'Each query is read and executed in strict ISO mode; /**/ rows reuse the preceding setup.',
+    cases: reconciliation.cases,
+  };
+  fs.writeFileSync(syntaxFixturePath, `${JSON.stringify(fixture, null, 2)}\n`);
+
+  const coverage = JSON.parse(fs.readFileSync(syntaxCoveragePath, 'utf8'));
+  coverage.source = syntaxSource;
+  coverage.checkedOn = checkedOn;
+  coverage.upstream = inventoryFromCases(fixture.cases);
+  for (const evidence of coverage.evidence ?? []) {
+    if (['all-active', 'all-reviewed'].includes(evidence.ids)) evidence.ids = 'all-executable';
+    if (evidence.path === 'test/conformance/wg17-syntax-cases.json') evidence.link = '../run-wg17.mjs';
+  }
+  fs.writeFileSync(syntaxCoveragePath, `${JSON.stringify(coverage, null, 2)}\n`);
+
+  // Generate status after the fixture/manifest are synchronized.
+  const { renderWg17SyntaxStatus } = await import('./report-wg17-syntax-coverage.mjs');
+  fs.writeFileSync(syntaxStatusPath, renderWg17SyntaxStatus());
+
+  const upstreamAssertions = fixture.cases
+    .filter((item) => item.outcome == null)
+    .map(({ id }) => id);
+  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`,
+    );
+  }
+  return { changed: semanticChanges > 0, upstreamAssertions, ...reconciliation };
+}
+
+const isMain = process.argv[1] != null && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;
+if (isMain) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) printHelp();
+    else await upgradeWg17(options);
+  } catch (error) {
+    process.stderr.write(`${error?.stack ?? error}\n`);
+    process.exitCode = 1;
+  }
+}

package/why-eyeprolog.md

@@ -20,7 +20,7 @@ syntax.
 EyeProlog implements the Part 1 core together with Technical Corrigenda 1, 2,
 and 3, Part 2 modules, and the Part 3 definite clause grammar specification.
 Its executable conformance matrix and tests document the supported
-behavior, including a complete executable trace of the 366 active WG17 syntax
+behavior, including an executable trace of the vendored active WG17 syntax
 cases. This is extensive implementation evidence, not certification by an
 independent standards body.