eyeprolog 1.5.24 → 1.5.26

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, both Claim and tnot(Claim) conditionally succeed when
-% the truth value is undefined.  That lets this example expose all three states.
-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/index.d.ts

@@ -1,7 +1,7 @@
 export interface EyePrologStats {
   /** Alternating-fixed-point rounds used to build WFS models. */
   wfs_fixpoint_rounds: number;
-  /** Undefined WFS answers observed while producing query results. */
+  /** Undefined WFS atoms encountered while resolving query goals. */
   wfs_undefined_answers: number;
   [key: string]: number;
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.24",
+  "version": "1.5.26",
   "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

@@ -909,14 +909,37 @@ export class Solver {
         if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
       }
       if (!ok) continue;
-      if (!lower?.has(row)) this.stats.wfs_undefined_answers++;
+      if (!lower?.has(row)) {
+        this.stats.wfs_undefined_answers++;
+        continue;
+      }
       yield* this.solve(rest, next, depth + 1);
       if (this.solutionsSeen >= this.solutionLimit) return;
     }
   }
 
   *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);
@@ -925,22 +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++;
-      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) {
@@ -1523,7 +1542,10 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
       if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
     }
     if (!ok) continue;
-    if (!lower?.has(row)) solver.stats.wfs_undefined_answers++;
+    if (!lower?.has(row)) {
+      solver.stats.wfs_undefined_answers++;
+      continue;
+    }
     stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
   }
 }

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-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 |

package/test/conformance/README.md

@@ -31,9 +31,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-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: () => {
@@ -6726,7 +6740,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 +6757,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');
@@ -7782,9 +7798,9 @@ win(X) :- move(X, Y), tnot(win(Y)).
         assertEqual(program.findGroup('win', 1).wfsDatalog, true, 'win/1 uses finite WFS evaluation');
         assertEqual(program.findGroup('win', 1).tabled, false, 'win/1 is not positive least-model tabled');
         const result = run(program, { goal: 'win(X)' });
-        assertEqual(result.stdout.trim().split('\n').length, 4, 'negative cycle yields four conditional WFS answers');
+        assertEqual(result.stdout, '', 'negative cycle does not expose undefined atoms as successful answers');
         assertEqual(result.stats.wfs_fixpoint_rounds, 2, 'alternating fixed point converges in two rounds');
-        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle answers are undefined rather than unconditional truths');
+        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle atoms are observed as undefined rather than unconditional truths');
 
         const nafProgram = Program.parse('p(X) :- \\+ q(X).\nq(X) :- p(X).\n');
         assertEqual(nafProgram.findGroup('p', 1).wfsDatalog, false, '\\+/1 remains ordinary negation as failure');
@@ -7804,7 +7820,67 @@ undefined_case :- tnot(win(c)).
 `;
         assertEqual(run(source, { goal: 'true_case' }).stdout, 'true_case.\n', 'win(a) is true because b is false');
         assertEqual(run(source, { goal: 'false_case' }).stdout, '', 'tnot(win(a)) fails for a true atom');
-        assertEqual(run(source, { goal: 'undefined_case' }).stdout, 'undefined_case.\n', 'tnot of an undefined WFS atom is a conditional success');
+        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: () => {
+        const source = `
+:- use_module(library(tabling)).
+:- table(a/0).
+:- table(b/0).
+a :- tnot(b).
+b :- tnot(a).
+`;
+        const result = run(source, { goal: 'a, write(true), nl; halt' });
+        assertEqual(result.stdout, '', 'undefined first branch neither writes nor produces a ground answer');
+        assertEqual(result.haltCode, 0, 'fallback halt branch runs');
+        assertEqual(result.stats.wfs_undefined_answers, 1, 'undefined atom remains observable in statistics');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1144,8 +1144,19 @@ win(X) :- move(X, Y), tnot(win(Y)).
 ```
 
 Here neither `win(a)` nor `win(b)` is unconditionally established; both belong
-to the undefined part of the well-founded model. EyeProlog exposes undefined
-WFS answers as conditional successes, including inside finite collectors.
+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
@@ -1664,8 +1675,8 @@ The reported counters include completed goal lists, calls to the goal solver
 and single-goal solver, unification attempts, maximum depth and goal-list size,
 deterministic built-in successes and failures, and table fixed-point rounds.
 WFS execution additionally reports `wfs_fixpoint_rounds` and
-`wfs_undefined_answers`. The latter counts undefined-answer observations made
-while producing query results; it is an execution statistic, not a declaration
+`wfs_undefined_answers`. The latter counts undefined atoms encountered while
+resolving query goals; it is an execution statistic, not a declaration
 that those atoms are true. All statistics describe work performed, not logical
 truth. Compare counters only across equivalent queries and the same
 implementation version.
@@ -5950,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
 
@@ -6358,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`,
@@ -9374,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:
 
@@ -9395,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 |