eyeprolog 1.3.100 → 1.4.1

package/README.md

@@ -68,7 +68,7 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 - [Symbiotic Knowledge Graphs](examples/deck/symbiotic-knowledge-graphs.md) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
 - [rdf-prolog-roundtrip](https://github.com/eyereasoner/rdf-prolog-roundtrip) — standalone RDF 1.2 ↔ ISO Prolog bridge used by the RDF examples
 - [ISO conformance audit](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
-- [Conformance report](conformance-report.md) — generated public corpus summary
+- [Conformance report](conformance-report.md) — generated executable conformance status and corpus summary
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
 
 ## RDF, Prolog, and symbiotic knowledge graphs

package/conformance-report.md

@@ -1,6 +1,20 @@
 # EyeProlog conformance report
 
-This report summarizes the file-based conformance corpus under `test/conformance/`.
+This report combines an executable external conformance gate with the file-based
+conformance corpus under `test/conformance/`. The executable result is measured
+when this report is generated; it is not inferred from fixture counts.
+
+## Executable conformance status
+
+| Gate | Passed | Total | Status |
+|---|---:|---:|---|
+| WG17 syntax | 366 | 366 | pass |
+
+The WG17 syntax row executes the vendored 366-case conformity-testing matrix
+against EyeProlog's strict ISO reader/writer. A behavior fix such as operator-token
+spelling therefore changes this report even when no corpus file is added or removed.
+
+## File-based corpus inventory
 
 | Category | Positive | Errors | Warnings | Proofs | Total |
 |---|---:|---:|---:|---:|---:|

package/package.json

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

package/src/write.js

@@ -28,6 +28,11 @@ function quotedControlEscape(ch) {
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
+  // `;` is a solo-character name token in ISO 6.4.2/6.5.3, so unlike most
+  // solo characters it is a valid atom without quotes. Keep `|` distinct:
+  // Corrigendum 2 makes the bar token equivalent to atom '|' only while it
+  // is being used as an operator; as an ordinary atom/functor it is quoted.
+  if (name === ';') return false;
   // A lone full stop is the end token, not a graphic atom.  Longer
   // graphic tokens may contain dots and are valid unquoted writeq/1 output
   // (WG17 #371-373: ./*, .*, ...*).  Only a token beginning with /* would
@@ -164,6 +169,10 @@ function writeNumberedVariable(index) {
 }
 
 function operatorName(name) {
+  // Corrigendum 2 adds a dedicated bar token to operator syntax. The atom
+  // itself still needs quoting in functional notation, but operator-form
+  // output must use the unquoted `|` token (WG17 #181/#290).
+  if (name === '|') return '|';
   if (name === '.' || name.startsWith('/*')) return quoteAtom(name);
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return name;
   if (/^[!#$&*+\-./<=>?@^~\\;:]+$/.test(name)) return name;
@@ -274,6 +283,10 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   if (resolved.type === STRING) return writeString(resolved.name);
   if (resolved.type === ATOM) {
     if (!options.quoted) return resolved.name;
+    // Corrigendum 2's bare bar token exists only in operator syntax. It is
+    // not an atom token, so an ordinary atom `|` must remain quoted even when
+    // `|` is currently declared as an operator (for example as f('|')).
+    if (resolved.name === '|') return quoteAtom(resolved.name);
     // Top-level bindings are already delimited by their answer punctuation.
     // Keep valid dotted graphic tokens readable there without weakening the
     // ISO writeq/1 policy tested by WG17 #308.

package/test/conformance/ISO-COMPLIANCE.md

@@ -6,7 +6,7 @@ together with Technical Corrigenda 1:2007, 2:2012, and 3:2017. Detailed
 row-level evidence lives only where it adds information: the built-in, processor,
 term-semantics, Prolog-text/execution, evaluable-functor, implementation-defined,
 WG17-syntax, and STC draft ledgers in this directory. The generated
-[`conformance-report.md`](../../conformance-report.md) gives current case totals.
+[`conformance-report.md`](../../conformance-report.md) gives the current executable WG17 syntax result together with file-based case totals.
 
 The ledger deliberately does **not** claim independent certification. A row
 marked `covered` means EyeProlog has implementation and executable tests for
@@ -38,13 +38,13 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 7.7 — execution and backtracking | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes ordinary clause selection/backtracking, source/database order, empty-versus-unknown procedures, logical-update visibility, and strict dispatch. EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts remain disabled in the strict profile. |
 | 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion. The 8.15 built-in additions remain independently row-audited. |
 | 7.9 — expression evaluation | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) closes recursive evaluation, direct-variable precedence, corrected non-evaluable `F/N` errors (including STC #69), operand template/type rules, mixed arithmetic-comparison conversion, exceptional values, and finite-host resource normalization. The audit also fixes float-only `float_integer_part/1` and `float_fractional_part/1` so even huge valid integers reach `type_error(float,...)` before any I->F overflow. |
-| 7.10 — input/output concepts | covered | Higher-level stream semantics are pinned for non-atom ground stream terms, alias lifetime, current/target stream selection and fallback, write truncation, append positioning, contradictory stream options, exact binary round-tripping, flushing, standard-stream close behavior, and repositioned overwrite. The complete 8.11-8.14 built-in mode/error family remains row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), while all implementation-defined stream choices are indexed in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md). |
+| 7.10 — input/output concepts | covered | Higher-level stream semantics are pinned for non-atom ground stream terms, alias lifetime, current/target stream selection and fallback, write truncation, append positioning, contradictory stream options, exact binary round-tripping, flushing, standard-stream close behavior, and repositioned overwrite. Term-output spelling is also checked lexically where ISO distinguishes token forms: Corrigendum 2 bar operators are written with bare `|`, ordinary atom/functor `|` remains quoted, and the semicolon name token is emitted bare by canonical output. The complete 8.11-8.14 built-in mode/error family remains row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), while all implementation-defined stream choices are indexed in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md). |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. STC #70 is recorded explicitly: EyeProlog has no separate finite procedure-arity ceiling, so the optional `max_procedure_arity` flag is absent while `max_arity` remains `unbounded`. Strict mode excludes the EyeProlog `occurs_check` extension. |
 | 7.12 — errors | covered | The strict error-envelope gate exercises instantiation, type, domain, existence, permission, representation, evaluation, resource, syntax, and system errors through `error(Error, Context)`. Built-in rows provide the individual prescribed conditions, implementation-defined representation/context choices are documented, and simultaneous-error regressions pin deterministic EyeProlog choices without treating textual table order as normative. |
 | 8.2-8.17 — built-in predicates | covered | [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now records the complete Part 1 + Corrigenda built-in family at one row per prescribed mode, success/failure behavior, individual error condition, and conditional/not-applicable branch. The row audit exposed and fixed source/runtime 7.6.2 body conversion/variable sharing, strict host-string leakage, input-code error timing, `close/2` force handling, and closed-stream `stream_property/2` behavior. Simultaneous-error choices are documented as implementation dependent under 7.12 unless separately constrained. |
 | Clause 9 — evaluable functors | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) records the published Part 1 + Corrigenda arithmetic templates and exceptional branches across 9.1, 9.3, and 9.4. It pins the unbounded integer model, `rndI`/`rndF`/`resultF` choices, float-only conversion rules, I->F overflow, explicit `exp/1` and power underflow, Corrigendum 2 additions and mixed-type `max/2`/`min/2` implementation-dependent choice, Corrigendum 3 negative-power correction, signed bitwise/shift choices, and resource-error translation. Post-N289 STC #75 remains a separately tracked draft proposal rather than a silent change to the published baseline. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
-| Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
+| Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases, including the distinct bare `|` operator token required for term output. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
 
 ## Conformance corrections and audit closure

package/test/conformance/README.md

@@ -109,7 +109,7 @@ 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:
+Regenerate the public conformance report, including the executable WG17 syntax status and the file-based category inventory:
 
 ```sh
 node test/run-conformance-report.mjs
@@ -146,8 +146,8 @@ are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 The corpus has 386 cases in `iso/` and 802 file-based conformance cases in
 total. Of those, 11 cases in `stc/` are explicitly labelled working-draft
 review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
-The generated `conformance-report.md` is the authoritative source for current
-category totals. Together with regression, documentation-sync, API, example,
+The generated `conformance-report.md` is the authoritative source for the current
+executable WG17 syntax result and file-based category totals. Together with regression, documentation-sync, API, example,
 and book-example checks, `npm test` is the release gate.
 
 ## Updating expected output

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

@@ -7,7 +7,10 @@ This ledger counts an upstream case when its WG17 identifier, query, and
 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.
+upstream assertion. Writer expectations also preserve ISO-significant token
+spelling: in particular, a bare bar used as an operator is not treated as
+equivalent to a quoted atom, and a bare semicolon name token is not silently
+accepted in quoted form.
 
 ## Current standing
 

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

@@ -3894,7 +3894,7 @@
             "variables": "[]"
           },
           {
-            "output": "a-->b,c'|'d",
+            "output": "a-->b,c|d",
             "variables": "[]"
           }
         ]
@@ -3914,7 +3914,7 @@
             "variables": "[]"
           },
           {
-            "output": "'|'(a,';'(b,c))",
+            "output": "'|'(a,;(b,c))",
             "variables": "[]"
           }
         ]
@@ -3934,7 +3934,7 @@
             "variables": "[]"
           },
           {
-            "output": "'|'(';'(a,b),c)",
+            "output": "'|'(;(a,b),c)",
             "variables": "[]"
           }
         ]
@@ -3965,7 +3965,7 @@
             "variables": "[]"
           },
           {
-            "output": "[(a'|'b)]",
+            "output": "[(a|b)]",
             "variables": "[]"
           }
         ]
@@ -5173,7 +5173,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "';'(a)",
+            "output": ";(a)",
             "variables": "[]"
           }
         ]
@@ -5189,7 +5189,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "';'(a)",
+            "output": ";(a)",
             "variables": "[]"
           }
         ]
@@ -5205,7 +5205,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "';'(a,b)",
+            "output": ";(a,b)",
             "variables": "[]"
           }
         ]

package/test/run-conformance-report.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-// Static conformance corpus report.
-// This complements the executable runner with a category summary that makes
-// coverage growth visible without running every case.
+// Executable conformance status plus static corpus inventory.
+// The WG17 row is run when this report is generated, so a syntax-conformance
+// regression changes the public report even when the fixture inventory itself
+// has not changed.
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { runWg17 } from './run-wg17.mjs';
 import { listPrologFiles } from './test-support.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
@@ -18,9 +20,9 @@ const KINDS = [
   { kind: 'proofs', expectedKind: 'expected-proofs', expectedExt: '.pl', column: 'proofs' },
 ];
 
-export function buildConformanceReport() {
+export function buildConformanceReport({ wg17Suite = runWg17 } = {}) {
   const categories = new Map();
-  const issues = [];
+  const corpusIssues = [];
 
   for (const { kind, expectedKind, expectedExt, column } of KINDS) {
     const base = path.join(conformanceRoot, kind);
@@ -33,10 +35,10 @@ export function buildConformanceReport() {
 
       const stem = file.slice(0, -3);
       const expected = path.join(conformanceRoot, expectedKind, `${stem}${expectedExt}`);
-      if (!fs.existsSync(expected)) issues.push(`missing ${expectedKind}/${stem}${expectedExt}`);
+      if (!fs.existsSync(expected)) corpusIssues.push(`missing ${expectedKind}/${stem}${expectedExt}`);
       if (kind === 'warnings') {
         const expectedStderr = path.join(conformanceRoot, expectedKind, `${stem}.txt`);
-        if (!fs.existsSync(expectedStderr)) issues.push(`missing ${expectedKind}/${stem}.txt`);
+        if (!fs.existsSync(expectedStderr)) corpusIssues.push(`missing ${expectedKind}/${stem}.txt`);
       }
     }
   }
@@ -52,32 +54,97 @@ export function buildConformanceReport() {
     total: acc.total + row.total,
   }), { positive: 0, errors: 0, warnings: 0, proofs: 0, total: 0 });
 
-  return { rows, total, issues: issues.sort() };
+  const executable = [executeGate('WG17 syntax', wg17Suite)];
+  const executionIssues = executable.flatMap((gate) => gate.failures.map((failure) =>
+    `${gate.name}: ${failure.name}: ${failure.message}`));
+
+  return {
+    rows,
+    total,
+    executable,
+    corpusIssues: corpusIssues.sort(),
+    executionIssues,
+    issues: [...corpusIssues.sort(), ...executionIssues],
+  };
 }
 
 export function formatConformanceReport(report = buildConformanceReport()) {
   const lines = [
     '# EyeProlog conformance report',
     '',
-    'This report summarizes the file-based conformance corpus under `test/conformance/`.',
+    'This report combines an executable external conformance gate with the file-based',
+    'conformance corpus under `test/conformance/`. The executable result is measured',
+    'when this report is generated; it is not inferred from fixture counts.',
+    '',
+    '## Executable conformance status',
+    '',
+    '| Gate | Passed | Total | Status |',
+    '|---|---:|---:|---|',
+  ];
+
+  for (const gate of report.executable) {
+    const status = gate.passed === gate.total ? 'pass' : 'fail';
+    lines.push(`| ${gate.name} | ${gate.passed} | ${gate.total} | ${status} |`);
+  }
+
+  lines.push(
+    '',
+    'The WG17 syntax row executes the vendored 366-case conformity-testing matrix',
+    'against EyeProlog\'s strict ISO reader/writer. A behavior fix such as operator-token',
+    'spelling therefore changes this report even when no corpus file is added or removed.',
+    '',
+    '## File-based corpus inventory',
     '',
     '| Category | Positive | Errors | Warnings | Proofs | Total |',
     '|---|---:|---:|---:|---:|---:|',
-  ];
+  );
 
   for (const row of report.rows) {
     lines.push(`| ${row.category} | ${row.positive} | ${row.errors} | ${row.warnings} | ${row.proofs} | ${row.total} |`);
   }
   lines.push(`| **Total** | **${report.total.positive}** | **${report.total.errors}** | **${report.total.warnings}** | **${report.total.proofs}** | **${report.total.total}** |`);
 
-  if (report.issues.length > 0) {
+  if (report.corpusIssues.length > 0) {
     lines.push('', '## Corpus issues', '');
-    for (const issue of report.issues) lines.push(`- ${issue}`);
+    for (const issue of report.corpusIssues) lines.push(`- ${issue}`);
+  }
+  if (report.executionIssues.length > 0) {
+    lines.push('', '## Executable conformance failures', '');
+    for (const issue of report.executionIssues) lines.push(`- ${issue}`);
   }
 
   return `${lines.join('\n')}\n`;
 }
 
+function executeGate(name, runSuite) {
+  const failures = [];
+  const reporter = {
+    passed: 0,
+    total: 0,
+    section() {},
+    sectionTotal() {},
+    test(testName, run) {
+      this.total++;
+      try {
+        run();
+        this.passed++;
+      } catch (error) {
+        failures.push({
+          name: testName,
+          message: String(error?.message ?? error).split('\n', 1)[0],
+        });
+      }
+    },
+  };
+
+  try {
+    runSuite(reporter);
+  } catch (error) {
+    failures.push({ name: 'suite setup', message: String(error?.message ?? error).split('\n', 1)[0] });
+  }
+  return { name, passed: reporter.passed, total: reporter.total, failures };
+}
+
 function categoryOf(file) {
   const parts = file.split('/');
   return parts.length > 1 ? parts[0] : 'legacy-numbered';

package/test/run-regression.mjs

@@ -4698,6 +4698,34 @@ function documentationSyncCases() {
           true,
           'non-semantic internal operator spacing remains flexible',
         );
+        const barWriter = {
+          id: 181,
+          query: "writeq((a-->b,c|d)).",
+          input: "op(1105,xfy,'|').\nwriteq((a-->b,c|d)).",
+        };
+        assertEqual(
+          matchesUpstreamExpectation(
+            'a-->b,c|d',
+            { type: 'success', stages: [{ output: "a-->b,c'|'d", variables: '[]' }] },
+            barWriter,
+          ),
+          false,
+          'quoted bar is not accepted in operator-form writer output',
+        );
+        const semicolonWriter = {
+          id: 331,
+          query: 'write_canonical(;(a,b)).',
+          input: 'write_canonical(;(a,b)).',
+        };
+        assertEqual(
+          matchesUpstreamExpectation(
+            ';(a,b)',
+            { type: 'success', stages: [{ output: "';'(a,b)", variables: '[]' }] },
+            semicolonWriter,
+          ),
+          false,
+          'quoted semicolon is not accepted when the ISO name token is bare',
+        );
         const repeated = {
           id: 227, input: 'write_canonical(B+B).',
           outcome: { type: 'success', stages: [{ output: '+(_A,_A)', variables: "['B' = B]" }] },
@@ -5001,10 +5029,27 @@ function documentationSyncCases() {
         assertEqual(report.total.total >= 475, true, 'conformance case count');
         assertEqual(report.total.positive + report.total.errors + report.total.warnings + report.total.proofs, report.total.total, 'conformance total');
         assertEqual(report.rows.some((row) => row.category === 'legacy-numbered'), false, 'legacy-numbered category');
+        const wg17 = report.executable.find((gate) => gate.name === 'WG17 syntax');
+        assertEqual(wg17?.total, 366, 'WG17 executable total');
+        assertEqual(wg17?.passed, 366, 'WG17 executable passed');
+        assertArrayEqual(wg17?.failures ?? [], [], 'WG17 executable failures');
         const text = formatConformanceReport(report);
+        assertIncludes(text, '| WG17 syntax | 366 | 366 | pass |', 'report');
         assertIncludes(text, '| variables |', 'report');
         assertIncludes(text, '| Proofs |', 'report');
         assertIncludes(text, '| **Total** |', 'report');
+
+        const failing = buildConformanceReport({
+          wg17Suite: (reporter) => {
+            reporter.section('WG17 syntax');
+            reporter.test('synthetic syntax failure', () => { throw new Error('synthetic mismatch'); });
+            reporter.sectionTotal('WG17 syntax');
+          },
+        });
+        assertEqual(failing.executable[0].passed, 0, 'failing WG17 executable passed');
+        assertEqual(failing.executable[0].total, 1, 'failing WG17 executable total');
+        assertEqual(failing.executionIssues.length, 1, 'failing WG17 report issue count');
+        assertIncludes(formatConformanceReport(failing), '| WG17 syntax | 0 | 1 | fail |', 'failing report');
       },
     },
 

package/test/run-wg17.mjs

@@ -252,6 +252,48 @@ function termEquivalent(expected, actual, item) {
   }
 }
 
+function soloTokenQuoteSignature(text) {
+  const signature = [];
+  let quote = null;
+  const source = presentationText(text);
+  for (let index = 0; index < source.length; index++) {
+    const ch = source[index];
+    if (quote != null) {
+      if (ch === '\\') {
+        index++;
+        continue;
+      }
+      if (ch === quote) {
+        if (source[index + 1] === quote) {
+          index++;
+          continue;
+        }
+        quote = null;
+        continue;
+      }
+      if (ch === '|' || ch === ';' || ch === ',') signature.push(`${ch}:quoted`);
+      continue;
+    }
+    if (ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === '|' || ch === ';' || ch === ',') signature.push(`${ch}:bare`);
+  }
+  return signature;
+}
+
+function preservesWriterSoloTokenSpelling(expected, actual, item) {
+  // For writer conformity cases, semantic term equivalence is deliberately
+  // not enough: ISO distinguishes the bare bar operator token from atom '|',
+  // and semicolon is itself a valid unquoted name token. This prevents the
+  // fallback parser comparison from accepting regressions such as `a'|'b` or
+  // canonical `';'(a,b)` when the WG17 expected spelling is `a|b` / `;(a,b)`.
+  if (!/\bwrite(?:q|_canonical|_term)?\s*\(/.test(item?.query ?? '')) return true;
+  return JSON.stringify(soloTokenQuoteSignature(expected)) ===
+    JSON.stringify(soloTokenQuoteSignature(actual));
+}
+
 function abbreviatedErrorMatches(expected, actual) {
   if (actual.type !== 'error') return false;
   const formal = actual.formal ?? '';
@@ -284,6 +326,7 @@ function textExpectationMatches(expectedText, actual, item, example = false) {
     // boundary, notably Cor.3 prefix-operator cases such as `- (1^2)`. Do not
     // erase that boundary before the semantic/layout-tolerant fallbacks below.
     if (!preservesLeadingOperatorParenLayout(left, right)) continue;
+    if (!preservesWriterSoloTokenSpelling(left, right, item)) continue;
     if (stripLayoutOutsideQuotes(left) === stripLayoutOutsideQuotes(right)) return true;
     if (termEquivalent(left, right, item)) return true;
     if (example) {

package/the-art-of-eyeprolog.md

@@ -7784,14 +7784,14 @@ their declared goals are executed. The eight-case
 playground contract suite imports the production worker, sends real reasoning
 requests through its message protocol, and crawls the served module graph for
 missing assets, bad MIME types, and static Node-only imports. The generated
-`conformance-report.md` is the authoritative source for current conformance
-category totals.
+`conformance-report.md` is the authoritative source for the current executable
+WG17 syntax result and file-based conformance category totals.
 
 ### Generated and checked repository material
 
 Repository artifacts have distinct roles:
 
-- `conformance-report.md` is generated from the file-based conformance corpus;
+- `conformance-report.md` executes the vendored WG17 syntax gate and also inventories the file-based conformance corpus;
 - `examples/book/` is extracted from executable code blocks in this book and
   should be rebuilt with `npm run generate` rather than edited directly;
 - `examples/output/` and `examples/proof/` contain reviewed exact-output

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

@@ -95,7 +95,10 @@ This ledger counts an upstream case when its WG17 identifier, query, and
 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.
+upstream assertion. Writer expectations also preserve ISO-significant token
+spelling: in particular, a bare bar used as an operator is not treated as
+equivalent to a quoted atom, and a bare semicolon name token is not silently
+accepted in quoted form.
 
 ## Current standing