eyeprolog 1.3.58 → 1.3.60

package/README.md

@@ -226,7 +226,14 @@ precedence for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`, and
 the complete Part 1 flag defaults/value domains/changeability rules. The
 ongoing issue #65 audit additionally tightens Prolog-text declaration ordering,
 initialization lifetime, stream/open/close behavior, character/byte stream
-errors, `keysort/2` error cases, and strict arithmetic-extension boundaries.
+errors, `keysort/2` error cases, the now-closed 5.5.6 side-effect and 5.5.10 evaluable-functor strict
+extension boundaries, and the standard's permitted arithmetic variation points: mixed-type Corrigendum 2
+`max/2`/`min/2` and signed Clause 9.4 bitwise/shift behavior. The row-level
+7.1-7.3 term-semantics audit and 7.9/Clause 9 expression/evaluable-functor
+audit are now closed as well. That arithmetic pass also corrected float-only
+`float_integer_part/1` and `float_fractional_part/1`: an integer operand, even
+a huge valid unbounded integer, now reaches `type_error(float,...)` before any
+integer-to-float overflow.
 Those additions improve the Part 1 surface without turning the remaining audit
 rows into a blanket conformance claim. The post-N289 WG17/STC working draft is
 reviewed separately rather than treated as a fourth Corrigendum. The
@@ -236,10 +243,20 @@ proposal that would make the two power-underflow rows depend on the processor's
 9.1.4.2 `resultF` choice. Strict mode retains the published Part 1 +
 Corrigenda 1-3 behavior where the draft has not been standardized.
 
+As an additional 5.5.1 extension-safety gate, every vendored WG17 syntax case
+that succeeds in the strict Part 1 reader is re-run in the normal profile and
+must retain the same observable outcome; normal mode may accept extra extension
+syntax, but it must not reinterpret text already accepted as standard syntax.
+
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
 The ISO 5.4 implementation-defined/implementation-specific decision index is
 [`test/conformance/ISO-IMPLEMENTATION-DEFINED.md`](test/conformance/ISO-IMPLEMENTATION-DEFINED.md).
+The closed term and arithmetic row audits are
+[`ISO-TERM-SEMANTICS-MATRIX.md`](test/conformance/ISO-TERM-SEMANTICS-MATRIX.md) and
+[`ISO-EVALUABLE-FUNCTOR-MATRIX.md`](test/conformance/ISO-EVALUABLE-FUNCTOR-MATRIX.md);
+[`ISO-EXIT-CRITERIA.md`](test/conformance/ISO-EXIT-CRITERIA.md) states the remaining
+normative and external-corpus exit conditions.
 The separate [WG17 syntax ledger](test/conformance/WG17-SYNTAX-STATUS.md)
 records executable dispositions for the vendored active upstream WG17 syntax
 cases and runs as part of `npm test`. Reviewed cases can pin exact outcomes;

package/package.json

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

package/src/iso-arithmetic.js

@@ -71,10 +71,18 @@ function evaluateOperation(term, args, options = {}) {
   if (arity === 1 && ['abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
     'float_integer_part', 'float_fractional_part',
     'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt'].includes(name)) {
-    // The four float-to-integer rounding functors have only F->I operators
-    // (9.1.1/9.1.6). Corrigendum 1/2 therefore requires type_error(float,...)
-    // when their evaluated argument has integer type.
-    if (options.isoStrict === true && ['truncate', 'round', 'ceiling', 'floor'].includes(name) && args[0].integer) {
+    // These six conversion/rounding functors have float-only input templates
+    // in 9.1.1/9.1.6. They therefore require type_error(float,...) when their
+    // evaluated argument has integer type, before any I->F conversion.
+    if (options.isoStrict === true && [
+      'truncate', 'round', 'ceiling', 'floor',
+      'float_integer_part', 'float_fractional_part',
+    ].includes(name) && args[0].integer) {
+      // These functors have only F->I or F->F templates.  In particular,
+      // float_integer_part/1 and float_fractional_part/1 must reject an
+      // integer by type before any I->F conversion is attempted; otherwise a
+      // sufficiently large (but valid, unbounded) integer can be misreported
+      // as float_overflow instead of type_error(float,...).
       throw new PrologError('type_error(float)', numericTerm(args[0]));
     }
     if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };

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

@@ -372,7 +372,9 @@ and conditional/not-applicable processor branches all have explicit outcomes.
 ISO 7.12 simultaneous-error selection remains an implementation-dependent
 processor choice unless more specific normative text constrains it.
 
-The remaining #65 work is therefore above/below this built-in table: Clause 6
-text/rejection mapping, Clause 7 processor/control semantics, Clause 9
-exceptional-value rows, residual Clause 5 dependency rows, and the external
-conversion/variable-name conformance corpora.
+The remaining #65 work is therefore above/below this built-in table. The
+7.1-7.3 term-semantics and 7.9/Clause 9 evaluable-functor rows are now closed in
+their dedicated matrices. What remains is Clause 6 text/rejection mapping,
+Clause 7.4-7.8 plus higher-level 7.10/7.12 processor/control semantics, residual
+Clause 5 dependency rows, and the external conversion/variable-name exit
+criteria recorded in `ISO-EXIT-CRITERIA.md`.

package/test/conformance/ISO-COMPLIANCE.md

@@ -7,7 +7,11 @@ Corrigenda 1:2007, 2:2012, and 3:2017. It complements
 executable tests, [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md),
 which records the row-by-row built-in audit, and
 [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md), which decomposes
-Clause 5 processor obligations. The generated [`conformance-report.md`](../../conformance-report.md)
+Clause 5 processor obligations. [ISO-TERM-SEMANTICS-MATRIX.md](ISO-TERM-SEMANTICS-MATRIX.md)
+and [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) close the
+row-level Clause 7.1-7.3 and 7.9/Clause 9 audits, while
+[ISO-EXIT-CRITERIA.md](ISO-EXIT-CRITERIA.md) makes the remaining release exit
+conditions explicit. The generated [`conformance-report.md`](../../conformance-report.md)
 gives current case totals.
 
 The ledger deliberately does **not** claim independent certification. A row
@@ -22,29 +26,29 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
 | 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the [complete vendored WG17 syntax matrix](WG17-SYNTAX-STATUS.md). Wider shall-by-shall text-processing audit remains open. |
-| 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. A normative goal-semantics ledger is still being expanded. |
+| 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. The 7.1-7.3 term-semantics, 7.9/Clause 9 arithmetic, and 8.2-8.17 built-in row audits are now closed; the dependency remains open on 7.4-7.8, higher-level 7.10, and residual processor-level 7.12 semantics. |
 | 5.1(c) reject nonconforming text/read-terms | audit | Dedicated syntax-error cases and strict-core extension rejection. Exhaustive lexical rejection coverage remains open. |
 | 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. Rows marked `audit gap` remain conformance work, but the variation is no longer undocumented. |
 | 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, disable automatic tabling/recursion guards, and reject the normal-profile host `stringTerm/1` 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 or an explicit audit gap. |
-| 5.5 extension boundaries | audit | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) now splits 5.5 into its individual extension hooks. Operators, character conversion, the normal-profile host string type, directives, control constructs, flags, and reserved atoms have explicit decisions; exhaustive syntax-preservation, side-effect, built-in, and evaluable-functor dependency mapping remains open. |
+| 5.5 extension boundaries | audit | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) splits 5.5 into its individual extension hooks. Operators, character conversion, the normal-profile host string type, directives, control constructs, flags, built-ins, evaluable functors, and reserved atoms now have explicit decisions. The remaining open extension work is now concentrated in exhaustive syntax-preservation (5.5.1); the Prolog-visible additional-side-effect boundary (5.5.6) is explicitly filtered in strict mode and host instrumentation is documented as an embedding concern. |
 
 ## Normative language families
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and Unicode-scalar PCS/collation boundary tests. The implementation-defined 6.5/6.6 character-model decisions are now closed; wider shall-by-shall lexical mapping remains open. |
-| 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates, plus strict checks for the required `variable < float < integer < atom < compound` type order, PCS-based atom collation, and the `max_arity=unbounded` compound-term model. The normal JavaScript API string term is now explicitly documented as a 5.5.4 extension and rejected at strict program/goal entry so it cannot add a sixth strict-core type. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and Unicode-scalar PCS/collation boundary tests. A cross-profile gate now verifies that every WG17 case accepted by the strict Part 1 reader has the same observable outcome under normal-mode syntax extensions. The implementation-defined 6.5/6.6 character-model decisions are closed; the remaining work is the explicit production-by-production shall map. |
+| 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 | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Preparation-time `char_conversion/2` affects later unquoted source text and respects `char_conversion=off`. Strict preparation now enforces declaration-before-clause ordering for `dynamic/1`, `multifile/1`, and `discontiguous/1`, cross-text `multifile/1`, discontiguous clause grouping, empty declared procedures, include textual-replacement behavior, and one-time initialization per prepared program. The remaining shall-by-shall mapping is still open. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access; focused strict checks cover the database built-ins and empty-procedure lifetime. Clause-body conversion now applies 7.6.2 both to prepared source clauses and runtime `asserta/1` / `assertz/1`: variables become `call/1`, `,/2`, `;/2`, and `->/2` are converted recursively, and head/body variable identity is preserved so `clause/2` and `retract/1` observe the converted term correctly. Runtime protection includes the solver-native conjunction control construct `','/2` and, following STC #56's accepted-direction action item, `(:-)/1-2` for database modification/private access while leaving their call behavior distinct. The remaining clause-conversion shall-by-shall mapping is still open. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. The 8.15 built-in slice (`\+/1`, `once/1`, `repeat/0`, Corrigendum 2 `call/2..8`, `false/0`) is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md); the remaining general control-construct semantics ledger stays open. |
-| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now pins direct-variable precedence, 7.9.2 non-evaluable `F/N` errors (including STC #69), arithmetic numeric/integer type errors, float-only rounding conversions, the Part 1 mixed integer/float comparison conversion rule, I->F overflow before floating evaluable functors (STC #42), the published `exp/1`/power underflow rows, and prescribed negative/zero power errors before later conversion overflow. Post-N289 STC #75's proposal to make the two power-underflow rows conditional on the 9.1.4.2 choice is tracked separately and is not silently substituted for the licensed baseline. Unbounded integer powers/shifts no longer leak host `RangeError`; finite-host exhaustion is normalized to `resource_error(memory)` in line with the Part 1 resource-error note and STC #21. The remaining exceptional-value/error-precedence rows are still being exhaustively enumerated. |
+| 7.9 — expression evaluation | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) closes recursive evaluation, direct-variable precedence, corrected non-evaluable `F/N` errors (including STC #69), operand template/type rules, mixed arithmetic-comparison conversion, exceptional values, and finite-host resource normalization. The audit also fixes float-only `float_integer_part/1` and `float_fractional_part/1` so even huge valid integers reach `type_error(float,...)` before any I->F overflow. |
 | 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The complete 8.11-8.14 built-in mode/error family is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), including lifecycle/current-stream handling, stream positions, text/binary permissions, EOF actions, `force(true)`, input-code representation timing, term-I/O options, operators, and character conversion. `stream_property/2` now also distinguishes a malformed stream-term (domain error) from a valid stream-term whose stream is no longer open (ordinary failure). The higher-level 7.10 source/sink, buffering, positioning, and implementation-defined stream semantics remain under shall-by-shall audit. |
 | 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 | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax/resource families and focused error cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now gives explicit mode/error-condition outcomes across the complete 8.2-8.17 built-in family, including Corrigendum additions and not-applicable conditional branches. The audit records the 7.12 rule that simultaneous error conditions are implementation dependent: overlap regressions document stable EyeProlog choices rather than inventing a universal table-order requirement. Remaining work is concentrated in non-built-in Clause 7 semantics, Clause 9 exceptional interactions, and processor-level error conditions. |
 | 8.2-8.17 — built-in predicates | covered | [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now records the complete Part 1 + Corrigenda built-in family at one row per prescribed mode, success/failure behavior, individual error condition, and conditional/not-applicable branch. The row audit exposed and fixed source/runtime 7.6.2 body conversion/variable sharing, strict host-string leakage, input-code error timing, `close/2` force handling, and closed-stream `stream_property/2` behavior. Simultaneous-error choices are documented as implementation dependent under 7.12 unless separately constrained. |
-| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, distinguishes non-evaluable `F/N` errors from numeric/integer operand errors per 7.9.2 and STC #69, and enforces float-only rounding modes, performs I->F conversion before floating functors (including overflow), reports the published `exp/1`, `**/2`, and Corrigendum 2 `^/2` underflow conditions, tracks STC #75's proposed conditional power interpretation without adopting it as published text, preserves the power-specific undefined conditions ahead of conversion overflow, and uses the Part 1 integer-to-float rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison and round-to-zero arithmetic behavior as extensions. Unbounded BigInt resource exhaustion is translated into the Prolog error model rather than leaking host exceptions. Host floating-point representation choices remain documented implementation-defined behavior; the remaining exceptional-value rows are still under audit. |
+| Clause 9 — evaluable functors | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) records the published Part 1 + Corrigenda arithmetic templates and exceptional branches across 9.1, 9.3, and 9.4. It pins the unbounded integer model, `rndI`/`rndF`/`resultF` choices, float-only conversion rules, I->F overflow, explicit `exp/1` and power underflow, Corrigendum 2 additions and mixed-type `max/2`/`min/2` implementation-dependent choice, Corrigendum 3 negative-power correction, signed bitwise/shift choices, and resource-error translation. Post-N289 STC #75 remains a separately tracked draft proposal rather than a silent change to the published baseline. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -288,18 +292,13 @@ outputs are never auto-accepted.
 
 ## Exit criteria for a full conformance claim
 
-EyeProlog should not change its public wording from “ISO profile” to “conforming
-ISO/IEC 13211-1 processor” until all of the following are true:
-
-1. every normative Part 1 processor requirement is represented in this ledger;
-2. every `audit` row above has been reduced to explicit pass/not-applicable or
-   documented implementation-defined choices;
-3. the external WG17 conversion and variable-name conformity corpora have
-   joined the now-complete syntax corpus in strict core mode, with every
-   difference explained or fixed;
-4. prescribed modes, individual error conditions, side effects, and any
-   precedence actually constrained by procedural rules or Corrigenda have
-   executable coverage, while 7.12 simultaneous-error choices are documented;
-5. every `audit gap` recorded in the ISO 5.4 decision index is either fixed or
-   explicitly excluded from the strict-conformance claim; and
-6. an external conformance run has found no unexplained deviations.
+[ISO-EXIT-CRITERIA.md](ISO-EXIT-CRITERIA.md) is now the authoritative checklist
+for moving public wording from “ISO profile” to “conforming ISO/IEC 13211-1
+processor”. It requires closure of every remaining normative `audit` row,
+reproducible offline external comparison evidence, and no unexplained deviation.
+
+The row-level 8.2-8.17 built-in audit, 7.1-7.3 term-semantics audit, and
+7.9/Clause 9 evaluable-functor audit are already closed. The checklist remains
+open because Clause 6, 7.4-7.8, higher-level 7.10/7.12, their Clause 5 dependency
+rows, and part of the external conversion/variable-name evidence are not yet
+fully reduced to explicit dispositions.

package/test/conformance/ISO-EVALUABLE-FUNCTOR-MATRIX.md

@@ -0,0 +1,91 @@
+# ISO Part 1 expression/evaluable-functor audit matrix
+
+This file is the row-level audit for Part 1 Clause 7.9 and Clause 9, including
+the arithmetic additions and corrections in Technical Corrigenda 1-3. It is
+paired with the strict regression named `closes the ISO 7.9 and Clause 9
+evaluable-functor rows`.
+
+The published ISO/IEC 13211-1:1995 + Corrigenda 1-3 text is the normative
+baseline. Post-N289 STC draft proposals are tracked separately in
+`STC-DRAFT-STATUS.md`; they do not silently replace published requirements.
+
+## 7.9 - evaluating an expression
+
+| Requirement | Status | Evidence / decision |
+| --- | --- | --- |
+| Evaluate variables | covered | direct variable operands raise `instantiation_error` before competing expression errors in strict mode |
+| Evaluate numeric constants | covered | integer and float constants retain their numeric types subject to the documented float representation |
+| Select an evaluable functor by name/arity | covered | Part 1 + Corrigenda functors are accepted; a non-evaluable term reports `type_error(evaluable,F/N)`, including the corrected zero-arity culprit shape |
+| Recursively evaluate operands | covered | nested arithmetic, arithmetic comparisons, and `is/2` suites cover recursive evaluation; EyeProlog documents its stable operand-evaluation choice where Part 1 permits implementation dependence |
+| Operand type constraints | covered | integer-only and float-only templates report the required type errors after expression evaluation |
+| Exceptional values | covered | zero divisor, undefined, float overflow, explicit underflow, and finite-host resource exhaustion are pinned in strict tests |
+
+## 9.1 - simple arithmetic and type conversion
+
+| Functor / operation family | Required templates and exceptional branches | Status | Evidence / implementation choice |
+| --- | --- | --- | --- |
+| `+/2`, `-/2`, `*/2` | integer/integer -> integer; mixed/float -> float | covered | BigInt exact integer operations; binary64 mixed/float operations; host BigInt exhaustion -> `resource_error(memory)` |
+| `/2` | numeric operands -> float; zero divisor | covered | binary64 division; zero divisor is an evaluation error |
+| `//2` | integer operands; zero divisor | covered | `integer_rounding_function=toward_zero` and BigInt truncating division |
+| `rem/2`, `mod/2` | integer operands; zero divisor | covered | sign behavior is pinned for negative operands |
+| unary `-/1` | integer or float | covered | preserves numeric type |
+| `abs/1`, `sign/1` | integer or float | covered | preserves integer results for integer operands and float results for float operands |
+| `float/1` | integer -> float; float -> float | covered | integer-to-float overflow is detected before the selected floating operation |
+| `floor/1`, `truncate/1`, `round/1`, `ceiling/1` | float -> integer only | covered | integer operands report `type_error(float,...)`; representative negative/positive rounding results are pinned |
+| `float_integer_part/1`, `float_fractional_part/1` | float -> float only | covered | integer operands report `type_error(float,...)` before any I->F conversion; regression includes huge unbounded integers so float overflow cannot mask the required type error |
+| integer model | bounded or unbounded choice | covered | `bounded=false`; semantic integer range is unbounded, with finite-host exhaustion represented as a resource error |
+| `rndI` | processor integer-division rounding choice | covered | toward zero, consistent with the fixed flag |
+| `rndF` / float representation | implementation-defined float rounding model | covered | ECMAScript IEEE-754 binary64 |
+| `resultF` | choose generic tiny-result rounding or underflow | covered | EyeProlog selects `round(x)`; representable subnormals survive and still-smaller generic arithmetic may round to `0.0` |
+| approximate addition | implementation-defined floating addition | covered | ECMAScript binary64 addition |
+
+## Corrigendum 2 simple-arithmetic additions
+
+| Functor | Status | Evidence / decision |
+| --- | --- | --- |
+| unary `+/1` | covered | identity over numeric expressions |
+| `div/2` | covered | integer floor division; negative-operand cases distinguish it from `//2` |
+
+## 9.3 - other evaluable functors
+
+| Functor family | Status | Exceptional / implementation-dependent coverage |
+| --- | --- | --- |
+| `**/2` | covered | negative-base restrictions, zero/negative exponent, float overflow, and the published explicit underflow row are pinned |
+| `sin/1`, `cos/1`, `atan/1` | covered | integer templates perform I->F conversion first; conversion overflow is detected |
+| `exp/1` | covered | float overflow and published non-zero-result underflow are pinned |
+| `log/1`, `sqrt/1` | covered | non-positive/domain-invalid values report `evaluation_error(undefined)` as applicable |
+| Corrigendum 2 `max/2`, `min/2` | covered | all type templates are supported; mixed numeric types use the documented implementation-dependent exact comparison and return one original operand, preserving its type |
+| Corrigendum 2 `^/2` plus Corrigendum 3 correction | covered | integer powers remain exact where defined; negative integer exponent/type rules, negative-base rules, zero-negative exponent, overflow, and published underflow are pinned |
+| Corrigendum 2 `asin/1`, `acos/1` | covered | valid values plus out-of-domain undefined errors |
+| Corrigendum 2 `atan2/2` | covered | numeric templates plus the zero/zero undefined condition |
+| Corrigendum 2 `tan/1` | covered | integer/float templates and I->F conversion behavior |
+| Corrigendum 2 `pi/0` | covered | strict evaluable constant is available |
+
+The 2026-08-23 post-N289 draft item #75 proposes conditioning the published
+`**/2` and `^/2` underflow rows on the processor's `resultF` choice. EyeProlog
+records that proposal but keeps the published unconditional strict behavior
+until a normative corrigendum changes the baseline.
+
+## 9.4 - bitwise functors
+
+| Functor | Status | Implementation-defined negative/signed behavior |
+| --- | --- | --- |
+| `>>/2` | covered | BigInt arithmetic/sign-propagating right shift; negative shift count reverses direction |
+| `<</2` | covered | BigInt signed left shift; negative shift count reverses direction |
+| `/\\/2` | covered | BigInt infinite-two's-complement semantics |
+| `\\//2` | covered | BigInt infinite-two's-complement semantics |
+| `\\/1` | covered | BigInt complement, equivalent to `-N-1` |
+| Corrigendum 2 `xor/2` | covered | BigInt infinite-two's-complement semantics |
+
+All 9.4 functors require integer operands; non-integers report
+`type_error(integer,...)`. Very large otherwise-valid shifts retain the
+unbounded integer model and translate finite-host exhaustion to
+`resource_error(memory)`.
+
+## Closure note
+
+With this matrix and the strict arithmetic regression, the release-facing
+Clause 7.9 and Clause 9 rows are `covered`. The remaining issue #65 audit is not
+therefore an arithmetic audit: it is concentrated in Clause 6 text/rejection,
+Clause 7.4-7.8 and 7.10/7.12 processor semantics, their Clause 5 dependencies,
+and the remaining external-corpus exit criteria.

package/test/conformance/ISO-EXIT-CRITERIA.md

@@ -0,0 +1,55 @@
+# ISO Part 1 audit exit criteria
+
+Issue #65 is intentionally closed by evidence rather than by a single large
+test count. This checklist defines what must be true before EyeProlog can remove
+the remaining qualification that its strict ISO/IEC 13211-1 profile is still
+under systematic audit.
+
+The normative baseline is ISO/IEC 13211-1:1995 plus Technical Corrigenda 1-3.
+Post-N289 STC drafts are review input only until standardized.
+
+## Exit checklist
+
+| Criterion | Status | Evidence / remaining work |
+| --- | --- | --- |
+| Clause 5 processor obligations have explicit dispositions | open | `ISO-PROCESSOR-REQUIREMENTS.md` still has dependent audit rows for preparation/execution/rejection and syntax preservation |
+| Clause 6 lexical/syntactic requirements have explicit dispositions | open | 366-case vendored WG17 syntax gate and cross-profile preservation are green, but the production-by-production shall/rejection map is not yet complete |
+| Clause 7 semantic requirements have explicit dispositions | open | 7.1-7.3 and 7.9 are now closed; 7.4-7.8, higher-level 7.10, and residual processor-level 7.12 rows remain |
+| 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 |
+| Implementation-defined choices are documented | covered | `ISO-IMPLEMENTATION-DEFINED.md` is the Clause 5.4 decision index and strict tests pin the behavior that affects execution |
+| Implementation-specific strict/normal boundary is documented and tested | open | major 5.5 hooks are closed; exhaustive 5.5.1 syntax-preservation mapping remains tied to the Clause 6 audit |
+| Published Corrigenda 1-3 are incorporated | covered | dedicated conformance/strict tests and the compliance matrix track all three published Corrigenda |
+| Current post-N289 draft is tracked without changing the published baseline silently | covered | `STC-DRAFT-STATUS.md` tracks the reviewed 2026-08-23 items #73-#76, including the deliberate published-baseline treatment of #75 |
+| Independent external syntax corpus is an offline release gate | covered | vendored active WG17 syntax matrix: 366 executable dispositions, checked against upstream expectations and reviewed exact outcomes |
+| Third-party standard-core regression evidence is retained with provenance | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases are vendored under `iso/`; `THIRD_PARTY.md` records origin and licenses |
+| Known external-corpus deviations are explained and pinned | covered for vendored gates | the Prologue `bounded=false` / `max_integer` divergence is retained as upstream material and explicitly regression-tested; WG17 rows independently validate upstream expectation before any local reviewed snapshot can pass |
+| External conversion/variable-name comparisons used during the audit are reproducible offline | open | focused behavior is already covered internally, but the remaining public comparison material has not all been normalized into a vendored offline fixture |
+| Optional cross-engine runs have no unexplained deviations | open / environment-dependent | external-engine runner evidence is useful corroboration but is not substituted for normative ISO rows; release environments without those engines record the gate as unavailable rather than silently passing it |
+| No unexplained deviation remains in the release-facing ledger | open | may become covered only when every open normative/external item above is either fixed, declared not applicable, or documented as a permitted implementation-defined/dependent choice |
+
+## What counts as an explained deviation
+
+A difference from an external corpus or another Prolog implementation is not an
+automatic conformance defect. It is explained only when the repository records
+which of these applies and has an executable regression where applicable:
+
+- EyeProlog was wrong and was fixed to the published baseline;
+- the external expectation reflects a different permitted implementation-defined
+  or implementation-dependent choice;
+- the external fixture itself targets behavior outside the published baseline;
+- a later STC draft proposes a change that is not yet a published Corrigendum;
+- the behavior is an EyeProlog implementation-specific extension excluded from
+  `--iso-strict`; or
+- the condition is genuinely not applicable to EyeProlog's declared processor
+  model.
+
+An unexplained mismatch, host exception, skipped vendored row, or documentation
+claim without executable support keeps the relevant exit criterion open.
+
+## Release use
+
+`ISO-COMPLIANCE.md` is the release-facing status ledger. This file is the exit
+checklist behind it. Closing a row here must not be inferred solely from a test
+count: the corresponding normative or external evidence must be identifiable
+and the user-facing documentation must describe the same boundary.

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

@@ -75,9 +75,9 @@ Status values are:
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso-arithmetic.js`, `src/number-value.js`. |
 | 9.1.4.2 | Floating-point result function for operations whose result is governed only by `resultF` | EyeProlog chooses `round(x)` rather than the optional exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller generic arithmetic result to `0.0`, consistently with float-token, `number_chars/2`, and `number_codes/2` input. The published Part 1 `**/2` and Corrigendum 2 `^/2` tables still contain separate unconditional underflow rows, which strict mode retains; post-N289 STC #75 proposes making those two power rows conditional on this `resultF` choice and is tracked separately as draft work. `exp/1` has its own published exceptional condition and is not the subject of STC #75. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js` and parser/number conversion; strict exceptional-value regressions. |
 | 9.1.4.3 | Approximate-addition function | ECMAScript binary64 addition is used; subtraction is implemented through the corresponding host operation and all finite results remain binary64 values. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js`. |
-| 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso-arithmetic.js` BigInt bitwise operators. |
-| 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso-arithmetic.js`. |
-| 9.4.2 | Left shift of negative integers and unusual shift counts | `<<` uses BigInt signed shift semantics; a negative count reverses direction. Resource exhaustion remains possible for very large results. | **defined** — `a << b` in `src/iso-arithmetic.js`. |
+| 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso-arithmetic.js` BigInt bitwise operators and strict Clause 9.4 boundary regressions. |
+| 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso-arithmetic.js`; strict regressions pin negative operands/counts. |
+| 9.4.2 | Left shift of negative integers and unusual shift counts | `<<` uses BigInt signed shift semantics; a negative count reverses direction. Resource exhaustion remains possible for very large results. | **defined** — `a << b` in `src/iso-arithmetic.js`; strict regressions pin negative counts and resource exhaustion. |
 | 9.4.3 | Bitwise AND with negative operands | BigInt infinite-two's-complement semantics. | **defined** — `a & b`. |
 | 9.4.4 | Bitwise OR with negative operands | BigInt infinite-two's-complement semantics. | **defined** — `a \| b`. |
 | 9.4.5 | Bitwise complement | BigInt complement, i.e. `~N = -N-1`. | **defined** — `~a`. |
@@ -118,11 +118,11 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 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 | Host output/statistics, library-specific state, proof/statistics collection | The strict registry excludes library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. |
+| 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` is absent; automatic tabling/recursion guards are disabled. |
 | 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 interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
-| 5.5.10 Evaluable functors | Library/runtime extensions when registered outside the strict core | Strict arithmetic registry is the Part 1 + Corrigenda set. |
+| 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`. |
 | 5.5.11 Reserved atoms | None | None. |
 | Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` option `double_quotes(true|false)`. Strict core excludes that extension and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
@@ -139,6 +139,7 @@ For portability work, EyeProlog also documents these choices even though the
 - distinct variables are ordered by first encounter within the operation that
   needs a stable ordering;
 - expression arguments are evaluated left-to-right by the JavaScript evaluator;
+- Corrigendum 2 mixed integer/float `max/2` and `min/2` use exact mathematical comparison and return one of the original operands without forcing integer-to-float conversion; equal values choose the left operand, so its original numeric type is preserved. EyeProlog does not elect the optional mixed-type `undefined` or `float_overflow` outcomes solely because the operand types differ;
 - generated variable names use EyeProlog's stable `_A`, `_B`, ... style within
   a write operation/top-level query;
 - resource and syntax-error detail atoms are EyeProlog implementation details;

package/test/conformance/ISO-MATRIX.md

@@ -5,11 +5,14 @@ Technical Corrigenda 1:2007, 2:2012, and 3:2017. This matrix links the standard
 families to executable coverage; `conformance-report.md` supplies the generated
 case totals. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) tracks the processor-level
 compliance audit and the remaining work before a full conformance claim.
+`ISO-TERM-SEMANTICS-MATRIX.md` and `ISO-EVALUABLE-FUNCTOR-MATRIX.md` provide
+the closed row-level Clause 7.1-7.3 and 7.9/Clause 9 ledgers;
+`ISO-EXIT-CRITERIA.md` records the remaining project-level exit conditions.
 
 | Standard area | Implementation | Representative executable coverage |
 | --- | --- | --- |
-| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, Unicode-scalar PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
-| Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, Unicode-scalar PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases, and a cross-profile check that all strict-success WG17 cases retain the same normal-profile outcome |
+| Clause 7.1-7.3 term types, term order and unification | five strict term types, derived term notions, finite-tree unification, identity, standard order, occurs-check behavior | `ISO-TERM-SEMANTICS-MATRIX.md`, `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order`, and the strict 7.1-7.3 closure regression |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
 | 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, and the one-row-per-mode/error 8.2-8.5 slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`, including conditional finite-`max_arity` branches |
 | 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors, and the explicit row-level 8.6-8.7 mode/error-condition audit |
@@ -18,7 +21,7 @@ compliance audit and the remaining work before a full conformance claim.
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus the complete 8.15 row-audit in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived cases, and the complete 8.16 mode/error slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.17 flags and halt | complete required Part 1 flag set, selected defaults, standard value domains/changeability, and halt status handling | `exceptions_and_flags`, `remaining_builtins_and_directives`, the complete strict flag audit, halt cases, and explicit 8.17 rows in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
-| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and power-error precedence, float-only rounding modes, I->F overflow before floating functors, published `exp/1`/`**/2`/`^/2` underflow (with post-N289 STC #75 tracked separately), Part 1 mixed integer/float comparison conversion, and resource-error normalization for finite-host exhaustion of unbounded integer operations |
+| Clause 7.9 / Clause 9 evaluable functors | recursive expression evaluation plus integer, float, rounding, transcendental and bitwise operations | `ISO-EVALUABLE-FUNCTOR-MATRIX.md`, `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, the strict row-closure regression (including huge-integer float-only template precedence), published `exp/1`/`**/2`/`^/2` underflow with STC #75 tracked separately, mixed comparison/max/min choices, signed bitwise/negative-shift semantics, and unbounded-integer resource normalization |
 | Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
 | Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 

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

@@ -17,7 +17,7 @@ certification claim.
 | Requirement | Status | Current evidence / remaining work |
 | --- | --- | --- |
 | 5.1(a) prepare conforming Prolog text | audit | parser/preparation tests, directives, include behavior, preparation-time operators/flags/character conversion, and the complete vendored WG17 syntax matrix; the remaining Clause 6/7.4 shall-by-shall map is still open |
-| 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 suites plus the now-complete 8.2-8.17 row-audited built-in family in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`; remaining Clause 7/9 processor-semantic rows are still being enumerated |
+| 5.1(b) execute conforming Prolog goals | audit | the 7.1-7.3 term-semantics matrix, 7.9/Clause 9 evaluable-functor matrix, and complete 8.2-8.17 built-in row audit are closed; remaining dependency rows are 7.4-7.8, higher-level 7.10, and residual processor-level 7.12 semantics |
 | 5.1(c) reject nonconforming text/read terms | audit | syntax-error corpus, WG17 negative syntax cases, strict extension rejection; exhaustive Clause 6 rejection mapping remains open |
 | 5.1(d) specify permitted variations | covered | `ISO-IMPLEMENTATION-DEFINED.md` records the Part 1 implementation-defined choices and implementation-specific extension families |
 | 5.1(e) offer a strictly conforming mode | covered | CLI `--iso-strict` and API `isoStrict: true`; registry/directive/operator/flag extension filtering plus disabled implementation-specific execution shortcuts |
@@ -27,7 +27,7 @@ certification claim.
 | Requirement | Status | Current evidence / remaining work |
 | --- | --- | --- |
 | 5.2 conforming and strictly conforming Prolog text boundary | audit | strict parser accepts Part 1 + Corrigenda syntax plus implementation-defined PCS choices and rejects implementation-specific language facilities; full Clause 6/7.4 dependency audit remains open |
-| 5.3 conforming and strictly conforming Prolog goal boundary | audit | strict registry/control/evaluable filtering and Clause 7-9 regression suites; the built-in 8.2-8.17 mode/error rows are closed, while remaining general goal/control and Clause 9 semantic rows stay open |
+| 5.3 conforming and strictly conforming Prolog goal boundary | audit | strict registry/control/evaluable filtering plus closed 7.1-7.3, 7.9/Clause 9, and 8.2-8.17 row matrices; remaining general execution/control, higher-level stream, and processor-error semantics keep the top-level goal boundary open |
 | 5.4 accompanying documentation for implementation-defined and implementation-specific features | covered | `ISO-IMPLEMENTATION-DEFINED.md`, *The Art of EyeProlog*, strict-boundary documentation, and release-facing conformance ledgers |
 
 ## 5.5 — extension boundaries
@@ -35,21 +35,22 @@ certification claim.
 | Requirement | Status | EyeProlog decision / evidence |
 | --- | --- | --- |
 | 5.5 general extension rule | covered | normal mode may provide documented extensions; strict mode removes their Part 1 interpretation rather than changing implementation-defined choices |
-| 5.5.1 syntax extensions preserve standard token/text meaning | audit | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation; a complete one-row preservation map for every Clause 6 production remains open |
+| 5.5.1 syntax extensions preserve standard token/text meaning | audit | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation. Every vendored WG17 case that succeeds in the Part 1 strict reader now has an identical normal-profile observable outcome, directly checking that normal syntax extensions do not reinterpret accepted standard text. A complete one-row preservation map for every Clause 6 production remains open |
 | 5.5.2 additional predefined operators | covered | strict mode starts from the Part 1 predefined operator table; normal-profile extra operators are documented and filtered |
 | 5.5.3 initial character-conversion mapping | covered | identity initial mapping; user changes are exercised through preparation/execution `char_conversion/2` behavior |
 | 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 | audit | host/proof/statistics/library effects are outside the strict registry or documented normal-mode behavior; exhaustive side-effect preservation mapping remains part of the Clause 7.7/7.10 audit |
+| 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.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 | audit | strict mode excludes normal-profile arithmetic extensions such as evaluable `e`; the 9.1.4.2 `resultF` choice is documented, and post-N289 STC #75's proposed conditional power-underflow interpretation is kept separate from the published baseline; the remaining Clause 9 exceptional-value/error rows stay under audit |
+| 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 |
 | 5.5.11 reserved atoms | not applicable | EyeProlog declares no reserved-atom extension; extension names remain ordinary atoms unless used in a documented syntactic/predicate/directive role |
 
 ## Exit-use rule
 
 A top-level row stays `audit` until all of the normative clauses it depends on
 have explicit pass, not-applicable, or documented implementation-defined
-outcomes. This prevents a large green regression suite from being mistaken for
-a completed processor-requirement audit.
+outcomes. `ISO-EXIT-CRITERIA.md` records the same dependency closure from the
+release-exit perspective. This prevents a large green regression suite from
+being mistaken for a completed processor-requirement audit.

package/test/conformance/ISO-TERM-SEMANTICS-MATRIX.md

@@ -0,0 +1,53 @@
+# ISO Part 1 term-semantics audit matrix
+
+This file closes the Clause 7.1-7.3 audit at a finer granularity than the
+release-facing `ISO-COMPLIANCE.md`. The normative baseline is ISO/IEC
+13211-1:1995 plus Technical Corrigenda 1-3.
+
+`covered` means the applicable Part 1 semantic rule has an implementation
+choice where the standard permits one and executable evidence in the strict
+profile. This matrix is implementation evidence, not independent
+certification.
+
+## 7.1 - term types and derived term notions
+
+| Requirement family | Status | EyeProlog evidence |
+| --- | --- | --- |
+| Five mutually exclusive core term types | covered | strict type predicates and ordering tests cover variable, float, integer, atom, and compound; the normal-profile host string term is rejected at strict program/goal entry |
+| Atomic-term boundary | covered | integers, floats, and atoms satisfy the atomic predicates; compound terms do not |
+| Variable set / repeated-variable identity | covered | `term_variables/2`, read-term Corrigendum 3 variable metadata, `copy_term/2`, collector tests, and repeated-variable unification preserve identity and first occurrence |
+| Existential/free-variable use by collectors | covered | `bagof/3` and `setof/3` mode/semantic suites cover explicit `^/2` existential variables and grouping by free variables |
+| Integer type | covered | `bounded=false` selects the full mathematical-integer model; `max_integer`/`min_integer` therefore have no value and host exhaustion is translated to `resource_error(memory)` rather than a numeric representation bound |
+| Byte and character-code subranges | covered | byte I/O rows and the Unicode-scalar processor character set are separately pinned; byte values remain 0..255 while character codes follow the declared PCS |
+| Floating-point type | covered | ECMAScript IEEE-754 binary64 is the documented implementation-defined float model; input overflow and arithmetic exceptional values have strict tests |
+| Atoms and one-character atoms | covered | parser/reader/writer, atom conversion, character conversion, and PCS/collation suites cover atom identity and one-character atoms |
+| Compound term / arguments / arity | covered | `functor/3`, `arg/3`, `=../2`, parser, predicate-indicator operations, and `max_arity=unbounded` tests cover construction/decomposition and arbitrary semantic arity |
+| Lists, predicate indicators, and related derived term notions | covered | list, proper-list, sort/keysort, predicate-indicator, `current_predicate/1`, `abolish/1`, `call/N`, and module/DCG boundary tests exercise the applicable Part 1 derived forms |
+| Variants / renamed copies | covered | `copy_term/2`, all-solutions collectors, clause selection, and Corrigendum variable-name tests verify renamed-copy behavior without sharing source variables |
+
+## 7.2 - standard order of terms
+
+| Rule | Status | EyeProlog evidence / decision |
+| --- | --- | --- |
+| Type order | covered | strict gate pins `variable < float < integer < atom < compound` |
+| Distinct variable order | covered | implementation-dependent stable encounter order is documented in `ISO-IMPLEMENTATION-DEFINED.md`; sort/collector operations keep that order stable for the operation |
+| Float order | covered | numeric floating ordering is used within the float type |
+| Integer order | covered | mathematical BigInt ordering is used within the integer type |
+| Atom order | covered | null atom and lexicographic ordering use the declared Unicode-scalar collating sequence |
+| Compound order | covered | arity precedes functor name, then arguments are compared left-to-right by standard term order; strict regression pins representative arity/functor cases |
+
+## 7.3 - unification
+
+| Rule | Status | EyeProlog evidence / decision |
+| --- | --- | --- |
+| NSTO unifiable terms produce an MGU | covered | equality, clause-head matching, repeated-variable, list-tail, nested-compound, and explicit strict regression cases |
+| NSTO non-unifiable terms fail | covered | scalar/functor/arity/repeated-variable mismatch suites and strict regression cases |
+| STO ordinary unification | covered | Part 1 leaves the result undefined; EyeProlog consistently performs an occurs check and fails cyclic bindings, which is one permitted processor behavior for this undefined case |
+| Explicit occurs-check unification | covered | `unify_with_occurs_check/2` succeeds for finite unifiable terms and fails positive-occurs-check cases |
+| Implicit unification uses the same finite-tree model | covered | clause-head matching, database operations, control constructs, and collectors share the same unifier; the vendored Prologue STO annotations remain external comparison evidence rather than redefining Part 1 behavior |
+
+## Closure note
+
+The Clause 7.1-7.3 row is `covered` only for the published Part 1 + Corrigenda
+baseline. Normal-mode string terms and other EyeProlog extensions remain outside
+this strict five-type model and are documented separately under Clause 5.5.

package/test/conformance/README.md

@@ -10,9 +10,13 @@ and proof output test the behavior of the JavaScript implementation.
 [ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
 corrigenda, plus EyeProlog's module and DCG compatibility profiles, to representative
 executable cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md)
-tracks the row-by-row built-in audit, while
-[ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) decomposes the
-Clause 5 processor obligations. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
+tracks the row-by-row built-in audit,
+[ISO-TERM-SEMANTICS-MATRIX.md](ISO-TERM-SEMANTICS-MATRIX.md) closes 7.1-7.3,
+[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-EXIT-CRITERIA.md](ISO-EXIT-CRITERIA.md) makes the remaining normative and
+external-corpus release-exit conditions explicit. [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
 implementation questions from the post-N289 working draft (reviewed through the 2026-08-23 items #73-#76); those cases are
@@ -24,9 +28,11 @@ predicate indicators listed in Appendix B of the book across the Part 1 strict-c
 target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
 release-facing ledger for the Part 1 strict-core audit. This suite is
 still not an independent certification of every processor requirement or lexical
-edge. The complete 8.2-8.17 built-in family is now tracked one prescribed
-mode/error row at a time; the remaining Clause 6/7/9 and processor semantics
-stay explicitly open in the dedicated audit files. Cases under `iso/`
+edge. The complete 8.2-8.17 built-in family, 7.1-7.3 term semantics, and
+7.9/Clause 9 expression/evaluable-functor families are now tracked and closed
+at row level. The remaining Clause 6, 7.4-7.8, higher-level 7.10/7.12,
+processor-dependency, and external-corpus criteria stay explicitly open in the
+dedicated audit files. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core

package/test/run-iso-strict.mjs

@@ -8,6 +8,7 @@ import {
   Env,
   compound,
   createStrictIsoRegistry,
+  getEyePrologRegistry,
   parseGoalText,
   parseProgramText,
   run,
@@ -196,6 +197,31 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'representation_error(term)', 'strict program construction rejects API string terms');
   });
 
+
+  reporter.test('closes the ISO 7.1-7.3 term-semantics rows', () => {
+    for (const goal of [
+      'var(X), \\+ nonvar(X)',
+      'integer(1), float(1.0), atom(a), compound(f(a))',
+      'atomic(1), atomic(1.0), atomic(a), \\+ atomic(f(a))',
+      'term_variables(f(X,Y,X),[X,Y])',
+      'f(X,a)=f(b,Y), X==b, Y==a',
+      '\\+ (f(a)=g(a))',
+      '\\+ (X=f(X))',
+      '\\+ unify_with_occurs_check(X,f(X))',
+      'copy_term(f(X,X),f(Y,Y)), X \\== Y',
+      'f(a) @< f(a,b)',
+      'f(a) @< g(a)',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (goal) => [...solver.solve([parseGoalText(goal, { isoStrict: true })], new Env(), 0)].length;
+    equal(answers('X @< 1.0'), 1, 'variable < float');
+    equal(answers('1.0 @< 1'), 1, 'float < integer');
+    equal(answers('1 @< a'), 1, 'integer < atom');
+    equal(answers('a @< f(a)'), 1, 'atom < compound');
+  });
+
   reporter.test('keeps the strict write-option surface to Part 1 plus Corrigendum 3', () => {
     const strictError = capture(() => run('', {
       isoStrict: true,
@@ -673,6 +699,143 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'evaluation_error(undefined)', 'zero-negative power precedes exponent conversion overflow');
   });
 
+  reporter.test('closes the 5.5.6 additional side-effect extension boundary', () => {
+    const normalRegistry = getEyePrologRegistry();
+    const strictRegistry = createStrictIsoRegistry();
+    equal(Boolean(normalRegistry.get('statistics', 0)), true, 'normal statistics/0 side-effect extension');
+    equal(Boolean(strictRegistry.get('statistics', 0)), false, 'strict statistics/0 excluded');
+    equal(Boolean(strictRegistry.get('statistics', 2)), false, 'strict statistics/2 excluded');
+    equal(Boolean(strictRegistry.get('call_cleanup', 2)), false, 'strict cleanup extension excluded');
+    equal(Boolean(strictRegistry.get('setup_call_cleanup', 3)), false, 'strict setup/cleanup extension excluded');
+    equal(capture(() => run('', { isoStrict: true, goal: 'statistics' })).formal,
+      'existence_error(procedure)', 'strict execution cannot invoke statistics/0');
+  });
+
+  reporter.test('closes the 5.5.10 evaluable-functor extension boundary', () => {
+    const strictExtension = capture(() => run('', { isoStrict: true, goal: 'X is e' }));
+    equal(strictExtension.formal, 'type_error(evaluable)', 'normal-only e/0 is not evaluable in strict mode');
+    equal(run('', { goal: 'X is e' }).stats.completed_goal_lists, 1, 'normal e/0 extension remains available');
+
+    for (const goal of [
+      'X is +1',
+      'X is -7 div 3',
+      'X is max(2,3.0)',
+      'X is min(2.0,3)',
+      'X is 3^3',
+      'X is asin(0)',
+      'X is acos(1)',
+      'X is atan2(1,0)',
+      'X is tan(0)',
+      'X is pi',
+      'X is xor(10,12)',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, `Corrigendum evaluable ${goal}`);
+  });
+
+  reporter.test('pins Corrigendum 2 mixed-type max/min implementation-dependent behavior', () => {
+    for (const goal of [
+      'X is max(2.0,3), X == 3',
+      'X is max(2,3.0), X == 3.0',
+      'X is min(2.0,3), X == 2.0',
+      'X is min(2,3.0), X == 2',
+      'X is max(0,0.0), X == 0',
+      'X is max(0.0,0), X == 0.0',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+
+    // Corrigendum 2 permits several mixed-type choices, including returning
+    // one of the original operands without converting the integer to float.
+    // EyeProlog compares the mathematical values exactly and preserves the
+    // selected operand's original type, so a huge integer does not create a
+    // float-overflow merely because the other operand is a float.
+    const huge = `1${'0'.repeat(400)}`;
+    equal(run('', { isoStrict: true, goal: `X is max(${huge},1.0), X == ${huge}` }).stats.completed_goal_lists,
+      1, 'mixed max/2 does not force integer-to-float conversion');
+    equal(run('', { isoStrict: true, goal: `X is min(${huge},1.0), X == 1.0` }).stats.completed_goal_lists,
+      1, 'mixed min/2 preserves selected float operand');
+  });
+
+  reporter.test('pins implementation-defined Clause 9.4 signed bitwise and shift behavior', () => {
+    for (const goal of [
+      'X is ((-16) >> 2), X == -4',
+      'X is (16 >> -2), X == 64',
+      'X is (16 << -2), X == 4',
+      'X is ((-1) /\\ 5), X == 5',
+      'X is ((-1) \\/ 5), X == -1',
+      'X is xor(-1,5), X == -6',
+      'X is \\ 5, X == -6',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+  });
+
+
+  reporter.test('closes the ISO 7.9 and Clause 9 evaluable-functor rows', () => {
+    for (const goal of [
+      'X is 7+35, X==42',
+      'X is 7-35, X== -28',
+      'X is 7*5, X==35',
+      'X is 7/2, X =:= 3.5',
+      'X is 7//(-3), X== -2',
+      'X is 7 div (-3), X== -3',
+      'X is (-7) rem 3, X== -1',
+      'X is (-7) mod 3, X==2',
+      'X is +7, X==7',
+      'X is -7, X== -7',
+      'X is abs(-7), X==7',
+      'X is sign(-7), X== -1',
+      'X is float(7), X =:= 7.0',
+      'X is floor(1.9), X==1',
+      'X is truncate(-1.9), X== -1',
+      'X is round(1.4), X==1',
+      'X is ceiling(1.1), X==2',
+      'X is float_integer_part(1.5), X =:= 1.0',
+      'X is float_fractional_part(-1.5), X =:= -0.5',
+      'X is 2 ** 3, X =:= 8.0',
+      'X is sin(0), X =:= 0.0',
+      'X is cos(0), X =:= 1.0',
+      'X is atan(0), X =:= 0.0',
+      'X is exp(0), X =:= 1.0',
+      'X is log(1), X =:= 0.0',
+      'X is sqrt(4), X =:= 2.0',
+      'X is max(2,3.0), X==3.0',
+      'X is min(2.0,3), X==2.0',
+      'X is 3^3, X==27',
+      'X is asin(0), X =:= 0.0',
+      'X is acos(1), X =:= 0.0',
+      'X is atan2(1,0), X > 1.5',
+      'X is tan(0), X =:= 0.0',
+      'X is pi, X > 3.14',
+      'X is xor(10,12), X==6',
+      'X is (10 /\\ 12), X==8',
+      'X is (10 \\/ 12), X==14',
+      'X is (8 << 2), X==32',
+      'X is (8 >> 2), X==2',
+      'X is \\ 5, X== -6',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+
+    const huge = `1${'0'.repeat(400)}`;
+    for (const functor of ['float_integer_part', 'float_fractional_part']) {
+      equal(capture(() => run('', { isoStrict: true, goal: `X is ${functor}(${huge})` })).formal,
+        'type_error(float)', `${functor}/1 float-only template precedes I->F overflow`);
+    }
+
+    for (const [goal, formal, label] of [
+      ['X is Y+1', 'instantiation_error', 'direct variable expression'],
+      ['X is foo', 'type_error(evaluable)', 'non-evaluable atom'],
+      ['X is 1.5 // 1', 'type_error(integer)', 'integer-only arithmetic'],
+      ['X is floor(1)', 'type_error(float)', 'float-only rounding'],
+      ['X is 1/0', 'evaluation_error(zero_divisor)', 'floating division zero'],
+      ['X is 1 div 0', 'evaluation_error(zero_divisor)', 'integer division zero'],
+      ['X is log(0)', 'evaluation_error(undefined)', 'log domain'],
+      ['X is sqrt(-1)', 'evaluation_error(undefined)', 'sqrt domain'],
+      ['X is asin(2)', 'evaluation_error(undefined)', 'asin domain'],
+      ['X is acos(2)', 'evaluation_error(undefined)', 'acos domain'],
+      ['X is atan2(0,0)', 'evaluation_error(undefined)', 'atan2 zero pair'],
+      ['X is 0 ** -1', 'evaluation_error(undefined)', 'power zero-negative'],
+      ['X is (-2) ** 0.5', 'evaluation_error(undefined)', 'negative-base power'],
+      ['X is exp(1000.0)', 'evaluation_error(float_overflow)', 'transcendental overflow'],
+      ['X is exp(-1000.0)', 'evaluation_error(underflow)', 'transcendental underflow'],
+      ['X is 2.0 ** -1075.0', 'evaluation_error(underflow)', 'published power underflow'],
+    ]) equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+  });
+
   reporter.test('uses the Part 1 mixed arithmetic comparison operations', () => {
     // 8.7 converts the integer operand to float in mixed comparisons.
     equal(run('', { isoStrict: true, goal: '18014398509481985 =:= 18014398509481984.0' }).stats.completed_goal_lists,

package/test/run-regression.mjs

@@ -1245,21 +1245,34 @@ c4 ?- call((!;1)).
       run: () => {
         const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
         const source = fs.readFileSync(filename, 'utf8');
-        const result = publicApi.runQuads(Program.parseSources([{
+        const program = Program.parseSources([{
           text: source,
           filename,
           baseDir: path.dirname(filename),
-        }]));
-        assertEqual(result.total, 33, 'quad total');
+        }]);
+        assertEqual(program.quads.length, 33, 'vendored quad total');
+        const maxIntegerQuads = program.quads.filter(({ query }) =>
+          termToString(query).includes('current_prolog_flag(max_integer, Max)'));
+        assertEqual(maxIntegerQuads.length, 1, 'max_integer quad count');
+
+        // This regression is about the one deliberate ISO divergence in the
+        // upstream Prologue fixture. Running all 33 records also explores two
+        // intentionally non-terminating STO examples and used to dominate the
+        // regression suite by several seconds, without adding evidence for
+        // max_integer. Keep the full vendored corpus intact, but execute only
+        // the relevant record here.
+        program.quads = maxIntegerQuads;
+        const result = publicApi.runQuads(program);
         // The upstream working-draft quad accepts either integer overflow or
         // Max=unbounded. ISO/IEC 13211-1 7.11.1.1 instead says that when
         // bounded=false, current_prolog_flag(max_integer, N) fails. Preserve
         // the upstream fixture unchanged and make that one deliberate
         // standards-driven divergence explicit in the regression gate.
-        assertEqual(result.passed, 32, 'quad passed');
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.passed, 0, 'quad passed');
         assertEqual(result.failed, 1, 'quad failed');
         assertIncludes(result.stdout, 'current_prolog_flag(max_integer, Max)', 'max_integer divergence');
-        assertIncludes(result.stdout, 'quads: 33 run, 32 passed, 1 failed.', 'quad report');
+        assertIncludes(result.stdout, 'quads: 1 run, 0 passed, 1 failed.', 'quad report');
       },
     },
     {
@@ -3531,6 +3544,21 @@ function documentationSyncCases() {
         );
       },
     },
+    {
+      name: 'normal syntax extensions preserve successful WG17 Part 1 outcomes',
+      run: () => {
+        const fixture = readWg17SyntaxFixture();
+        let checked = 0;
+        for (const item of fixture.cases) {
+          const strict = executeWg17Item(item);
+          if (strict.type !== 'success') continue;
+          const normal = executeWg17Item(item, { isoStrict: false });
+          assertEqual(JSON.stringify(normal), JSON.stringify(strict), `WG17 #${item.id} cross-profile outcome`);
+          checked++;
+        }
+        if (checked === 0) throw new Error('WG17 fixture has no successful Part 1 syntax cases');
+      },
+    },
     {
       name: 'WG17 stream-sensitive cases #270 and #271 follow the upstream input protocol',
       run: () => {
@@ -3663,6 +3691,48 @@ function documentationSyncCases() {
         assertIncludes(text, 'Implementation-specific features required to be documented by 5.4', '5.5 extension inventory');
       },
     },
+    {
+      name: 'ISO term and arithmetic row matrices are closed and linked',
+      run: () => {
+        const compliance = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-COMPLIANCE.md'), 'utf8');
+        const terms = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-TERM-SEMANTICS-MATRIX.md'), 'utf8');
+        const arithmetic = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-EVALUABLE-FUNCTOR-MATRIX.md'), 'utf8');
+        assertIncludes(compliance, '| 7.1-7.3 — term types, term order, unification | covered |', '7.1-7.3 covered');
+        assertIncludes(compliance, '| 7.9 — expression evaluation | covered |', '7.9 covered');
+        assertIncludes(compliance, '| Clause 9 — evaluable functors | covered |', 'Clause 9 covered');
+        assertIncludes(terms, '## 7.3 - unification', 'term unification row matrix');
+        assertIncludes(arithmetic, '## 9.4 - bitwise functors', 'Clause 9.4 row matrix');
+        assertIncludes(arithmetic, '`float_integer_part/1`, `float_fractional_part/1`', 'float-only conversion row');
+      },
+    },
+    {
+      name: 'ISO exit criteria keep remaining audit work explicit',
+      run: () => {
+        const exit = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-EXIT-CRITERIA.md'), 'utf8');
+        for (const item of [
+          '| Clause 6 lexical/syntactic requirements have explicit dispositions | open |',
+          '| Clause 7 semantic requirements have explicit dispositions | open |',
+          '| 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 |',
+          '| External conversion/variable-name comparisons used during the audit are reproducible offline | open |',
+          '| No unexplained deviation remains in the release-facing ledger | open |',
+        ]) assertIncludes(exit, item, item);
+      },
+    },
+    {
+      name: 'public ISO documentation links the row matrices and exit checklist',
+      run: () => {
+        const readme = fs.readFileSync(path.join(packageRoot, 'README.md'), 'utf8');
+        const book = fs.readFileSync(path.join(packageRoot, 'the-art-of-eyeprolog.md'), 'utf8');
+        const profile = fs.readFileSync(path.join(packageRoot, 'why-eyeprolog.md'), 'utf8');
+        for (const name of ['ISO-TERM-SEMANTICS-MATRIX.md', 'ISO-EVALUABLE-FUNCTOR-MATRIX.md', 'ISO-EXIT-CRITERIA.md']) {
+          assertIncludes(readme, name, `README ${name}`);
+          assertIncludes(book, name, `book ${name}`);
+        }
+        assertIncludes(profile, 'completed row-level 7.1-7.3 term-semantics and 7.9/Clause 9 arithmetic audits', 'Why EyeProlog audit state');
+      },
+    },
     {
       name: 'book is the single implementation reference',
       run: () => assertArrayEqual(bookReferenceDocumentationIssues(), [], 'book reference documentation'),

package/test/run-wg17.mjs

@@ -33,13 +33,13 @@ function capturedStages(stdout) {
     .map((match) => ({ output: match[2], variables: match[3] }));
 }
 
-function executeFinite(item) {
+function executeFinite(item, isoStrict = true) {
   try {
     // Match the upstream protocol: the Query cell plus its terminating newline
     // is input to read(G), G (and subsequent read/call stages when present).
     // This is essential for stream-sensitive cases such as #270 and #271.
     const result = run('', {
-      isoStrict: true,
+      isoStrict,
       goal: runnerStage(1, item.readCount ?? 16),
       ioOptions: { input: `${item.input}\n` },
     });
@@ -50,10 +50,10 @@ function executeFinite(item) {
   }
 }
 
-function executeWait(item) {
-  const program = Program.parse('', { isoStrict: true });
+function executeWait(item, isoStrict = true) {
+  const program = Program.parse('', { isoStrict });
   const solver = new Solver(program, {
-    isoStrict: true,
+    isoStrict,
     ioOptions: { input: `${item.input}\n` },
   });
   const stream = solver.io.resolve('user_input');
@@ -63,7 +63,7 @@ function executeWait(item) {
     return null;
   };
   const goal = parseGoalText('read_term(G, [])', {
-    isoStrict: true,
+    isoStrict,
     operatorDefinitions: [...program.operators.values()],
   });
   try {
@@ -310,10 +310,11 @@ export function wg17TestDescription(item) {
   return `#${item.id} ${query} -> ${expected}`;
 }
 
-export function executeWg17Item(item) {
+export function executeWg17Item(item, options = {}) {
+  const isoStrict = options.isoStrict ?? true;
   return usesWaitMatcher(item.expected) || item.outcome?.type === 'waits'
-    ? executeWait(item)
-    : executeFinite(item);
+    ? executeWait(item, isoStrict)
+    : executeFinite(item, isoStrict);
 }
 
 function assertOutcome(item) {

package/the-art-of-eyeprolog.md

@@ -7589,13 +7589,22 @@ requirements whose normative `shall` clauses, option combinations, or error
 precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
 `test/conformance/ISO-IMPLEMENTATION-DEFINED.md` is the ISO 5.4 decision
-index: it enumerates the Part 1 implementation-defined decisions, the
-implementation-specific extension families, and any remaining strict-mode audit
-gaps without turning draft WG17/STC proposals into the licensed baseline.
-`test/conformance/WG17-SYNTAX-STATUS.md` separately traces the vendored active
+index: it enumerates the Part 1 implementation-defined decisions and the
+implementation-specific extension families without turning draft WG17/STC
+proposals into the licensed baseline. `ISO-TERM-SEMANTICS-MATRIX.md` closes the
+7.1-7.3 type/order/unification rows and `ISO-EVALUABLE-FUNCTOR-MATRIX.md` closes
+7.9/Clause 9 expression and arithmetic rows. `ISO-EXIT-CRITERIA.md` makes the
+remaining normative, external-corpus, and unexplained-deviation exit conditions
+explicit. `test/conformance/WG17-SYNTAX-STATUS.md` separately traces the vendored active
 upstream syntax cases. Reviewed cases can pin exact strict-reader outcomes, while
 newly upgraded cases execute directly against the upstream Codex expectation.
 
+The syntax audit also cross-checks extension safety: each vendored WG17 case
+accepted by the strict Part 1 reader is executed through the normal profile and
+must preserve the same observable outcome. Additional normal-mode syntax may
+accept texts outside the strict grammar, but it may not reinterpret an accepted
+standard case.
+
 The complete suite must pass before release. The file-based conformance corpus
 contains 802 cases, including 386 focused ISO
 cases derived from the success, failure, mode, and error behavior in
@@ -7663,9 +7672,16 @@ strict boundary. The continuing issue #65 audit also enforces Part 1
 preparation constraints for `dynamic/1`, `multifile/1`, and `discontiguous/1`,
 keeps initialization tied to preparation of a program, tightens stream
 creation/position/EOF behavior and text-vs-binary permission errors, corrects
-Corrigendum 2 `keysort/2` error cases, and keeps the non-standard evaluable atom
-`e` outside strict mode. These are conformance improvements, while the
-remaining qualifications are:
+Corrigendum 2 `keysort/2` error cases, closes the 5.5.6 Prolog-visible
+side-effect boundary by excluding statistics/cleanup extensions from strict
+mode, closes 5.5.10 by keeping the non-standard evaluable atom `e` outside
+strict mode, closes the row-level 7.1-7.3 term-semantics and 7.9/Clause 9
+arithmetic audits, and pins the permitted arithmetic variation points for
+mixed-type Corrigendum 2 `max/2`/`min/2` plus signed Clause 9.4 bitwise and
+negative-shift behavior. The Clause 9 audit also corrected float-only
+`float_integer_part/1` and `float_fractional_part/1` so integer operands are
+rejected by type before a potentially overflowing integer-to-float conversion.
+These are conformance improvements, while the remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
@@ -7685,9 +7701,9 @@ Write terms explicitly, keep variables uppercase or underscore-prefixed, and
 quote atom names that are neither lowercase plain names nor graphic tokens.
 These boundaries distinguish implemented ISO functionality from certification.
 The EyeProlog corpus verifies this documented profile and strict-core boundary.
-A public full-conformance claim is deferred until the compliance ledger has no
-unresolved normative audits and external conformity runs have no unexplained
-deviations.
+A public full-conformance claim is deferred until the explicit
+`test/conformance/ISO-EXIT-CRITERIA.md` checklist has no unresolved normative
+audits or unexplained external-corpus deviations.
 
 ### Security and resource use
 

package/why-eyeprolog.md

@@ -28,9 +28,11 @@ collating-sequence integers in both normal and strict profiles. Strict mode
 therefore rejects implementation-specific language extensions without changing
 that processor choice. Its executable conformance matrix and tests
 document the supported behavior, including an executable trace of the vendored
-active WG17 syntax cases. This is extensive implementation evidence, not a
-claim that every Part 1, Part 2, or Part 3 normative requirement has already
-been certified or closed.
+active WG17 syntax cases, cross-profile preservation of all strict-success WG17 syntax outcomes, closed strict side-effect and evaluable-functor extension boundaries, the completed row-level 7.1-7.3 term-semantics and 7.9/Clause 9 arithmetic audits, and explicit choices at standardized variation points such as mixed-type
+`max/2`/`min/2` and signed bitwise/shift operations. The remaining exit criteria
+are recorded explicitly rather than inferred from aggregate test counts. This is
+extensive implementation evidence, not a claim that every Part 1, Part 2, or
+Part 3 normative requirement has already been certified or closed.
 
 ## Why a small implementation?