eyeprolog 1.3.26 → 1.3.27

package/package.json

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

package/src/iso.js

@@ -1322,6 +1322,7 @@ function* readTermBuiltin({ solver, goal, env }) {
 function defaultTermWriteOptions(mode) {
   if (mode === 'writeq') return { quoted: true, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
   if (mode === 'canonical') return { quoted: true, ignoreOps: true, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
+  if (mode === 'write_term') return { quoted: false, ignoreOps: false, numbervars: false, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
   return { quoted: false, ignoreOps: false, numbervars: true, variableNames: new Map(), compact: true, operatorAtomsAsArgs: true, doubleQuotes: null };
 }
 
@@ -1361,7 +1362,7 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptions(term, env, mode = 'write') {
+function termWriteOptions(term, env, mode = 'write_term') {
   const result = defaultTermWriteOptions(mode);
   for (const option of optionList(term, env)) {
     if (option.type === VAR) throw new PrologError('instantiation_error');

package/src/write.js

@@ -143,6 +143,28 @@ function chooseOperator(term, table) {
   return null;
 }
 
+function startsWithUnsignedNumber(term, env, table, options) {
+  const resolved = deref(term, env);
+  if (resolved.type === NUMBER) return !resolved.name.startsWith('-');
+  if (resolved.type !== COMPOUND || isCons(resolved)) return false;
+  if (options.numbervars && resolved.name === '$VAR' && resolved.arity === 1) {
+    const index = deref(resolved.args[0], env);
+    if (index.type === NUMBER && /^\d+$/.test(index.name) &&
+        writeNumberedVariable(Number(index.name)) != null) {
+      return false;
+    }
+  }
+  const definition = chooseOperator(resolved, table);
+  if (definition == null) return false;
+  if (definition.specifier === 'xf' || definition.specifier === 'yf') {
+    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
+  }
+  if (definition.specifier === 'xfx' || definition.specifier === 'xfy' || definition.specifier === 'yfx') {
+    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
+  }
+  return false;
+}
+
 function printableReadVariableNames(term, env, explicit) {
   const names = new Map(explicit);
   const used = new Set(names.values());
@@ -286,7 +308,15 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
       let text;
       if (specifier === 'fx' || specifier === 'fy') {
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
-        text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+        // A separated `- 1` is still read as the negative number -1.  When
+        // the source term is the unary -/1 compound, parenthesize a positive
+        // numeric-leading argument so writeq/write_term remain read-back safe
+        // (WG17 #135, #183, #215, #216, and #248).
+        if (resolved.name === '-' && startsWithUnsignedNumber(resolved.args[0], env, table, options)) {
+          text = `${token} (${format(resolved.args[0], env, options, table, 1200)})`;
+        } else {
+          text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
+        }
       } else if (specifier === 'xf' || specifier === 'yf') {
         let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
         const childDefinition = chooseOperator(deref(resolved.args[0], env), table);

package/test/conformance/README.md

@@ -72,7 +72,7 @@ Run the Part 1 + Corrigenda strict-core processor gate:
 npm run test:iso-strict
 ```
 
-Run all vendored WG17 conformity matrices independently:
+Run the vendored WG17 conformity matrix independently:
 
 ```sh
 npm run test:wg17
@@ -87,12 +87,15 @@ 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.
+may keep their reviewed exact outcomes as an additional regression lock,
+removed cases disappear, and new or semantically changed cases initially have
+no local snapshot. **Every case is always checked independently against the
+upstream Codex expectation**, so a reviewed EyeProlog outcome can never make a
+non-conforming result pass (the failure mode that previously hid WG17 #227).
+The runner follows the upstream `read(G), G` input protocol, including the
+terminating newline, so stream-sensitive cases such as #270 and #271 exercise
+the characters left after `read/1`. Normal `npm test` remains offline and uses
+only the committed upstream snapshot.
 
 Summarize conformance coverage by category:
 

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

@@ -4,9 +4,10 @@ Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/
 Upstream inventory checked: 2026-08-16
 
 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.
+expected ISO disposition are stored in the offline executable matrix. Every
+case is executed against the upstream Codex expectation. Reviewed exact
+EyeProlog outcomes are additional regression locks and can never override the
+upstream assertion.
 
 ## Current standing
 
@@ -19,8 +20,9 @@ executed directly against the upstream Codex expectation.
 
 The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
 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.
+hook. All 366 executable cases are independently checked against the
+upstream Codex expectation. 365 cases additionally retain exact reviewed
+outcomes for stronger regression checking; 1 case currently relies on the upstream assertion alone.
 
 ## Traceable evidence
 

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

@@ -1308,7 +1308,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- 1",
+            "output": "- (1)",
             "variables": "[]"
           }
         ]
@@ -1340,7 +1340,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- 1 ^ 2",
+            "output": "- (1 ^ 2)",
             "variables": "[]"
           }
         ]
@@ -1532,7 +1532,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- - 1",
+            "output": "- - (1)",
             "variables": "[]"
           }
         ]
@@ -1552,7 +1552,7 @@
             "variables": "[]"
           },
           {
-            "output": "- 1 ~ 2 ~ 3",
+            "output": "- (1 ~ 2 ~ 3)",
             "variables": "[]"
           }
         ]
@@ -1572,7 +1572,7 @@
             "variables": "[]"
           },
           {
-            "output": "- 1 ~ 2",
+            "output": "- (1 ~ 2)",
             "variables": "[]"
           }
         ]
@@ -3162,7 +3162,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "A",
+            "output": "$VAR(0)",
             "variables": "[]"
           }
         ]
@@ -5092,7 +5092,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "- (1 * 2) ^ 3",
+            "output": "- ((1 * 2) ^ 3)",
             "variables": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -54,7 +54,7 @@ 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';
+import { executeWg17Item, matchesUpstreamExpectation, readWg17SyntaxFixture } from './run-wg17.mjs';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..');
@@ -3236,7 +3236,7 @@ function documentationSyncCases() {
       },
     },
     {
-      name: 'WG17 direct upstream assertions are executable without local outcomes',
+      name: 'WG17 upstream expectations independently validate reviewed outcomes',
       run: () => {
         assertEqual(matchesUpstreamExpectation('succeeds', { type: 'success', stages: [] }), true, 'succeeds');
         assertEqual(matchesUpstreamExpectation('fails', { type: 'failure' }), true, 'fails');
@@ -3251,6 +3251,39 @@ function documentationSyncCases() {
           true,
           'observable output',
         );
+        const repeated = {
+          id: 227, input: 'write_canonical(B+B).',
+          outcome: { type: 'success', stages: [{ output: '+(_A,_A)', variables: "['B' = B]" }] },
+        };
+        assertEqual(
+          matchesUpstreamExpectation('e.g. +(_1,_1)', repeated.outcome, repeated),
+          true,
+          'anonymous spelling accepted',
+        );
+        assertEqual(
+          matchesUpstreamExpectation(
+            'e.g. +(_1,_1)',
+            { type: 'success', stages: [{ output: '+(B,B)', variables: "['B' = B]" }] },
+            repeated,
+          ),
+          false,
+          'named-variable spelling rejected',
+        );
+      },
+    },
+    {
+      name: 'WG17 stream-sensitive cases #270 and #271 follow the upstream input protocol',
+      run: () => {
+        const fixture = readWg17SyntaxFixture();
+        const byId = new Map(fixture.cases.map((item) => [item.id, item]));
+        for (const [id, expected] of [[270, "C = ' '"], [271, "C = '%'"]]) {
+          const item = byId.get(id);
+          if (item == null) throw new Error(`missing WG17 #${id}`);
+          assertEqual(item.expected, expected, `WG17 #${id} upstream expectation`);
+          const actual = executeWg17Item(item);
+          assertEqual(matchesUpstreamExpectation(item.expected, actual, item), true, `WG17 #${id} result`);
+          assertEqual(JSON.stringify(actual), JSON.stringify(item.outcome), `WG17 #${id} reviewed outcome`);
+        }
       },
     },
     {

package/test/run-wg17.mjs

@@ -1,13 +1,16 @@
 #!/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.
+// Offline execution of the vendored WG17 conformity-testing syntax matrix.
+// Every case is checked against the upstream Codex expectation. Reviewed
+// exact EyeProlog outcomes are an additional regression lock, never a
+// replacement for the upstream assertion.
 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 { parseTermText } from '../src/parser.js';
+import { variantTerms } from '../src/term.js';
 import { TestReporter, isMainModule } from './test-style.mjs';
 
 const testRoot = path.dirname(fileURLToPath(import.meta.url));
@@ -32,6 +35,9 @@ function capturedStages(stdout) {
 
 function executeFinite(item) {
   try {
+    // Match the upstream protocol: the Query cell plus its terminating newline
+    // is input to read(G), G (and subsequent read/call stages when present).
+    // This is essential for stream-sensitive cases such as #270 and #271.
     const result = run('', {
       isoStrict: true,
       goal: runnerStage(1, item.readCount ?? 16),
@@ -48,7 +54,7 @@ function executeWait(item) {
   const program = Program.parse('', { isoStrict: true });
   const solver = new Solver(program, {
     isoStrict: true,
-    ioOptions: { input: item.input },
+    ioOptions: { input: `${item.input}\n` },
   });
   const stream = solver.io.resolve('user_input');
   let requests = 0;
@@ -63,32 +69,203 @@ function executeWait(item) {
   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.
+    // Returning null models EOF only after EyeProlog has requested the extra
+    // input that the upstream case classifies as "waits".
   }
   return requests === 1 ? { type: 'waits' } : { type: 'did_not_wait', requests };
 }
 
-function canonicalUpstreamExpected(expected) {
-  return String(expected)
+function presentationText(value) {
+  return String(value ?? '')
+    .replace(/&sup[23];/gi, '')
     .replace(/[²³°]/g, '')
     .replace(/\u00a0/g, ' ')
-    .replace(/[ \t\n]+/g, ' ')
+    .replace(/\r\n?/g, '\n')
     .trim();
 }
 
-function observableOutput(actual) {
-  if (actual.type !== 'success') return null;
-  return actual.stages.map(({ output }) => output).join('');
+function canonicalUpstreamExpected(expected) {
+  return presentationText(expected).replace(/[ \t\n]+/g, ' ').trim();
+}
+
+function bindingAnswer(text) {
+  let value = String(text ?? '').trim();
+  if (value === '[]') return '';
+  if (value.startsWith('[') && value.endsWith(']')) value = value.slice(1, -1);
+  return value.replace(/'([A-Z_][A-Za-z0-9_]*)'\s*=/g, '$1 =');
+}
+
+function observableCandidates(actual) {
+  if (actual.type !== 'success') return [];
+  const outputs = actual.stages.map(({ output }) => output ?? '').filter(Boolean);
+  const bindings = actual.stages.map(({ variables }) => bindingAnswer(variables)).filter(Boolean);
+  const candidates = new Set([...outputs, ...bindings]);
+  if (outputs.length > 0) {
+    candidates.add(outputs.join(''));
+    candidates.add(outputs.join(' '));
+  }
+  if (bindings.length > 0) candidates.add(bindings.join(', '));
+  if (outputs.length > 0 && bindings.length > 0) {
+    candidates.add([...outputs, ...bindings].join(' '));
+    candidates.add(`${outputs.join('')} ${bindings.join(', ')}`);
+  }
+  return [...candidates].filter(Boolean);
+}
+
+function stripLayoutOutsideQuotes(text) {
+  const source = presentationText(text);
+  let output = '';
+  let quote = null;
+  for (let index = 0; index < source.length; index++) {
+    const ch = source[index];
+    if (quote != null) {
+      output += ch;
+      if (ch === '\\' && index + 1 < source.length) {
+        output += source[++index];
+        continue;
+      }
+      if (ch === quote) {
+        if (source[index + 1] === quote) output += source[++index];
+        else quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      quote = ch;
+      output += ch;
+    } else if (!/\s/.test(ch)) {
+      output += ch;
+    }
+  }
+  return output.replace(/\.$/, '').replace(/([eE])\+(?=\d)/g, '$1');
+}
+
+function normalizeExampleVariables(text) {
+  const names = new Map();
+  let next = 0;
+  return String(text).replace(/(?<![A-Za-z0-9_])_[A-Za-z0-9]+/g, (name) => {
+    if (!names.has(name)) names.set(name, `_V${++next}`);
+    return names.get(name);
+  });
+}
+
+function unquoteAtomText(text) {
+  const source = text.trim();
+  if (!(source.startsWith("'") && source.endsWith("'"))) return source;
+  let output = '';
+  for (let index = 1; index < source.length - 1; index++) {
+    const ch = source[index];
+    if (ch === "'" && source[index + 1] === "'") {
+      output += "'";
+      index++;
+      continue;
+    }
+    if (ch === '\\' && index + 1 < source.length - 1) {
+      const escaped = source[++index];
+      const symbolic = { a: '\x07', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v' };
+      output += symbolic[escaped] ?? escaped;
+      continue;
+    }
+    output += ch;
+  }
+  return output;
+}
+
+function splitOperatorNames(text) {
+  const source = text.trim();
+  if (!source.startsWith('[')) return [unquoteAtomText(source)];
+  const body = source.slice(1, -1);
+  const names = [];
+  let quote = false;
+  let start = 0;
+  for (let index = 0; index <= body.length; index++) {
+    const ch = body[index];
+    if (quote) {
+      if (ch === "'" && body[index + 1] === "'") index++;
+      else if (ch === "'") quote = false;
+      continue;
+    }
+    if (ch === "'") {
+      quote = true;
+      continue;
+    }
+    if (ch === ',' || index === body.length) {
+      names.push(unquoteAtomText(body.slice(start, index)));
+      start = index + 1;
+    }
+  }
+  return names.filter(Boolean);
+}
+
+function operatorDefinitionsFromInput(input) {
+  const definitions = [];
+  const pattern = /\bop\(\s*(\d+)\s*,\s*(fx|fy|xf|yf|xfx|xfy|yfx)\s*,\s*(\[[^\]]*\]|'(?:''|[^'])*'|[^)\s,]+)\s*\)/g;
+  for (const match of String(input ?? '').matchAll(pattern)) {
+    for (const name of splitOperatorNames(match[3])) {
+      definitions.push([Number(match[1]), match[2], name]);
+    }
+  }
+  return definitions;
+}
+
+function termEquivalent(expected, actual, item) {
+  try {
+    const operatorDefinitions = operatorDefinitionsFromInput(item?.input);
+    const options = { isoStrict: true, operatorDefinitions };
+    const left = parseTermText(`${presentationText(expected).replace(/\.$/, '')}.`, options);
+    const right = parseTermText(`${presentationText(actual).replace(/\.$/, '')}.`, options);
+    return variantTerms(left, new Env(), right, new Env());
+  } catch (_) {
+    return false;
+  }
+}
+
+function abbreviatedErrorMatches(expected, actual) {
+  if (actual.type !== 'error') return false;
+  const formal = actual.formal ?? '';
+  const patterns = [
+    [/p\._e\./i, 'permission_error'],
+    [/d\._e\./i, 'domain_error'],
+    [/ex\._e\./i, 'existence_error'],
+    [/rep(?:r)?\._e\.|repr\.\s*err\./i, 'representation_error'],
+  ];
+  return patterns.some(([pattern, prefix]) => pattern.test(expected) && formal.startsWith(prefix));
 }
 
-export function matchesUpstreamExpectation(expectedText, actual) {
+function textExpectationMatches(expectedText, actual, item, example = false) {
+  const candidates = observableCandidates(actual);
+  if (candidates.length === 0) return false;
+  let expected = presentationText(expectedText);
+  if (example) expected = expected.replace(/^e\.g\.\s*/i, '');
+
+  for (const candidate of candidates) {
+    let left = expected;
+    let right = candidate;
+    if (example && /(?<![A-Za-z0-9_])_[A-Za-z0-9]+/.test(left)) {
+      // ISO 7.10.5 requires the generated spelling to be an anonymous-variable
+      // token. Normalise only the choice of suffix/name, not the leading `_`.
+      if (!/(?<![A-Za-z0-9_])_[A-Za-z0-9]+/.test(right)) continue;
+      left = normalizeExampleVariables(left);
+      right = normalizeExampleVariables(right);
+    }
+    if (stripLayoutOutsideQuotes(left) === stripLayoutOutsideQuotes(right)) return true;
+    if (termEquivalent(left, right, item)) return true;
+    if (example) {
+      const expectedNumber = Number(left);
+      const actualNumber = Number(right);
+      if (Number.isFinite(expectedNumber) && Number.isFinite(actualNumber) &&
+          Object.is(expectedNumber, actualNumber)) return true;
+    }
+  }
+  return false;
+}
+
+export function matchesUpstreamExpectation(expectedText, actual, item = {}) {
   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 ?? '');
   }
@@ -96,26 +273,24 @@ export function matchesUpstreamExpectation(expectedText, actual) {
     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 ?? '');
+    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 ?? ''));
   }
+  if (abbreviatedErrorMatches(expected, actual)) return true;
 
-  // 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;
+  if (/\s+or\s+/i.test(expected)) {
+    return expected.split(/\s+or\s+/i)
+      .some((alternative) => matchesUpstreamExpectation(alternative, actual, item));
+  }
+  if (/^e\.g\.\s*/i.test(expected)) return textExpectationMatches(expected, actual, item, true);
+  return textExpectationMatches(expected, actual, item, false);
 }
 
 function usesWaitMatcher(expectedText) {
-  const expected = canonicalUpstreamExpected(expectedText);
-  return /^waits$/i.test(expected);
+  return /^waits$/i.test(canonicalUpstreamExpected(expectedText));
 }
 
 function compactTestText(value, maximum) {
@@ -135,30 +310,34 @@ export function wg17TestDescription(item) {
   return `#${item.id} ${query} -> ${expected}`;
 }
 
+export function executeWg17Item(item) {
+  return usesWaitMatcher(item.expected) || item.outcome?.type === 'waits'
+    ? executeWait(item)
+    : executeFinite(item);
+}
+
 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 = executeWg17Item(item);
 
-  const actual = usesWaitMatcher(item.expected) ? executeWait(item) : executeFinite(item);
-  if (!matchesUpstreamExpectation(item.expected, actual)) {
+  if (!matchesUpstreamExpectation(item.expected, actual, item)) {
     throw new Error(
       `WG17 #${item.id} (${item.expected})\n` +
-      `upstream expectation did not match\n` +
+      `upstream Codex expectation did not match\n` +
       `actual ${JSON.stringify(actual)}`,
     );
   }
+
+  if (item.outcome != null && JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
+    throw new Error(
+      `WG17 #${item.id} (${item.expected})\n` +
+      `reviewed regression outcome changed\n` +
+      `expected ${JSON.stringify(item.outcome)}\n` +
+      `actual   ${JSON.stringify(actual)}`,
+    );
+  }
 }
 
-function readWg17SyntaxFixture() {
+export 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');
@@ -168,6 +347,16 @@ function readWg17SyntaxFixture() {
     if (!Number.isInteger(item.id) || ids.has(item.id)) {
       throw new Error(`invalid or duplicate WG17 syntax id #${item.id}`);
     }
+    if (typeof item.query !== 'string' || typeof item.input !== 'string' || typeof item.expected !== 'string') {
+      throw new Error(`incomplete WG17 syntax fixture row #${item.id}`);
+    }
+    if (item.outcome != null && !matchesUpstreamExpectation(item.expected, item.outcome, item)) {
+      throw new Error(
+        `WG17 #${item.id} reviewed outcome contradicts upstream Codex expectation\n` +
+        `upstream ${JSON.stringify(item.expected)}\n` +
+        `outcome  ${JSON.stringify(item.outcome)}`,
+      );
+    }
     ids.add(item.id);
   }
   return fixture;
@@ -183,10 +372,8 @@ function runWg17Syntax(reporter = new TestReporter()) {
   reporter.sectionTotal('WG17 syntax');
 }
 
-const suites = [runWg17Syntax];
-
 export function runWg17(reporter = new TestReporter()) {
-  for (const runSuite of suites) runSuite(reporter);
+  runWg17Syntax(reporter);
 }
 
 if (isMainModule(import.meta.url)) {

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

@@ -92,9 +92,10 @@ Source: [Conformity Testing I: Syntax](${manifest.source})
 Upstream inventory checked: ${manifest.checkedOn}
 
 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.
+expected ISO disposition are stored in the offline executable matrix. Every
+case is executed against the upstream Codex expectation. Reviewed exact
+EyeProlog outcomes are additional regression locks and can never override the
+upstream assertion.
 
 ## Current standing
 
@@ -107,8 +108,9 @@ executed directly against the upstream Codex expectation.
 
 The matrix runs in strict ISO stream-reader mode as part of \`npm test\`. The
 ${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.
+hook. All ${coveredIds.length} executable cases are independently checked against the
+upstream Codex expectation. ${coveredIds.length - direct} case${coveredIds.length - direct === 1 ? '' : 's'} additionally retain exact reviewed
+outcomes for stronger regression checking; ${direct} case${direct === 1 ? '' : 's'} currently ${direct === 1 ? 'relies' : 'rely'} on the upstream assertion alone.
 
 ## Traceable evidence
 

package/tools/upgrade-wg17.mjs

@@ -364,7 +364,7 @@ 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`);
+    `Codex expectation; existing reviewed exact outcomes remain pinned only as additional regression checks.\n`);
 }
 
 export async function upgradeWg17({ check = false, source = syntaxSource } = {}) {

package/test/run-wg17-syntax.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-// Offline, one-by-one execution of the 366 active WG17 syntax cases. The
-// fixture is a dated snapshot of the public conformity-testing table, so the
-// release gate does not depend on the network or another Prolog system.
-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),
-      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 assertOutcome(item) {
-  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)}`,
-    );
-  }
-}
-
-export function runWg17Syntax(reporter = new TestReporter()) {
-  const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
-  if (fixture.cases.length !== 366) {
-    throw new Error(`WG17 fixture has ${fixture.cases.length} cases instead of 366`);
-  }
-  const ids = new Set(fixture.cases.map(({ id }) => id));
-  if (ids.size !== 366 || ids.has(20) || ids.has(273)) {
-    throw new Error('WG17 fixture identifiers do not match the active upstream inventory');
-  }
-
-  reporter.section('WG17 syntax');
-  for (const item of fixture.cases) reporter.test(`#${item.id}`, () => assertOutcome(item));
-  reporter.sectionTotal('WG17 syntax');
-}
-
-if (isMainModule(import.meta.url)) {
-  const reporter = new TestReporter();
-  try {
-    runWg17Syntax(reporter);
-    reporter.totalLine();
-  } catch (_) {
-    process.exitCode = 1;
-  }
-}