eyeprolog 1.5.25 → 1.5.27

package/examples/odrl-policy-reasoning.pl

@@ -345,11 +345,8 @@ profile_prohibition(Request) :-
   cycle_request(Request),
   tnot(profile_permission(Request)).
 
-% For a ground WFS claim, true and false are successful positive and negative
-% probes.  If neither probe succeeds, the WFS truth value is undefined.
-wfs_truth(Claim, true) :- call(Claim), \+ tnot(Claim).
-wfs_truth(Claim, false) :- tnot(Claim), \+ call(Claim).
-wfs_truth(Claim, undefined) :- \+ call(Claim), \+ tnot(Claim).
+% The normal-profile wfs_truth/2 predicate reports the three-valued result of
+% each ground claim without treating an undefined claim as ordinary success.
 
 % --- Curated questions -----------------------------------------------------
 

package/package.json

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

package/src/cli.js

@@ -28,6 +28,7 @@ export async function main(argv) {
     proofDetail: 'abstract',
     verifyProof: null,
     quads: false,
+    quiet: false,
     stats: false,
     isoStrict: false,
     portable: false,
@@ -60,6 +61,8 @@ export async function main(argv) {
       options.verifyProof = file;
     } else if (!endOptions && (arg === '--quads' || arg === '-q')) {
       options.quads = true;
+    } else if (!endOptions && arg === '--quiet') {
+      options.quiet = true;
     } else if (!endOptions && (arg === '--stats' || arg === '-s')) {
       options.stats = true;
     } else if (!endOptions && arg === '--iso-strict') {
@@ -116,7 +119,7 @@ export async function main(argv) {
   }
 
   if (options.isoStrict && options.files.length === 0 && options.goals.length === 0 &&
-      options.verifyProof == null && !options.proof && !options.stats && !options.warnings) {
+      options.verifyProof == null && !options.proof && !options.quiet && !options.stats && !options.warnings) {
     const engine = await loadEngine();
     const { runRepl } = await import('./repl.js');
     const exitCode = await runRepl(engine, {
@@ -251,8 +254,8 @@ async function runForwardDefault(engine, program, options) {
   });
   try {
     const result = engine.executeForwardRules(program, solver, {
-      onAnswer: (line) => process.stdout.write(line),
-      onFuse: (line) => process.stdout.write(line),
+      onAnswer: (line) => { if (!options.quiet) process.stdout.write(line); },
+      onFuse: (line) => { if (!options.quiet) process.stdout.write(line); },
       onDiagnostic: (line) => process.stderr.write(line),
     });
     if (result.haltCode != null) process.exitCode = result.haltCode;
@@ -277,7 +280,7 @@ async function runDefault(engine, program, options) {
   try {
     const { haltCode } = engine.executeGoals(program, solver, goals, {
       onAnswer: (line, resolved) => {
-        process.stdout.write(line);
+        if (!options.quiet) process.stdout.write(line);
         if (options.proof) writeExplanation(explanation, program, resolved, registry, options);
       },
     });
@@ -313,6 +316,7 @@ Options:
   --proof-detail mode   Use abstract or expanded proof detail (implies --proof).
   --verify-proof file   Verify why/2 proof certificates against the input program.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
+  --quiet               Suppress answer terms while preserving Prolog output.
   -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
                         reject EyeProlog language extensions.

package/src/program.js

@@ -57,6 +57,10 @@ function collectMultiplicitySensitiveDependencies(goal, out = []) {
     collectMultiplicitySensitiveDependencies(goal.args[0], out);
     return out;
   }
+  if (goal.name === 'wfs_truth' && goal.arity === 2) {
+    collectMultiplicitySensitiveDependencies(goal.args[0], out);
+    return out;
+  }
   if (goal.name === 'forall' && goal.arity === 2) {
     collectMultiplicitySensitiveDependencies(goal.args[0], out);
     collectMultiplicitySensitiveDependencies(goal.args[1], out);
@@ -1134,6 +1138,10 @@ function collectAutoloadGoalDependencies(goal, out = []) {
     collectAutoloadGoalDependencies(goal.args[0], out);
     return out;
   }
+  if (goal.name === 'wfs_truth' && goal.arity === 2) {
+    collectAutoloadGoalDependencies(goal.args[0], out);
+    return out;
+  }
 
   out.push({ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module });
 
@@ -1687,7 +1695,8 @@ function annotateGoalModule(term, module) {
   if (!term || (term.type !== ATOM && term.type !== COMPOUND)) return term;
   term.module = module;
   const callableArguments = (term.name === ',' || term.name === ';' || term.name === '->') ? term.args
-    : (['call', 'once', '\\+', 'not', 'catch', 'call_cleanup', 'setup_call_cleanup',
+    : (term.name === 'wfs_truth' && term.arity === 2) ? [term.args[0]]
+    : (['call', 'once', '\\+', 'not', 'tnot', 'catch', 'call_cleanup', 'setup_call_cleanup',
       'forall', 'findall', 'bagof', 'setof', 'countall', 'sumall',
       'aggregate_min', 'aggregate_max', 'maplist', 'phrase'].includes(term.name)
       ? term.args

package/src/solver.js

@@ -919,7 +919,27 @@ export class Solver {
   }
 
   *solveTabledNegation(argument, env) {
-    const invoked = copyResolved(argument, env);
+    const truth = this.groundGoalTruth(argument, env);
+    if (truth === 'true') return;
+    if (truth === 'undefined') {
+      this.stats.wfs_undefined_answers++;
+      return;
+    }
+    yield env;
+  }
+
+  groundGoalTruth(argument, env) {
+    let invoked = copyResolved(argument, env);
+    while (invoked.type === COMPOUND && invoked.name === ':' && invoked.arity === 2) {
+      const module = invoked.args[0];
+      if (module.type === VAR) throw new PrologError('instantiation_error');
+      if (module.type !== 'atom') throw new PrologError('type_error(atom)', module);
+      invoked = invoked.args[1];
+      if (invoked.type !== COMPOUND && invoked.type !== 'atom') {
+        throw new PrologError('type_error(callable)', invoked);
+      }
+      qualifyTerm(invoked, module.name);
+    }
     if (invoked.type === VAR) throw new PrologError('instantiation_error');
     if (invoked.type !== COMPOUND && invoked.type !== 'atom') {
       throw new PrologError('type_error(callable)', invoked);
@@ -928,25 +948,18 @@ export class Solver {
     const group = this.program.findGroup(invoked.name, invoked.arity, invoked.module ?? 'user');
     if (group?.wfsDatalog === true) {
       const model = this.wfsModelFor(group);
-      const truth = truthOfGroundGoal(model, invoked);
-      if (truth === 'true') return;
-      if (truth === 'undefined') {
-        this.stats.wfs_undefined_answers++;
-        return;
-      }
-      yield env;
-      return;
+      return truthOfGroundGoal(model, invoked);
     }
 
-    // Outside an unstratified WFS component, a ground tabled negation has the
-    // ordinary two-valued result after the positive goal is evaluated.
+    // Outside an unstratified WFS component, a ground goal has the ordinary
+    // two-valued result after the positive goal is evaluated.
     const child = this.cloneForInnerGoal(1);
     for (const _ of child.solve([invoked], env.clone(), 0)) {
       this.absorbStatsFrom(child);
-      return;
+      return 'true';
     }
     this.absorbStatsFrom(child);
-    yield env;
+    return 'false';
   }
 
   activeVariant(goal, env) {

package/src/standard-library.js

@@ -310,6 +310,13 @@ function* tabledNegationBuiltin({ solver, goal, env }) {
   yield* solver.solveTabledNegation(goal.args[0], env);
 }
 
+function* wfsTruthBuiltin({ solver, goal, env }) {
+  const truth = solver.groundGoalTruth(goal.args[0], env);
+  if (truth === 'undefined') solver.stats.wfs_undefined_answers++;
+  const next = env.clone();
+  if (unify(goal.args[1], atom(truth), next)) yield next;
+}
+
 function runtimeStatistics(solver) {
   return { ...solver.stats, ...memoryStatistics() };
 }
@@ -361,6 +368,7 @@ export function createEyePrologRegistry() {
   registry.add('statistics', 0, statisticsBuiltin, { deterministic: true });
   registry.add('statistics', 2, statisticsValueBuiltin);
   registry.add('tnot', 1, tabledNegationBuiltin, { deterministic: true });
+  registry.add('wfs_truth', 2, wfsTruthBuiltin, { deterministic: true });
   attsHostBuiltins.register(registry);
   expansionBuiltins.register(registry);
   arithmeticHostBuiltins.register(registry);

package/test/conformance/ISO-BUILTIN-MODE-ERROR-MATRIX.md

@@ -17,11 +17,13 @@ table.
 The table is intentionally explicit about what has and has not been closed.
 The current audit now covers the complete 8.2-8.17 built-in family at the
 level of prescribed modes, success/failure behavior, individual error
-conditions, and explicit not-applicable processor branches. Higher-level
-Clause 7 and Clause 9 semantics remain tracked separately.
+conditions, and explicit not-applicable processor branches. Closely related
+conditions may share a row only when that row names every condition and the
+executable evidence for each. Higher-level Clause 7 and Clause 9 semantics
+remain tracked separately.
 
 The focused assertions added for this matrix live in `test/run-iso-strict.mjs`;
-existing file-based cases remain additional independent evidence.
+existing file-based cases remain additional regression evidence.
 
 ## 8.2 — term unification
 
@@ -369,6 +371,8 @@ built-in matrix does not have a gap at 8.17.
 The built-in **8.2-8.17 row audit is complete** at the level tracked by this
 file: prescribed modes, success/failure behavior, individual error conditions,
 and conditional/not-applicable processor branches all have explicit outcomes.
+“Row audit” means condition-by-condition accounting; it does not promise one
+Markdown table row per condition when a grouped row enumerates them all.
 ISO 7.12 simultaneous-error selection remains an implementation-dependent
 processor choice unless more specific normative text constrains it.
 

package/test/conformance/ISO-COMPLIANCE.md

@@ -5,12 +5,16 @@ EyeProlog's ISO/IEC 13211-1 core. The normative baseline is ISO/IEC 13211-1:1995
 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
+published-Corrigenda, WG17-syntax, and STC draft ledgers in this directory. The generated
 [`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
-that family and no known open defect in the listed behavior. A row marked
+that family, an explicit disposition for every requirement accounted for by
+the linked audit rows, and no known open defect in the listed behavior. An
+audit row may group closely related modes or error conditions, but it must name
+each grouped condition and its evidence; `covered` does not imply one Markdown
+row per occurrence of the word `shall`. A row marked
 `audit` means the family is implemented and tested, but the project has not yet
 mapped every normative `shall`, option combination, prescribed error, and
 relevant implementation-dependent overlap choice to an explicit audit outcome.
@@ -23,7 +27,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 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. |
-| 5.1(e) offer a strictly conforming mode | covered | `--iso-strict` and API option `isoStrict: true` restrict the processor to the Part 1 + Corrigenda 1-3 core language surface, remove EyeProlog-only registry/flag/operator features, reject explicit tabling and other normal-profile extensions, and reject the normal-profile host `stringTerm/1` term type at strict program/goal entry. |
+| 5.1(e) offer a strictly conforming mode | covered | `--iso-strict` and API option `isoStrict: true` restrict the processor to the Part 1 + Corrigenda 1-3 core language surface, remove EyeProlog-only registry/flag/operator features, reject explicit tabling and other normal-profile extensions, and reject the normal-profile host `stringTerm(Text)` term type at strict program/goal entry. |
 | 5.4 accompanying documentation | covered | *The Art of EyeProlog* remains the implementation reference; [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md) is the closed clause-by-clause 5.4 decision index and points each decision to implementation evidence. |
 | 5.5 extension boundaries | covered | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) gives an explicit disposition for every 5.5 extension hook. The Clause 6 cross-profile gate verifies that normal-mode syntax extensions do not reinterpret standard text accepted by the strict reader. |
 
@@ -31,7 +35,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 366-case WG17 syntax matrix provides externally sourced production-level expectations, 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. |
@@ -41,11 +45,11 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 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. |
+| 8.2-8.17 — built-in predicates | covered | [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) accounts for the complete Part 1 + Corrigenda built-in family across prescribed modes, success/failure behavior, individual error conditions, and conditional/not-applicable branches. Closely related conditions may share a row when every condition and its executable evidence are named. The 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, 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. |
+| Corrigendum 1 | covered | [ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) dispositions every amendment cluster, including the square-root boundary, double-quoted operator atoms, typed expression errors, clause/operator enumeration, and atomic-conversion corrections; editorial items and the later-superseded set-order example are identified explicitly. |
+| Corrigendum 2 | covered | [ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) tracks the bar/operator changes, new predicates and evaluable functors, catch and uninstantiation corrections, atomic-conversion errors, and every other amendment cluster to executable evidence or an explicit editorial disposition. |
+| Corrigendum 3 | covered | [ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) tracks option-extension/error rules, final layout, term-to-body conversion, metadata traversal, writing rules, stream/built-in corrections, and negative integer powers; editorial changes are dispositioned separately. |
 
 ## Conformance corrections and audit closure
 
@@ -248,8 +252,10 @@ not interpret the following as core-language features:
 - the implementation-specific `occurs_check` Prolog flag;
 - Part 2 module directives (`module/2`, `use_module/1-2`, `meta_predicate/1`);
 - Part 3 grammar-rule expansion and `phrase/2-3`;
-- explicit tabling, `tnot/1` well-founded evaluation, and recursive numeric execution shortcuts;
-- EyeProlog well-founded negation via `tnot/1` and its WFS runtime statistics;
+- explicit tabling, EyeProlog well-founded evaluation via `tnot/1` and
+  `wfs_truth/2`, WFS runtime statistics, and recursive numeric execution shortcuts;
+- normal-profile integer digit separators and Trealla-compatible
+  `"text"||Tail` double-quoted-list splicing;
 - the JavaScript API `stringTerm(Text)` additional term type (normal mode only).
 
 The predefined Part 1 `1200 fx` `?-` operator and `1200 xfx` `-->` operator
@@ -288,13 +294,13 @@ post-N289 STC drafts remain review input until standardized.
 | 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 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 8 built-in modes/errors have explicit dispositions | covered | `ISO-BUILTIN-MODE-ERROR-MATRIX.md` accounts for 8.2-8.17 condition by condition, using grouped rows only where every grouped condition and its evidence are named |
 | 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 |
 | Implementation-defined choices are documented | covered | `ISO-IMPLEMENTATION-DEFINED.md` is the Clause 5.4 decision index and strict tests pin execution-visible choices |
 | 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 |
+| Published Corrigenda 1-3 are incorporated | covered | `ISO-CORRIGENDA-MATRIX.md` inventories every published amendment cluster with executable, editorial, or superseded disposition |
 | 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 |
+| Externally sourced syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations; this is external review evidence, not certification |
 | 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/ISO-CORRIGENDA-MATRIX.md

@@ -0,0 +1,93 @@
+# ISO/IEC 13211-1 published Corrigenda audit
+
+This matrix records every amendment cluster in Technical Corrigenda 1:2007,
+2:2012, and 3:2017 against EyeProlog's published Part 1 baseline. It separates
+behavior-changing requirements from editorial/example-only corrections and
+from text superseded by a later Corrigendum. A `covered` behavior row names
+executable evidence; an `editorial` row records that no processor behavior was
+changed; a `superseded` row points to the later published amendment.
+
+The stable audit IDs are checked by the documentation regression suite. They
+make omission detectable without reproducing the licensed standard text here.
+
+## Technical Corrigendum 1:2007
+
+| Audit ID | Clauses / amendment cluster | Disposition | EyeProlog evidence |
+| --- | --- | --- | --- |
+| C1-01 | 3.106, 3.108, 3.125, 3.148 terminology and typography | editorial | Definitions/source typography; no processor behavior changes. |
+| C1-02 | 4.1.3.5 non-negative square-root axiom | covered | Strict test `pins behavior-changing Technical Corrigendum 1 corrections` checks `sqrt(0)`. |
+| C1-03 | 6.3.7 priority of a double-quoted atom that names an operator | covered | Same strict test plus `iso/corrigendum1_double_quote_operator`. |
+| C1-04 | 7.2.5 compound-term ordering wording | editorial | The corrected condition is represented by the Clause 7.2 standard-order tests. |
+| C1-05 | 7.8.5.4, table 35, and 7.8.8.4 control-model/example corrections | editorial | Corrected notation; conjunction and if-then-else behavior is independently covered by the strict 7.8 audit. |
+| C1-06 | 7.9.2 integer- and float-operand type errors | covered | Strict Clause 7.9 tests exercise integer-only and float-only templates. |
+| C1-07 | 7.12.2 representation-error metavariable capitalization | editorial | Error-term representation is covered by the 7.12 envelope; this amendment changes notation only. |
+| C1-08 | 8.8.1.1 selected `clause/2` result is unified with head/body | covered | Strict test `pins behavior-changing Technical Corrigendum 1 corrections`. |
+| C1-09 | 8.9.4.1 `abolish/1` note wording | editorial | Singular/plural note correction only. |
+| C1-10 | 8.10.3.4 set-order example | superseded | Corrigendum 3 explicitly restores the original example; current behavior follows Corrigendum 3. |
+| C1-11 | 8.13.3.4 `put_byte/1-2` example values | editorial | Examples corrected; byte-output semantics are covered by the strict 8.13 audit. |
+| C1-12 | 8.14.1.4 input-stream names and post-syntax-error example state | editorial | Examples corrected; read-stream behavior is covered by strict term-I/O tests. |
+| C1-13 | 8.14.4.1 selected `current_op/3` result is unified with its arguments | covered | Strict test `pins behavior-changing Technical Corrigendum 1 corrections`. |
+| C1-14 | 8.16.4 `atom_chars/2` accepts a matching supplied list prefix | covered | Strict test `pins behavior-changing Technical Corrigendum 1 corrections`. |
+| C1-15 | 8.16.5 `atom_codes/2` accepts a matching supplied list prefix | covered | Strict test `pins behavior-changing Technical Corrigendum 1 corrections`. |
+| C1-16 | 9.1.4.1 and 9.1.7 arithmetic notes/examples | editorial | Corrected examples and reference; corresponding arithmetic operations are covered by the Clause 9 matrix. |
+| C1-17 | 9.3.5.4 and 9.3.6.4 transcendental example constants | editorial | Example constants only; `exp/1` and `log/1` have executable strict coverage. |
+| C1-18 | 9.4.1-9.4.4 example error terms | editorial | Corrected examples; evaluable-functor and integer-operand errors are covered by strict Clause 9 tests. |
+
+## Technical Corrigendum 2:2012
+
+| Audit ID | Clauses / amendment cluster | Disposition | EyeProlog evidence |
+| --- | --- | --- | --- |
+| C2-01 | 6.3.4, 6.4, 6.5 bar token/operator rules and protected `[]`/`{}` operators | covered | WG17 lexical output cases, `corrigenda_bar_operator`, and strict `op/3` tests. |
+| C2-02 | 6.3.4.4 predefined unary plus and `div` operators | covered | Strict predefined-operator and arithmetic tests. |
+| C2-03 | 7.1.1.5 witness-variable list | covered | `term_variables/2`, read-option traversal, and variable-order tests. |
+| C2-04 | 7.1.6.9 list-prefix definition | covered | Atomic-conversion partial/improper-list tests. |
+| C2-05 | 7.8.3.4 complete term-to-body error culprit for `call/1` | covered | Strict 7.8 callability and recursive body-conversion tests. |
+| C2-06 | 7.8.9 `catch/3` catches errors arising from its protected goal | covered | `corrigenda_catch_callability` and strict exception tests. |
+| C2-07 | 7.9 typed evaluable-operand error selection | covered | Strict Clause 7.9/9 operand-template tests. |
+| C2-08 | 7.12.2 pair/order domains and uninstantiation error class | covered | Strict error envelope and Corrigendum-specific output-argument tests. |
+| C2-09 | 8.1.3 output-mode arguments use uninstantiation errors | covered | Strict `open/4` output argument test. |
+| C2-10 | 8.2.4 `subsumes_term/2` | covered | Strict registry and Corrigendum term-predicate tests. |
+| C2-11 | 8.3.9-8.3.11 `callable/1`, `ground/1`, `acyclic_term/1` | covered | Strict registry/type tests and `corrigenda_term_predicates`. |
+| C2-12 | 8.4.2-8.4.4 `compare/3`, `sort/2`, `keysort/2` | covered | Strict mode/error rows and `corrigenda_sort_keysort`. |
+| C2-13 | 8.5.5 `term_variables/2` | covered | Strict mode/error rows and `corrigenda_term_predicates`. |
+| C2-14 | 8.9.3 static `retract/1` uses modify permission | covered | Strict database predicate error tests. |
+| C2-15 | 8.9.5 `retractall/1` | covered | Strict lifetime/error tests and `corrigenda_retractall`. |
+| C2-16 | 8.11.5 non-variable `open/4` stream result | covered | Strict uninstantiation-error test. |
+| C2-17 | 8.14.3 protected operator priority/specifier combinations | covered | Strict `op/3` row audit and bar-operator cases. |
+| C2-18 | 8.15.4 `call/2..8` and implementation-dependent higher arities | covered | Strict closure expansion, error, and selected ceiling tests. |
+| C2-19 | 8.15.5 `false/0` | covered | Strict registry, execution, and static-procedure protection tests. |
+| C2-20 | 8.16.4-8.16.8 atomic/number conversion partial-list errors | covered | Individual strict mode/error assertions for all four predicates. |
+| C2-21 | 9.1 unary plus and flooring integer `div/2` | covered | Strict arithmetic matrix and negative-operand distinction from `//2`. |
+| C2-22 | 9.3 `max/2`, `min/2`, `^/2`, inverse trig, `atan2/2`, `tan/1`, and `pi/0` | covered | Strict evaluable-functor matrix and exceptional-value tests. |
+| C2-23 | 9.4.6 `xor/2` | covered | Strict signed bitwise and operand-type tests. |
+
+## Technical Corrigendum 3:2017
+
+| Audit ID | Clauses / amendment cluster | Disposition | EyeProlog evidence |
+| --- | --- | --- | --- |
+| C3-01 | 5.5.12 implementation-specific options and their error classification | covered | Strict option surfaces reject normal-only options and exercise variable/domain distinctions. |
+| C3-02 | 6.2.1 optional final layout text | covered | Strict test `pins behavior-changing Technical Corrigendum 3 corrections`. |
+| C3-03 | 7.1.6.3 iterated-goal term uses structural form rather than unification | covered | Strict `bagof/3`/`setof/3` grouping and error tests. |
+| C3-04 | 7.8.3 `call/1` applies term-to-body conversion before execution | covered | Strict call/cut-scope and variable-body conversion regressions. |
+| C3-05 | 7.10.3 read-option unification and left-to-right variable traversal | covered | Corrigendum 3 metadata traversal tests. |
+| C3-06 | 7.10.4 `variable_names/1` write option | covered | Strict test `pins behavior-changing Technical Corrigendum 3 corrections` and file-based writer case. |
+| C3-07 | 7.10.5 variable, list, curly, functional, and operator writing rules | covered | Strict writer suite and exact WG17 writer assertions. |
+| C3-08 | 7.12.2 error-classification set corrections | editorial | Corrected type/domain/permission enumerations are reflected by individual strict errors. |
+| C3-09 | 8.1.2/8.1.3 option-list modes and component-variable errors | covered | Strict open/close/read/write option-list assertions. |
+| C3-10 | 8.5.1.4 conditional `max_arity` example | editorial | Example disposition is documented; EyeProlog selects `max_arity=unbounded`. |
+| C3-11 | 8.9.2.1 assertion-description variable correction | editorial | Metavariable typo only; `assertz/1` conversion behavior is strictly tested. |
+| C3-12 | 8.10.3.4 restores the original set-order example | superseded | Supersedes C1-10; current grouped-solution order is tested and documented as implementation dependent where permitted. |
+| C3-13 | 8.11.4.1 explicit success of `set_output/1` | covered | Strict stream-selection success test. |
+| C3-14 | 8.11.5, 8.11.6, 8.14.1, 8.14.2 option-list error rewrites | covered | Individual strict option instantiation/list/domain assertions. |
+| C3-15 | 8.14.1.1 corrected syntax reference | editorial | Reference correction only; read-term syntax errors are executable. |
+| C3-16 | 8.14.2.4 canonical-list and option-error examples | covered | Canonical list output, variable option, and invalid option tests. |
+| C3-17 | 8.17.1.4 unknown flag uses the `prolog_flag` domain | covered | Strict `set_prolog_flag/2` unknown-flag test. |
+| C3-18 | 9.3.1.3 arithmetic metavariable correction | editorial | Metavariable typo only. |
+| C3-19 | 9.3.10 negative integer exponent requires a float base | covered | Strict test `pins behavior-changing Technical Corrigendum 3 corrections`. |
+
+## Closure rule
+
+The three Corrigenda rows in `ISO-COMPLIANCE.md` may be marked `covered` only
+while this complete stable-ID inventory passes its structural regression and
+every behavior-changing row retains executable evidence. Editorial and
+superseded rows are explicit dispositions rather than silently omitted tests.

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -119,7 +119,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |
 | 5.5.5 Directives | `module/2`, `use_module/1-2`, `meta_predicate/1` and normal-profile library behavior | Rejected as implementation-specific Part 1 directives. |
 | 5.5.6 Side effects | Normal mode adds `statistics/0-2`, cleanup/library state, and optional proof/statistics host instrumentation. | The strict registry excludes Prolog-visible statistics/cleanup/library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. Host proof/statistics collection observes execution through the embedding API rather than adding a strict Prolog goal effect. **covered** — strict registry/execution regression. |
-| 5.5.7 Control constructs | `tnot/1` and normal-profile execution optimizations | `tnot/1` and the normal-profile explicit `table` declaration are absent. |
+| 5.5.7 Control constructs | `tnot/1`, `wfs_truth/2`, and normal-profile execution optimizations | `tnot/1`, `wfs_truth/2`, and the normal-profile explicit `table` declaration are absent. |
 | 5.5.8 Flags | `occurs_check` | Absent in strict mode. |
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and bundled-library autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |

package/test/conformance/ISO-PROCESSOR-REQUIREMENTS.md

@@ -40,7 +40,7 @@ certification claim.
 | 5.5.4 additional term types | covered | the normal JavaScript API's `stringTerm(Text)` is documented as an implementation-specific sixth term type, including disjointness, ordering, clause conversion, lack of source token syntax, expression behavior, and writing; strict program/goal entry rejects that type with `representation_error(term)` |
 | 5.5.5 additional directives | covered | normal module/library directives are documented implementation-specific features and are rejected by strict mode |
 | 5.5.6 additional side effects | covered | normal-profile `statistics/0-2`, cleanup/library state, proof/statistics host instrumentation, and other extension effects are documented outside the Part 1 core; strict registry tests exclude the Prolog-visible statistics/cleanup extensions. Host instrumentation is an embedding observation rather than an extra strict Prolog goal effect |
-| 5.5.7 additional control constructs | covered | `tnot/1` and implementation-specific execution optimizations are absent/disabled in strict mode; standard control constructs remain separately audited |
+| 5.5.7 additional control constructs | covered | `tnot/1`, `wfs_truth/2`, and implementation-specific execution optimizations are absent/disabled in strict mode; standard control constructs remain separately audited |
 | 5.5.8 additional flags | covered | normal `occurs_check` extension is absent from strict mode; the Part 1 flag family is fully audited |
 | 5.5.9 additional built-in predicates and error forms | covered | strict registry excludes normal-profile library/native additions; `ISO-BUILTIN-MODE-ERROR-MATRIX.md` closes the complete 8.2-8.17 family row-by-row; simultaneous-error choices are documented per 7.12 rather than treated as a global table-order mandate |
 | 5.5.10 additional evaluable functors/types | covered | strict mode rejects the normal-profile evaluable `e` extension while retaining the full Part 1 + Corrigenda arithmetic set. `ISO-EVALUABLE-FUNCTOR-MATRIX.md` now closes the Clause 9 semantic/error audit and pins the 9.1.4.2 `resultF`, mixed-type `max/2`/`min/2`, and signed bitwise/shift choices. Post-N289 STC #75 remains separate from the published baseline |
@@ -50,7 +50,7 @@ certification claim.
 
 The production audit is kept here rather than in another status file. The strict
 regression gate covers the following families directly, while the complete WG17
-matrix supplies the detailed independent syntax cases.
+matrix supplies detailed externally sourced syntax expectations.
 
 | Clause family | Disposition | Executable evidence |
 | --- | --- | --- |

package/test/conformance/README.md

@@ -14,6 +14,10 @@ tracks the row-by-row built-in audit,
 closes 7.4-7.8, [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md)
 closes 7.9/Clause 9, and [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md)
 decomposes the Clause 5 processor obligations.
+[ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) gives every published
+Corrigenda amendment cluster an executable, editorial, or superseded
+disposition. Built-in rows may group closely related conditions only when the
+row names every grouped condition and its executable evidence.
 The exit checklist is embedded in [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md). [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 [STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
@@ -31,9 +35,9 @@ Clause 9 evaluable functors. Public comparison material remains supporting revie
 evidence rather than a duplicated vendored corpus. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as explicit
-tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core
+tabling, `tnot/1` well-founded negation, and `wfs_truth/2` inspection are outside the Part 1 strict-core
 claim. Their focused semantic coverage lives primarily in regression tests;
-`tnot/1` is absent from the strict ISO registry. The processor character set is documented as the Unicode scalar repertoire with
+`tnot/1` and `wfs_truth/2` are absent from the strict ISO registry. The processor character set is documented as the Unicode scalar repertoire with
 scalar-value collation in both normal and strict profiles; `--iso-strict`
 therefore changes only implementation-specific language facilities, not this
 implementation-defined processor choice.

package/test/run-iso-strict.mjs

@@ -28,6 +28,50 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(result.stdout, 'p(1).\n', 'stdout');
   });
 
+  reporter.test('pins behavior-changing Technical Corrigendum 1 corrections', () => {
+    equal(run('', { isoStrict: true, goal: 'X is sqrt(0), X =:= 0.0' }).stats.completed_goal_lists,
+      1, 'non-negative square-root boundary');
+    equal(run('', {
+      isoStrict: true,
+      goal: "atom_chars('North',['N'|Tail]), Tail == [o,r,t,h]",
+    }).stats.completed_goal_lists, 1, 'atom_chars/2 accepts a supplied list prefix');
+    equal(run('', {
+      isoStrict: true,
+      goal: "atom_codes('North',[78|Tail]), Tail == [111,114,116,104]",
+    }).stats.completed_goal_lists, 1, 'atom_codes/2 accepts a supplied list prefix');
+
+    const source = [
+      ':- dynamic(p/1).',
+      'p(a).',
+      'p(b).',
+      ':- op(500, xfy, likes).',
+      ':- set_prolog_flag(double_quotes, atom).',
+      'double_quote_operator :- (alice "likes" bob) = likes(alice,bob).',
+      '',
+    ].join('\n');
+    equal(run(source, { isoStrict: true, goal: 'clause(p(X),true), X == a' }).stats.completed_goal_lists,
+      1, 'clause/2 unifies the selected clause');
+    equal(run(source, { isoStrict: true, goal: 'current_op(500,xfy,likes)' }).stats.completed_goal_lists,
+      1, 'current_op/3 unifies the selected operator');
+    equal(run(source, { isoStrict: true, goal: 'double_quote_operator' }).stats.completed_goal_lists,
+      1, 'double-quoted atom receives its operator priority');
+  });
+
+  reporter.test('pins behavior-changing Technical Corrigendum 3 corrections', () => {
+    const trailingLayout = Program.parse('p.\n  % trailing layout is a complete Prolog text\n', {
+      isoStrict: true,
+    });
+    equal(Boolean(trailingLayout.findGroup('p', 0)), true, 'optional final layout text');
+
+    const written = run('', {
+      isoStrict: true,
+      goal: "write_term(pair(X,X),[variable_names(['Named'=X])])",
+    });
+    includes(written.stdout, 'pair(Named,Named)', 'write variable_names/1');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 2^(-1)' })).formal,
+      'type_error(float)', 'negative integer exponent correction');
+  });
+
   reporter.test('keeps Corrigendum 2 core predicates and excludes Part 3 phrase', () => {
     const registry = createStrictIsoRegistry();
     equal(Boolean(registry.get('subsumes_term', 2)), true, 'subsumes_term/2');

package/test/run-regression.mjs

@@ -2404,6 +2404,7 @@ c4 ?- call((!;1)).
         assertIncludes(result.stdout, '-g, --goal goal', 'stdout');
         assertIncludes(result.stdout, '-p, --proof', 'stdout');
         assertIncludes(result.stdout, '-q, --quads', 'stdout');
+        assertIncludes(result.stdout, '--quiet', 'stdout');
         assertIncludes(result.stdout, '-s, --stats', 'stdout');
         assertIncludes(result.stdout, '--portable', 'stdout');
         assertIncludes(result.stdout, '--no-autoload', 'stdout');
@@ -3821,6 +3822,19 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: '--quiet preserves goal side effects without printing answer terms',
+      run: () => {
+        const input = 'emit :- write(side_effect), nl.\n';
+        const quiet = runCli(['--quiet', '--goal', 'emit', '-'], { input });
+        assertEqual(quiet.status, 0, 'quiet exit status');
+        assertEqual(quiet.stdout, 'side_effect\n', 'quiet stdout');
+        assertEqual(quiet.stderr, '', 'quiet stderr');
+
+        const ordinary = runCli(['--goal', 'emit', '-'], { input });
+        assertEqual(ordinary.stdout, 'side_effect\nemit.\n', 'ordinary answer output remains unchanged');
+      },
+    },
     {
       name: '-g requires a goal argument',
       run: () => {
@@ -5271,6 +5285,34 @@ ${profile}`;
         assertIncludes(arithmetic, '`float_integer_part/1`, `float_fractional_part/1`', 'float-only conversion row');
       },
     },
+    {
+      name: 'published ISO Corrigenda have a complete stable audit inventory',
+      run: () => {
+        const compliance = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-COMPLIANCE.md'), 'utf8');
+        const matrix = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-CORRIGENDA-MATRIX.md'), 'utf8');
+        const expected = [
+          ...Array.from({ length: 18 }, (_, index) => `C1-${String(index + 1).padStart(2, '0')}`),
+          ...Array.from({ length: 23 }, (_, index) => `C2-${String(index + 1).padStart(2, '0')}`),
+          ...Array.from({ length: 19 }, (_, index) => `C3-${String(index + 1).padStart(2, '0')}`),
+        ];
+        const rows = matrix.split('\n')
+          .filter((line) => /^\| C[123]-\d\d \|/.test(line))
+          .map((line) => line.split('|').slice(1, -1).map((cell) => cell.trim()));
+        assertEqual(rows.map(([id]) => id).join(','), expected.join(','), 'Corrigenda stable audit IDs');
+        for (const [id, clauses, disposition, evidence] of rows) {
+          assertEqual(Boolean(clauses), true, `${id} clause/amendment cluster`);
+          assertEqual(['covered', 'editorial', 'superseded'].includes(disposition), true, `${id} disposition`);
+          assertEqual(Boolean(evidence), true, `${id} evidence`);
+          if (disposition === 'covered') {
+            assertEqual(/test|WG17|strict|case/i.test(evidence), true, `${id} executable evidence`);
+          }
+        }
+        assertIncludes(compliance, '[ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md)', 'Corrigenda matrix link');
+        for (const corrigendum of ['Corrigendum 1', 'Corrigendum 2', 'Corrigendum 3']) {
+          assertIncludes(compliance, `| ${corrigendum} | covered |`, `${corrigendum} covered row`);
+        }
+      },
+    },
     {
       name: 'ISO 7.4-7.8 execution matrix is closed',
       run: () => {
@@ -5299,6 +5341,16 @@ ${profile}`;
         ]) assertIncludes(compliance, row, row);
         assertIncludes(processor, '## Clause 6 syntax-preservation closure', 'Clause 6 closure map');
         assertIncludes(processor, '| 5.5.1 syntax extensions preserve standard token/text meaning | covered |', '5.5.1 covered');
+
+        const boundary = compliance.slice(
+          compliance.indexOf('## Strict-core boundary'),
+          compliance.indexOf('## Release gate'),
+        );
+        assertIncludes(boundary, '`wfs_truth/2`', 'strict boundary includes wfs_truth/2');
+        assertIncludes(boundary, 'integer digit separators', 'strict boundary includes digit separators');
+        assertIncludes(boundary, '`"text"||Tail`', 'strict boundary includes double-bar list splicing');
+        assertEqual((boundary.match(/`tnot\/1`/g) ?? []).length, 1, 'strict boundary lists tnot/1 once');
+        assertEqual(compliance.includes('`stringTerm/1` term type'), false, 'JavaScript stringTerm uses call notation');
       },
     },
     {
@@ -5311,7 +5363,7 @@ ${profile}`;
           '| Clause 7 semantic requirements have explicit dispositions | covered |',
           '| Clause 8 built-in modes/errors have explicit dispositions | covered |',
           '| Clause 9 evaluable-functor requirements have explicit dispositions | covered |',
-          '| Independent external syntax corpus is an offline release gate | covered |',
+          '| Externally sourced syntax corpus is an offline release gate | covered |',
           '| No unexplained deviation remains in the release-facing ledger | covered |',
         ]) assertIncludes(exit, item, item);
         assertNotIncludes(exit, '| audit |', 'no release-facing audit rows remain');
@@ -6726,7 +6778,7 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 221, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 222, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS predicates, and generic library adapters');
         assertEqual(registry.get('eyeprolog__dynify', 1), null, 'Eyelet dynify adapter is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__dynify', 1)), true, 'Eyelet dynify adapter is an internal EyeProlog library primitive');
         assertEqual(registry.get('eyeprolog__eyelet_emit', 2), null, 'Eyelet event adapter is absent from the ISO registry');
@@ -6743,6 +6795,8 @@ answer(ok) :-
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
         assertEqual(registry.get('tnot', 1), null, 'tnot/1 is absent from the ISO registry');
         assertEqual(Boolean(library.get('tnot', 1)), true, 'tnot/1 is an EyeProlog WFS extension');
+        assertEqual(registry.get('wfs_truth', 2), null, 'wfs_truth/2 is absent from the ISO registry');
+        assertEqual(Boolean(library.get('wfs_truth', 2)), true, 'wfs_truth/2 is an EyeProlog WFS extension');
         assertEqual(registry.get('time', 1), null, 'time/1 is absent from the ISO registry');
         assertEqual(Boolean(library.get('time', 1)), true, 'time/1 is an EyeProlog timing extension');
         assertEqual(registry.get('dif', 2), null, 'dif/2 is absent from the strict ISO core registry');
@@ -7807,6 +7861,50 @@ undefined_case :- tnot(win(c)).
         assertEqual(run(source, { goal: 'undefined_case' }).stdout, '', 'tnot of an undefined WFS atom is not a successful answer');
       },
     },
+    {
+      name: 'wfs_truth exposes three-valued results without executing undefined goals',
+      run: () => {
+        const source = `
+:- use_module(library(tabling)).
+:- table(win/1).
+move(a, b).
+move(c, d).
+move(d, c).
+win(X) :- move(X, Y), tnot(win(Y)).
+`;
+        assertEqual(run(source, { goal: 'wfs_truth(win(a), Truth)' }).stdout,
+          'wfs_truth(win(a), true).\n', 'true WFS atom');
+        assertEqual(run(source, { goal: 'wfs_truth(win(b), Truth)' }).stdout,
+          'wfs_truth(win(b), false).\n', 'false WFS atom');
+        const undefinedResult = run(source, { goal: 'wfs_truth(win(c), Truth)' });
+        assertEqual(undefinedResult.stdout, 'wfs_truth(win(c), undefined).\n', 'undefined WFS atom');
+        assertEqual(undefinedResult.stats.wfs_undefined_answers, 1, 'undefined truth inspection is counted');
+        assertEqual(run(source, { goal: 'wfs_truth(win(c), true)' }).stdout, '', 'truth filter can reject undefined');
+        let nongroundError = null;
+        try {
+          run(source, { goal: 'wfs_truth(win(X), Truth)' });
+        } catch (error) {
+          nongroundError = error;
+        }
+        assertEqual(nongroundError?.formal, 'instantiation_error', 'inspected goal must be ground');
+
+        const moduleSource = `
+:- module(cycle, [status/1]).
+:- use_module(library(tabling)).
+:- table(a/0).
+:- table(b/0).
+a :- tnot(b).
+b :- tnot(a).
+status(Truth) :- wfs_truth(a, Truth).
+`;
+        assertEqual(run(moduleSource, { goal: 'cycle:status(Truth)' }).stdout,
+          'cycle:status(undefined).\n', 'lexical module qualification');
+        assertEqual(run(moduleSource, { goal: 'wfs_truth(cycle:a, Truth)' }).stdout,
+          'wfs_truth(cycle:a, undefined).\n', 'explicit module qualification');
+        assertEqual(run(moduleSource, { goal: 'tnot(cycle:a)' }).stdout, '',
+          'qualified tnot preserves undefined failure');
+      },
+    },
     {
       name: 'undefined WFS goals do not run continuations or print CLI answers',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1147,6 +1147,16 @@ Here neither `win(a)` nor `win(b)` is unconditionally established; both belong
 to the undefined part of the well-founded model. EyeProlog retains that state
 internally but does not expose undefined atoms as successful query answers or
 run the remaining goals of a conjunction through them.
+Use `wfs_truth/2` when the truth state itself is data:
+
+```text
+?- wfs_truth(win(a), Truth).
+   Truth = undefined.
+```
+
+The inspected goal must be ground. The predicate reports `true`, `false`, or
+`undefined`; reporting `undefined` is a successful result of `wfs_truth/2`, not
+a successful execution of the inspected goal.
 Direct calls to `tnot/1` must be ground. In WFS rules, variables occurring in
 the head or a negated literal must be range-restricted by positive body
 literals. Ordinary `\+/1` is unchanged, and strict ISO mode does not provide
@@ -5951,8 +5961,9 @@ declaration; they never opt an undeclared predicate into tabling.
 
 Ordinary `\+/1` remains ISO-style negation as failure. The separate `tnot/1`
 extension explicitly requests well-founded evaluation for eligible finite,
-range-restricted Datalog dependencies. Strict ISO mode exposes neither `table`
-nor `tnot/1`.
+range-restricted Datalog dependencies. `wfs_truth/2` reports the three-valued
+state of a ground callable as `true`, `false`, or `undefined`. Strict ISO mode
+exposes none of `table`, `tnot/1`, or `wfs_truth/2`.
 
 #### Query execution
 
@@ -6359,9 +6370,9 @@ or observability. The ISO and library catalogs therefore cover **523 distinct pr
 re-exported by a compatibility module is counted once in this library surface:
 for example `call_cleanup/2` and `setup_call_cleanup/3` are exported by
 `library(iso_ext)`, while `time/1` and `statistics/2` are available from
-`library(time)`. `statistics/0` and `tnot/1` remain normal-runtime extensions
-outside the library catalog. These additions are absent from the strict ISO
-registry.
+`library(time)`. `statistics/0`, `tnot/1`, and `wfs_truth/2` remain
+normal-runtime extensions outside the library catalog. These additions are
+absent from the strict ISO registry.
 
 The sources are `src/lib/aggregate.pl`, `src/lib/arithmetic.pl`,
 `src/lib/assoc.pl`, `src/lib/atts.pl`, `src/lib/between.pl`,
@@ -9375,6 +9386,8 @@ eyeprolog --goal 'ancestor(ada, Who)' examples/ancestor.pl
 
 Repeat `-g` or `--goal` to request several result relations in one run. EyeProlog prints
 their ground answers in the order the goals were supplied.
+Use `--quiet` for command-style goals: Prolog output such as `write/1` remains
+visible, while the resolved answer terms are suppressed.
 
 For a self-running example, place the host goal in an ordinary comment:
 
@@ -9396,6 +9409,7 @@ make the observed question explicit.
 | `--proof-detail abstract|expanded` | Select library abstraction for proof output; implies `--proof` |
 | `--verify-proof File` | Verify saved `why/2` proof certificates against the input program without proof search |
 | `-q`, `--quads` | Run embedded quad tests and fail if any do not hold |
+| `--quiet` | Suppress resolved answer terms while preserving Prolog output and diagnostics |
 | `--iso-strict` | Restrict parsing and execution to ISO/IEC 13211-1:1995 + Corrigenda 1–3; reject EyeProlog language extensions (including `table` and `:+`) and disable bundled-library autoloading |
 | `--portable` | Enforce the conservative EyeProlog/Trealla/Scryer interoperability profile |
 | `--no-autoload` | Disable bundled-library predicate autoloading |