eyeprolog 1.4.0 → 1.4.2

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 | 372 | 372 | pass |
+
+The WG17 syntax row executes the vendored 372-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.4.0",
+  "version": "1.4.2",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/write.js

@@ -99,17 +99,30 @@ function compactPrefixOperator(token, argument) {
   return `${token}${needsLayout ? ' ' : ''}${argument}`;
 }
 
+function quotedOperatorAfterNumericNeedsSpace(left, token) {
+  if (!token.startsWith("'") || !/^[0-9]+$/.test(left)) return false;
+  const value = Number(left);
+  // `0'X` starts character-code notation and bases 2..36 start based-number
+  // notation. Base 1 and values above 36 do not, so they need no layout
+  // before a quoted operator (WG17 #208, #355).
+  return value === 0 || (value >= 2 && value <= 36);
+}
+
 function compactPostfixOperator(argument, token) {
-  if (isWordOperatorToken(token)) return `${argument} ${token}`;
-  return `${argument}${compactBoundaryNeedsSpace(argument, token) ? ' ' : ''}${token}`;
+  const needsLayout = compactBoundaryNeedsSpace(argument, token) ||
+    quotedOperatorAfterNumericNeedsSpace(argument, token);
+  return `${argument}${needsLayout ? ' ' : ''}${token}`;
 }
 
 function compactInfixOperator(left, token, right) {
   // Solo punctuation operators already delimit themselves.
   if (token === ',' || token === ';') return `${left}${token}${right}`;
-  if (isWordOperatorToken(token)) return `${left} ${token} ${right}`;
-  const before = compactBoundaryNeedsSpace(left, token) ? ' ' : '';
-  const after = compactBoundaryNeedsSpace(token, right) ? ' ' : '';
+  const before = (compactBoundaryNeedsSpace(left, token) ||
+    quotedOperatorAfterNumericNeedsSpace(left, token)) ? ' ' : '';
+  let after = compactBoundaryNeedsSpace(token, right) ? ' ' : '';
+  // A word operator immediately followed by `(` would look like functional
+  // notation for that atom rather than operator notation.
+  if (isWordOperatorToken(token) && right.startsWith('(')) after = ' ';
   return `${left}${before}${token}${after}${right}`;
 }
 
@@ -384,7 +397,17 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
             ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(childDefinition.specifier)) {
           argumentPriority = priority - 1;
         }
-        const argument = format(resolved.args[0], env, options, table, argumentPriority);
+        const child = deref(resolved.args[0], env);
+        let argument = format(resolved.args[0], env, options, table, argumentPriority);
+        // If both the operand atom and postfix operator require quoted names,
+        // plain adjacency would form quoted-atom escape syntax and layout would
+        // not match the ISO writer form. Parenthesize the operator atom instead
+        // (WG17 #169). Do not apply this to ordinary word postfix operators.
+        if (options.minimalOperatorSpacing && child.type === ATOM && table.has(child.name) &&
+            writeAtom(child.name).startsWith("'") && token.startsWith("'") &&
+            compactBoundaryNeedsSpace(argument, token)) {
+          argument = `(${argument})`;
+        }
         text = options.minimalOperatorSpacing ? compactPostfixOperator(argument, token) : `${argument} ${token}`;
       } else {
         let leftPriority = specifier === 'yfx' ? priority : priority - 1;

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
@@ -19,7 +19,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
-| 5.1(a) prepare conforming Prolog text | covered | Clause 6 token/term production and rejection families are mapped by the strict production gate and the complete 366-case vendored WG17 syntax matrix; 7.4 preparation/directive behavior is separately closed. |
+| 5.1(a) prepare conforming Prolog text | covered | Clause 6 token/term production and rejection families are mapped by the strict production gate and the complete 372-case vendored WG17 syntax matrix; 7.4 preparation/directive behavior is separately closed. |
 | 5.1(b) execute conforming Prolog goals | covered | Clause 7 term/control/execution semantics, the higher-level 7.10 stream model, 7.11 flags, the 7.12 error envelope, all 8.2-8.17 built-in rows, and Clause 9 arithmetic have explicit executable dispositions. |
 | 5.1(c) reject nonconforming text/read-terms | covered | WG17 negative syntax cases, focused malformed-production/escape/comment/operator cases, read-term syntax errors, and strict rejection of implementation-specific syntax provide explicit rejection evidence across the Clause 6 families. |
 | 5.1(d) document permitted variations | covered | The clause-by-clause [ISO 5.4 decision index](ISO-IMPLEMENTATION-DEFINED.md) records every explicit implementation-defined decision found in the Part 1 + Corrigenda baseline and separately inventories implementation-specific extension families. The index retains an `audit gap` category for future discoveries; no current release-facing row depends on one. |
@@ -31,7 +31,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | covered | The strict Clause 6 gate maps atomic/variable/compound/operator/list/curly/double-quoted term forms, layout/comments, quoted escapes, integer bases/character codes, floating tokens, and solo/meta token boundaries, with malformed counterparts rejected. The complete 366-case WG17 syntax matrix provides independent production-level coverage, and a cross-profile gate verifies that normal syntax extensions preserve every strict-accepted standard observation. The implementation-defined 6.5/6.6 PCS/collation choices are documented separately. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | covered | The strict Clause 6 gate maps atomic/variable/compound/operator/list/curly/double-quoted term forms, layout/comments, quoted escapes, integer bases/character codes, floating tokens, and solo/meta token boundaries, with malformed counterparts rejected. The complete 372-case WG17 syntax matrix provides independent production-level coverage, and a cross-profile gate verifies that normal syntax extensions preserve every strict-accepted standard observation. The implementation-defined 6.5/6.6 PCS/collation choices are documented separately. |
 | 7.1-7.3 — term types, term order, unification | covered | [ISO-TERM-SEMANTICS-MATRIX.md](ISO-TERM-SEMANTICS-MATRIX.md) records the five mutually exclusive strict term types, derived variable/compound/list notions, the complete standard-order classes and implementation-dependent variable-order choice, NSTO MGU/failure behavior, and EyeProlog's permitted consistent occurs-check failure for Part 1's undefined STO ordinary-unification cases. The normal JavaScript API string term is documented as a 5.5.4 extension and rejected at strict program/goal entry. |
 | 7.4 — Prolog text and directives | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes the preparation/directive rows: declaration semantics, source clauses, cross-text operators/character conversion/flags, initialization order/lifetime, `include/1`, and one-time `ensure_loaded/1`, with implementation-defined cross-text choices indexed under 5.4. |
 | 7.5-7.6 — database and term/clause conversion | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes static/dynamic and private/public procedure semantics, clause order, logical-update visibility, empty/unknown lifetime, and term/body/clause conversion. Source and runtime assertion conversion recurse through `,/2`, `;/2`, and `->/2`, preserve variable identity, and protect standardized static/control procedures. |
@@ -286,7 +286,7 @@ post-N289 STC drafts remain review input until standardized.
 | Criterion | Status | Evidence |
 | --- | --- | --- |
 | Clause 5 processor obligations have explicit dispositions | covered | `ISO-PROCESSOR-REQUIREMENTS.md` gives explicit outcomes for 5.1-5.5, including the strict/normal extension boundary. |
-| Clause 6 lexical/syntactic requirements have explicit dispositions | covered | the strict Clause 6 production/rejection gate and the 366-case vendored WG17 matrix cover the standard families; cross-profile preservation verifies that normal extensions do not reinterpret strict-accepted text. |
+| Clause 6 lexical/syntactic requirements have explicit dispositions | covered | the strict Clause 6 production/rejection gate and the 372-case vendored WG17 matrix cover the standard families; cross-profile preservation verifies that normal extensions do not reinterpret strict-accepted text. |
 | Clause 7 semantic requirements have explicit dispositions | covered | 7.1-7.12 now have explicit semantic, implementation-defined, or error-envelope dispositions backed by strict tests and the specialized matrices. |
 | Clause 8 built-in modes/errors have explicit dispositions | covered | `ISO-BUILTIN-MODE-ERROR-MATRIX.md` closes 8.2-8.17 row by row |
 | Clause 9 evaluable-functor requirements have explicit dispositions | covered | `ISO-EVALUABLE-FUNCTOR-MATRIX.md` plus the strict arithmetic regression closes the published Part 1 + Corrigenda arithmetic rows |
@@ -294,7 +294,7 @@ post-N289 STC drafts remain review input until standardized.
 | Implementation-specific strict/normal boundary is documented and tested | covered | all 5.5 hooks have explicit dispositions; the WG17 cross-profile gate verifies syntax-preservation for standard text accepted by the strict reader. |
 | Published Corrigenda 1-3 are incorporated | covered | dedicated conformance/strict tests and this ledger track all three published Corrigenda |
 | Current post-N289 draft is tracked without silently changing the published baseline | covered | `STC-DRAFT-STATUS.md` tracks reviewed draft items separately from normative requirements |
-| Independent external syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations |
+| Independent external syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 372 executable dispositions checked against its upstream expectations |
 | Third-party standard-core regression provenance is retained | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases retain source identifiers and licenses in `THIRD_PARTY.md` |
 | No unexplained deviation remains in the release-facing ledger | covered | the release-facing ledger contains no remaining `audit` rows; documented variation points are implementation-defined/specific or draft-only rather than unexplained deviations. |
 

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
@@ -145,9 +145,9 @@ 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,
+review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 372 executable dispositions.
+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

@@ -1,16 +1,16 @@
 # 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-16
+Upstream inventory checked: 2026-08-28
 
 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. 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.
+upstream assertion. Concrete writer expectations are matched lexically: layout,
+parentheses, and quoting are significant. Only Codex expectations explicitly
+marked e.g. use controlled flexibility for representation choices such as
+generated variable names or equivalent numeric spellings.
 
 ## Current standing
 
@@ -20,25 +20,25 @@ A represented case still has to pass the executable upstream assertion in
 
 | Measure | Count |
 | --- | ---: |
-| Active upstream cases | 366 |
-| Upstream cases represented in the executable matrix | 366 (100.0%) |
+| Active upstream cases | 372 |
+| Upstream cases represented in the executable matrix | 372 (100.0%) |
 | Not yet traced one-by-one | 0 |
 | Deleted upstream identifiers | #20, #273 |
 
 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. All 366 executable cases are independently checked against the
-upstream Codex expectation. 366 cases additionally retain exact reviewed
+hook. All 372 executable cases are independently checked against the
+upstream Codex expectation. 372 cases additionally retain exact reviewed
 outcomes for stronger regression checking; 0 cases currently rely on the upstream assertion alone.
 
 ## Traceable evidence
 
 | Executable evidence | Referenced IDs | WG17 cases |
 | --- | ---: | --- |
-| [complete offline executable matrix](../run-wg17.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
+| [complete offline executable matrix](../run-wg17.mjs) | 372 | #1–#19, #21–#272, #274–#374 |
 
-The evidence groups overlap. Their union is **366** active cases:
-#1–#19, #21–#272, #274–#368.
+The evidence groups overlap. Their union is **372** active cases:
+#1–#19, #21–#272, #274–#374.
 
 ## Untraced upstream identifiers
 

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

@@ -2486,7 +2486,7 @@
             "variables": "[]"
           },
           {
-            "output": "0''",
+            "output": "0 ''",
             "variables": "[]"
           }
         ]
@@ -2506,7 +2506,7 @@
             "variables": "[]"
           },
           {
-            "output": "0''",
+            "output": "0 ''",
             "variables": "[]"
           }
         ]
@@ -2653,7 +2653,7 @@
             "variables": "[]"
           },
           {
-            "output": "0'f '",
+            "output": "0 'f '",
             "variables": "[]"
           }
         ]
@@ -3313,7 +3313,7 @@
             "variables": "[]"
           },
           {
-            "output": "(fy 1) yf",
+            "output": "(fy 1)yf",
             "variables": "[]"
           }
         ]
@@ -3333,7 +3333,7 @@
             "variables": "[]"
           },
           {
-            "output": "(fy (fy 1) yf) yf",
+            "output": "(fy (fy 1)yf)yf",
             "variables": "[]"
           }
         ]
@@ -3393,7 +3393,7 @@
             "variables": "[]"
           },
           {
-            "output": "(fy 1) yfx 2",
+            "output": "(fy 1)yfx 2",
             "variables": "[]"
           }
         ]
@@ -3453,7 +3453,7 @@
             "variables": "[]"
           },
           {
-            "output": "(1 xfy 2) yf",
+            "output": "(1 xfy 2)yf",
             "variables": "[]"
           }
         ]
@@ -3587,7 +3587,7 @@
       "query": "op(9,fy,p),op(9,xfy,p).\nwrite_canonical(1 p p p 2).",
       "input": "op(9,fy,p),op(9,xfy,p).\nwrite_canonical(1 p p p 2).",
       "readCount": 2,
-      "expected": "p(1, p(p(2)))",
+      "expected": "p(1,p(p(2)))",
       "outcome": {
         "type": "success",
         "stages": [
@@ -3607,7 +3607,7 @@
       "query": "op(7,fy,p),op(9,yfx,p).\nwrite_canonical(1 p p p 2).",
       "input": "op(7,fy,p),op(9,yfx,p).\nwrite_canonical(1 p p p 2).",
       "readCount": 2,
-      "expected": "p(1, p(p(2)))",
+      "expected": "p(1,p(p(2)))",
       "outcome": {
         "type": "success",
         "stages": [
@@ -3695,7 +3695,7 @@
             "variables": "[]"
           },
           {
-            "output": "'.' '.'",
+            "output": "('.')'.'",
             "variables": "[]"
           }
         ]
@@ -5565,6 +5565,97 @@
           }
         ]
       }
+    },
+    {
+      "id": 369,
+      "query": "writeq(?-).",
+      "input": "writeq(?-).",
+      "readCount": 1,
+      "expected": "?-",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": "?-",
+            "variables": "[]"
+          }
+        ]
+      }
+    },
+    {
+      "id": 370,
+      "query": "writeq(./*).",
+      "input": "writeq(./*).",
+      "readCount": 1,
+      "expected": "./*",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": "./*",
+            "variables": "[]"
+          }
+        ]
+      }
+    },
+    {
+      "id": 371,
+      "query": "writeq({*}).",
+      "input": "writeq({*}).",
+      "readCount": 1,
+      "expected": "{*}",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": "{*}",
+            "variables": "[]"
+          }
+        ]
+      }
+    },
+    {
+      "id": 372,
+      "query": "writeq(.*).",
+      "input": "writeq(.*).",
+      "readCount": 1,
+      "expected": ".*",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": ".*",
+            "variables": "[]"
+          }
+        ]
+      }
+    },
+    {
+      "id": 373,
+      "query": "writeq(...*).",
+      "input": "writeq(...*).",
+      "readCount": 1,
+      "expected": "...*",
+      "outcome": {
+        "type": "success",
+        "stages": [
+          {
+            "output": "...*",
+            "variables": "[]"
+          }
+        ]
+      }
+    },
+    {
+      "id": 374,
+      "query": "Finis ().",
+      "input": "Finis ().",
+      "readCount": 1,
+      "expected": "syntax err.",
+      "outcome": {
+        "type": "error",
+        "formal": "syntax_error(read_term)"
+      }
     }
   ],
   "sourceRevision": "1.300",

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

@@ -1,14 +1,14 @@
 {
   "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
-  "checkedOn": "2026-08-16",
+  "checkedOn": "2026-08-28",
   "upstream": {
     "firstId": 1,
-    "lastId": 368,
+    "lastId": 374,
     "deletedIds": [
       20,
       273
     ],
-    "activeCases": 366
+    "activeCases": 372
   },
   "evidence": [
     {

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,99 @@ 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 wg17 = report.executable.find((gate) => gate.name === 'WG17 syntax');
+  const wg17Total = wg17?.total ?? 0;
   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 ${wg17Total}-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

@@ -4726,6 +4726,54 @@ function documentationSyncCases() {
           false,
           'quoted semicolon is not accepted when the ISO name token is bare',
         );
+        const quotedPostfixWriter = {
+          id: 208,
+          query: "op(100,xf,'f ').\nwriteq(0 'f ').",
+          input: "op(100,xf,'f ').\nwriteq(0 'f ').",
+        };
+        assertEqual(
+          matchesUpstreamExpectation(
+            "0 'f '",
+            { type: 'success', stages: [{ output: "0'f '", variables: '[]' }] },
+            quotedPostfixWriter,
+          ),
+          false,
+          'mandatory layout before quoted postfix operator is not erased',
+        );
+        const dottedPostfixWriter = {
+          id: 169,
+          query: 'writeq(.(.)).',
+          input: "op(0,xfy,.),op(9,yf,.).\nwriteq(.(.)).",
+        };
+        assertEqual(
+          matchesUpstreamExpectation(
+            "('.')'.'",
+            { type: 'success', stages: [{ output: "'.' '.'", variables: '[]' }] },
+            dottedPostfixWriter,
+          ),
+          false,
+          'mandatory writer parentheses are not replaced by layout',
+        );
+        const wordPostfixWriter = { id: 150, query: 'writeq(yf(fy(1))).', input: 'writeq(yf(fy(1))).' };
+        assertEqual(
+          matchesUpstreamExpectation(
+            '(fy 1)yf',
+            { type: 'success', stages: [{ output: '(fy 1) yf', variables: '[]' }] },
+            wordPostfixWriter,
+          ),
+          false,
+          'concrete writer layout is matched exactly',
+        );
+        const canonicalWriter = { id: 163, query: 'write_canonical(1 p p p 2).', input: 'write_canonical(1 p p p 2).' };
+        assertEqual(
+          matchesUpstreamExpectation(
+            'p(1,p(p(2)))',
+            { type: 'success', stages: [{ output: 'p(1, p(p(2)))', variables: '[]' }] },
+            canonicalWriter,
+          ),
+          false,
+          'concrete canonical writer layout is matched exactly',
+        );
         const repeated = {
           id: 227, input: 'write_canonical(B+B).',
           outcome: { type: 'success', stages: [{ output: '+(_A,_A)', variables: "['B' = B]" }] },
@@ -5029,10 +5077,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, 372, 'WG17 executable total');
+        assertEqual(wg17?.passed, 372, 'WG17 executable passed');
+        assertArrayEqual(wg17?.failures ?? [], [], 'WG17 executable failures');
         const text = formatConformanceReport(report);
+        assertIncludes(text, '| WG17 syntax | 372 | 372 | 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

@@ -306,12 +306,26 @@ function abbreviatedErrorMatches(expected, actual) {
   return patterns.some(([pattern, prefix]) => pattern.test(expected) && formal.startsWith(prefix));
 }
 
+function isWriterCase(item) {
+  return /\bwrite(?:q|_canonical|_term)?\s*\(/.test(item?.query ?? '');
+}
+
 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, '');
 
+  // A concrete WG17 writer expectation describes output syntax, not merely
+  // the term denoted by that output. Layout, quoting and parentheses are
+  // therefore significant. Only expectations explicitly marked `e.g.` use
+  // the controlled semantic/layout fallbacks below.
+  const hasBindings = actual.type === 'success' &&
+    actual.stages.some(({ variables }) => bindingAnswer(variables).length > 0);
+  if (!example && isWriterCase(item) && !hasBindings) {
+    return candidates.some((candidate) => presentationText(candidate) === expected);
+  }
+
   for (const candidate of candidates) {
     let left = expected;
     let right = candidate;

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,10 +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. 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.
+upstream assertion. Concrete writer expectations are matched lexically: layout,
+parentheses, and quoting are significant. Only Codex expectations explicitly
+marked e.g. use controlled flexibility for representation choices such as
+generated variable names or equivalent numeric spellings.
 
 ## Current standing