eyeprolog 1.3.60 → 1.3.61

package/README.md

@@ -203,66 +203,24 @@ eyeprolog --iso-strict
 eyeprolog --iso-strict --goal 'p(X)' program.pl
 ```
 
-The equivalent JavaScript option is `isoStrict: true`. Strict mode rejects
-EyeProlog language extensions, Part 2 module directives, and Part 3 grammar-rule
-expansion/`phrase/2-3`; it also removes the EyeProlog `occurs_check` flag,
-`call_cleanup/2`, and `setup_call_cleanup/3`, and disables automatic tabling.
-Normal mode is unchanged and continues to support modules, DCGs, quads,
-libraries, proofs, cleanup-aware control, and the other documented extensions.
-
-The Part 1 processor character set is an implementation-defined processor
-choice, so strict mode does not replace it with a smaller repertoire. EyeProlog
-uses Unicode scalar values as its PCS in both normal and strict profiles, with
-the Unicode scalar value as the collating-sequence integer. ASCII keeps the
-standard lexical classes; extended Unicode letters participate in unquoted name
-syntax and other non-ASCII symbols are treated as extended graphic characters.
-Surrogates and values above U+10FFFF remain representation errors.
-
-Strict term I/O likewise keeps the standardized option boundary: `read_term/2-3`
-and `write_term/2-3` accept the Part 1 plus Corrigendum 3 options, while the
-normal-profile `write_term(...,[double_quotes(...)])` option remains an
-EyeProlog extension. The strict gate also checks the prescribed ISO error
-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, 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
-2026-08-23 draft items #73-#76 are now pinned explicitly: float input limits for
-`read*` and `number_*` conversions, invalid-character term input, and the draft
-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;
-newly upgraded cases run directly against the upstream Codex expectation.
-EyeProlog does not yet claim independent certification or closure of every
-normative Part 1 requirement.
+The equivalent JavaScript option is `isoStrict: true`. Strict mode keeps
+EyeProlog's documented implementation-defined Unicode scalar processor
+character set, while excluding normal-profile language extensions such as Part
+2 module compatibility forms, Part 3 DCG expansion, quads, extra libraries,
+automatic tabling, and non-standard flags/control facilities. Normal mode is
+unchanged.
+
+This README intentionally stays at the project-overview level. The detailed
+implementation reference is [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+The current Part 1 audit status and remaining release conditions are recorded in
+[`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md);
+implementation-defined decisions are indexed in
+[`ISO-IMPLEMENTATION-DEFINED.md`](test/conformance/ISO-IMPLEMENTATION-DEFINED.md). The complete
+vendored WG17 syntax corpus and the strict ISO regression suite run as release
+gates.
+
+EyeProlog does not claim independent ISO certification while the explicit exit
+checklist still contains unresolved normative or unexplained-deviation items.
 
 ## Module and definite clause grammar compatibility profiles
 

package/package.json

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

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

@@ -376,5 +376,5 @@ 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`.
+Clause 5 dependency rows and the unexplained-deviation exit criterion
+recorded in `ISO-COMPLIANCE.md`.

package/test/conformance/ISO-COMPLIANCE.md

@@ -1,18 +1,12 @@
 # ISO/IEC 13211-1 compliance ledger
 
-This ledger is the release-facing audit for EyeProlog's ISO/IEC 13211-1 core.
-The normative baseline is ISO/IEC 13211-1:1995 together with Technical
-Corrigenda 1:2007, 2:2012, and 3:2017. It complements
-[ISO-MATRIX.md](ISO-MATRIX.md), which maps standard families to representative
-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. [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.
+This ledger is the release-facing audit and high-level coverage map for
+EyeProlog's ISO/IEC 13211-1 core. The normative baseline is ISO/IEC 13211-1:1995
+together with Technical Corrigenda 1:2007, 2:2012, and 3:2017. Detailed
+row-level evidence lives only where it adds information: the built-in, processor,
+term-semantics, Prolog-text/execution, evaluable-functor, implementation-defined,
+WG17-syntax, and STC draft ledgers in this directory. The generated
+[`conformance-report.md`](../../conformance-report.md) gives current case totals.
 
 The ledger deliberately does **not** claim independent certification. A row
 marked `covered` means EyeProlog has implementation and executable tests for
@@ -26,7 +20,7 @@ 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. 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(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. The 7.1-7.8 term/preparation/database/control rows, 7.9/Clause 9 arithmetic, and 8.2-8.17 built-in row audits are now closed; the dependency remains open on 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. |
@@ -39,14 +33,14 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | --- | --- | --- |
 | 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.4 — Prolog text and directives | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes the preparation/directive rows: declaration semantics, source clauses, cross-text operators/character conversion/flags, initialization order/lifetime, `include/1`, and one-time `ensure_loaded/1`, with implementation-defined cross-text choices indexed under 5.4. |
+| 7.5-7.6 — database and term/clause conversion | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes static/dynamic and private/public procedure semantics, clause order, logical-update visibility, empty/unknown lifetime, and term/body/clause conversion. Source and runtime assertion conversion recurse through `,/2`, `;/2`, and `->/2`, preserve variable identity, and protect standardized static/control procedures. |
+| 7.7 — execution and backtracking | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes ordinary clause selection/backtracking, source/database order, empty-versus-unknown procedures, logical-update visibility, and strict dispatch. EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts remain disabled in the strict profile. |
+| 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion. The 8.15 built-in additions remain independently row-audited. |
 | 7.9 — expression evaluation | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) closes recursive evaluation, direct-variable precedence, corrected non-evaluable `F/N` errors (including STC #69), operand template/type rules, mixed arithmetic-comparison conversion, exceptional values, and finite-host resource normalization. The audit also fixes float-only `float_integer_part/1` and `float_fractional_part/1` so even huge valid integers reach `type_error(float,...)` before any I->F overflow. |
 | 7.10 — input/output concepts | 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. |
+| 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 higher-level 7.10 stream semantics and residual 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 | 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. |
@@ -91,9 +85,8 @@ database update errors, and Corrigendum 3 variable metadata traversal/write
 naming.
 
 The public WG17 `number_chars/2` comparison used in preparation of Corrigendum
-2 has additionally been checked against the current strict profile. That
-external comparison is useful independent evidence, but it is not yet vendored
-as an offline release gate; the exit criterion below therefore remains open.
+2 has additionally been checked during the audit. It remains supporting review
+evidence rather than a duplicated vendored corpus or release criterion.
 
 A further issue #65 audit closes the Part 1 flag family and tightens the 8.14
 term-I/O/operator error rules. The strict flag registry now distinguishes a
@@ -213,9 +206,9 @@ individual-error outcomes in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`. During this
 pass `stream_property/2` exposed a lifecycle distinction: a syntactically valid
 stream-term for a stream that has been closed denotes no currently open stream
 property pair and therefore fails, whereas a term that is not a stream-term is
-still a `domain_error(stream, ...)`. This leaves the remaining #65 checklist
-focused on Clause 6/7/9 processor semantics and external corpora rather than
-unmapped built-in tables.
+still a `domain_error(stream, ...)`. This leaves the remaining #65 checklist focused on Clause 6 syntax/rejection,
+higher-level 7.10 stream semantics, residual 7.12 processor errors, and final
+unexplained-deviation closure rather than unmapped built-in tables.
 
 ## Post-Corrigendum STC cross-check
 
@@ -271,10 +264,9 @@ directive may still add an infix `?-` definition; strict mode reads that as an
 ordinary term rather than as a quad.
 
 Module and DCG compatibility features remain supported and tested in the
-normal EyeProlog profile. They are tracked separately in ISO-MATRIX.md rather
-than being silently folded into the Part 1 strict-core claim. The project does
-not currently assert that this evidence closes every requirement of ISO/IEC
-13211-2:2000 or ISO/IEC TS 13211-3.
+normal EyeProlog profile, but they are not folded into the Part 1 strict-core
+claim. The project does not currently assert that this evidence closes every
+requirement of ISO/IEC 13211-2:2000 or ISO/IEC TS 13211-3.
 
 ## Release gate
 
@@ -292,13 +284,25 @@ outputs are never auto-accepted.
 
 ## Exit criteria for a full conformance claim
 
-[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.
+Issue #65 is closed by explicit dispositions, not by a test-count threshold.
+The remaining qualification can be removed only when every open item below is
+closed without an unexplained deviation from the published Part 1 + Corrigenda
+baseline. Public post-N289 STC drafts remain review input until standardized.
 
-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.
+| Criterion | Status | Evidence / remaining work |
+| --- | --- | --- |
+| Clause 5 processor obligations have explicit dispositions | open | `ISO-PROCESSOR-REQUIREMENTS.md` still depends on the remaining Clause 6 preparation/rejection and syntax-preservation work |
+| Clause 6 lexical/syntactic requirements have explicit dispositions | open | the 366-case vendored WG17 syntax gate and cross-profile preservation are green; the remaining work is the production-by-production shall/rejection map |
+| Clause 7 semantic requirements have explicit dispositions | open | 7.1-7.9 and 7.11 are closed; higher-level 7.10 stream semantics and residual processor-level 7.12 requirements 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 execution-visible choices |
+| Implementation-specific strict/normal boundary is documented and tested | open | the major 5.5 hooks are closed; exhaustive 5.5.1 syntax preservation remains tied to the Clause 6 audit |
+| Published Corrigenda 1-3 are incorporated | covered | dedicated conformance/strict tests and this ledger track all three published Corrigenda |
+| Current post-N289 draft is tracked without silently changing the published baseline | covered | `STC-DRAFT-STATUS.md` tracks reviewed draft items separately from normative requirements |
+| Independent external syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations |
+| Third-party standard-core regression provenance is retained | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases retain source identifiers and licenses in `THIRD_PARTY.md` |
+| No unexplained deviation remains in the release-facing ledger | open | every remaining `audit` row must end as covered, implementation-defined/specific with documented behavior, not applicable, or a documented defect |
+
+The specialized row matrices are evidence for this ledger, not separate public
+status documents. *The Art of EyeProlog* remains the implementation reference.

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

@@ -88,4 +88,4 @@ 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.
+and the remaining processor-level exit criteria.

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

@@ -16,8 +16,8 @@ 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 | 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(a) prepare conforming Prolog text | audit | parser/preparation tests, the closed 7.4 directive/source-clause matrix, include/ensure-loaded behavior, preparation-time operators/flags/character conversion, and the complete vendored WG17 syntax matrix; the remaining dependency is the production-by-production Clause 6 map |
+| 5.1(b) execute conforming Prolog goals | audit | the 7.1-7.8 term/preparation/database/control matrices, 7.9/Clause 9 evaluable-functor matrix, and complete 8.2-8.17 built-in row audit are closed; remaining dependency rows are 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 |
@@ -26,8 +26,8 @@ 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 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.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; 7.4 preparation is closed and the full Clause 6 production/rejection map remains open |
+| 5.3 conforming and strictly conforming Prolog goal boundary | audit | strict registry/control/evaluable filtering plus closed 7.1-7.9 and 8.2-8.17 row matrices; remaining higher-level 7.10 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
@@ -51,6 +51,6 @@ certification claim.
 
 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. `ISO-EXIT-CRITERIA.md` records the same dependency closure from the
-release-exit perspective. This prevents a large green regression suite from
+outcomes. `ISO-COMPLIANCE.md` records the same dependency closure in its embedded
+release-exit checklist. This prevents a large green regression suite from
 being mistaken for a completed processor-requirement audit.

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -0,0 +1,94 @@
+# ISO Part 1 Prolog-text, database, and execution matrix
+
+This matrix closes the remaining row-level audit for ISO/IEC 13211-1:1995
+Clauses 7.4-7.8 against the published Part 1 baseline plus Technical
+Corrigenda 1-3. It complements the built-in mode/error matrix: these rows are
+processor semantics above individual predicate definitions.
+
+`covered` means the strict profile has an explicit implementation decision and
+executable evidence. Where Part 1 leaves a choice implementation-defined, the
+chosen behavior is also indexed by `ISO-IMPLEMENTATION-DEFINED.md`.
+
+## 7.4 - Prolog text and preparation
+
+| Row | Status | EyeProlog disposition / executable evidence |
+| --- | --- | --- |
+| 7.4.1 preparation model | covered | A `Program` is prepared before goal execution. Source units share preparation state where Part 1 permits it; the implementation-defined cross-text choices are recorded in the 5.4 decision index. |
+| 7.4.2.1 `dynamic/1` | covered | Strict preparation validates predicate indicators, declaration ordering, protected procedures, and creates an empty dynamic/public procedure even with no clauses. |
+| 7.4.2.2 `multifile/1` | covered | Declarations can span source texts and preserve the prepared clause group; declaration/order checks are exercised by the strict/conformance suites. |
+| 7.4.2.3 `discontiguous/1` | covered | Strict preparation permits separated clause groups only when declared and preserves their source order. |
+| 7.4.2.4 `op/3` | covered | Operator changes affect subsequent text, including later text after an included source; invalid arguments use the same strict validation as the built-in. Earlier text is not reparsed. |
+| 7.4.2.5 `char_conversion/2` | covered | With the flag enabled, conversion affects subsequent unquoted source characters; quoted text is unchanged and disabling the flag stops conversion. The mapping can carry into later source units according to the documented implementation-defined choice. |
+| 7.4.2.6 `initialization/1` | covered | Goals are retained in preparation order and run after preparation. Reusing the same prepared `Program` does not run them again accidentally. |
+| 7.4.2.7 `include/1` | covered | The included text is prepared at the directive position and shares operator/character/flag preparation state with its parent. |
+| 7.4.2.8 `ensure_loaded/1` | covered | A source is prepared at most once in the current load graph, including repeated references and self/top-level references. |
+| 7.4.2.9 `set_prolog_flag/2` | covered | Preparation-time flag changes affect subsequent text and are replayed into execution state; strict flag names/values/changeability remain governed by the closed 7.11 audit. |
+| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. |
+
+The strict release test `closes ISO 7.4 Prolog-text preparation and directive
+rows` exercises the cross-text operator/character/flag state, include and
+ensure-loaded lifetime, initialization order, and one-shot initialization
+behavior together. Existing focused tests retain the individual declaration
+and preparation error cases.
+
+## 7.5 - database model
+
+| Row | Status | EyeProlog disposition / executable evidence |
+| --- | --- | --- |
+| 7.5.1 initial database and clause order | covered | Prepared clauses retain textual preparation order. The implementation-defined initial database/standard-procedure choices are documented separately. |
+| 7.5.2 static and dynamic procedures | covered | Source procedures are static unless declared dynamic; asserting a previously absent predicate creates a dynamic procedure; modification of protected/static procedures is rejected. |
+| 7.5.3 private and public procedures | covered | User static procedures are private to `clause/2`; dynamic procedures are public; standardized built-ins/control forms remain static/private. |
+| 7.5.4 database update visibility | covered | Dynamic calls use the logical-update view: an activation continues over the clause set visible when it began, while later activations see successful assertions/retractions. `retractall/1` retains an empty dynamic procedure and `abolish/1` removes it. |
+
+The strict test `closes ISO 7.5-7.7 database, conversion, and execution rows`
+pins source order, logical-update behavior, dynamic/public creation, and the
+required distinction between an empty declared procedure and an unknown one.
+The complete 8.8-8.9 database built-in modes/errors remain covered by
+`ISO-BUILTIN-MODE-ERROR-MATRIX.md`.
+
+## 7.6 - conversion between terms and clauses/goals
+
+| Row | Status | EyeProlog disposition / executable evidence |
+| --- | --- | --- |
+| 7.6.1 term-to-goal/body boundary | covered | Callable terms enter execution as goals; variables are deferred through `call/1`; non-callable numeric/body terms are rejected rather than silently coerced. |
+| 7.6.2 term-to-body conversion | covered | Variables become `call/1`; conjunction, disjunction, and if-then bodies are converted recursively; non-control callable terms retain their predication; variable identity is preserved across the converted clause. |
+| 7.6.3 clause-to-term observation | covered | `clause/2` returns fresh renamed clause observations with the required sharing between head and body. |
+| 7.6.4 update conversion | covered | `asserta/1`, `assertz/1`, `retract/1`, and prepared source clauses use the same strict body-conversion rules and reject malformed bodies before database mutation. |
+
+Corrigendum 3's explicit `call/1` term-to-body wording is covered by the source
+and asserted-body conversion regressions.
+
+## 7.7 - execution and backtracking
+
+| Row family | Status | EyeProlog disposition / executable evidence |
+| --- | --- | --- |
+| goal execution / procedure selection | covered | Strict mode uses ordinary clause selection and depth-first backtracking; EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts are disabled. |
+| clause order and re-execution | covered | Clauses are tried in prepared/database order; re-executable predicates expose subsequent solutions on backtracking. |
+| empty versus unknown procedure | covered | A defined procedure with zero clauses fails normally. A missing procedure follows the `unknown` flag (`error` by default in the strict profile). |
+| side effects and database changes | covered | Standard side effects occur at their execution point; successful dynamic changes become visible to later activations while preserving the logical-update view of active calls. |
+| built-in/control delegation | covered | Standardized built-ins dispatch through the strict registry and control constructs through the strict execution path; implementation-specific predicates/shortcuts are excluded by the 5.5 boundary audit. |
+
+## 7.8 - control constructs and exceptions
+
+| Row | Status | EyeProlog disposition / executable evidence |
+| --- | --- | --- |
+| 7.8.1 `true/0` | covered | succeeds once |
+| 7.8.2 `fail/0` | covered | fails |
+| 7.8.3 `call/1` | covered | executes the converted goal; variables can become callable after earlier bindings; Corrigendum 3 term-to-body conversion is used |
+| 7.8.4 cut | covered | cut commits within its defined invocation scope; callee-local cuts do not incorrectly prune caller alternatives |
+| 7.8.5 conjunction | covered | left-to-right execution and backtracking; nested malformed converted goals retain the whole control-term culprit |
+| 7.8.6 disjunction | covered | left branch is tried before the right and failure backtracks into the right branch |
+| 7.8.7 if-then | covered | successful condition commits to the selected condition solution before the then branch |
+| 7.8.8 if-then-else | covered | condition success selects the then branch; condition failure selects the else branch with the standard commit boundary |
+| 7.8.9 `catch/3` | covered | The protected goal executes inside the catch boundary. Corrigendum 2 behavior is pinned so callability errors arising from that protected goal can be caught. |
+| 7.8.10 `throw/1` | covered | Throws propagate until a matching catch and use a renamed/fresh term for exception matching. |
+
+The strict test `closes ISO 7.8 general control-construct and exception rows`
+keeps the general semantics visible in addition to the 8.15 built-in audit.
+
+## Audit result
+
+Clauses **7.4-7.8 are covered at row level** for the declared strict Part 1
+profile. Remaining Clause 7 exit work is therefore no longer general
+preparation/database/control semantics; it is concentrated in the higher-level
+7.10 stream model and residual processor-level 7.12 error requirements.

package/test/conformance/README.md

@@ -7,16 +7,14 @@ supported ISO Prolog profile, built-ins, extensions, and reasoner behavior.
 
 The suite is intentionally file-based. Exact standard output, errors, warnings,
 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)
+[ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the high-level Part 1 audit and coverage map. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md)
 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)
+[ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md)
+closes 7.4-7.8, [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md)
+closes 7.9/Clause 9, and [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md)
 decomposes the Clause 5 processor obligations.
-[ISO-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
+The exit checklist is embedded in [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md). [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 [STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
 implementation questions from the post-N289 working draft (reviewed through the 2026-08-23 items #73-#76); those cases are
@@ -28,11 +26,12 @@ 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, 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/`
+edge. The complete 8.2-8.17 built-in family and Clause 7.1-7.9 term,
+preparation/database/control, and expression/evaluable-functor families are now
+tracked and closed at row level. The remaining Clause 6, higher-level
+7.10/7.12, processor-dependency, and unexplained-deviation criteria stay
+explicitly open in the dedicated audit files. Public comparison material used during the audit remains supporting review
+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 automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core

package/test/run-iso-strict.mjs

@@ -2,6 +2,10 @@
 // Release gate for the ISO/IEC 13211-1 strict-core execution profile.
 // This is intentionally separate from the broader `iso/` corpus because that
 // corpus also exercises Part 2 modules and Part 3 grammar rules.
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
 import {
   Program,
   Solver,
@@ -254,6 +258,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
     includes(ignoredNonVariable.stdout, 'x', 'non-variable right side is permitted and ignored');
   });
 
+
   reporter.test('reports the complete alias option in open/4 alias collisions', () => {
     const error = capture(() => run('', {
       isoStrict: true,
@@ -939,6 +944,101 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }).stats.completed_goal_lists, 0, 'STC 48 variables([]) does not match an input variable');
   });
 
+  reporter.test('closes ISO 7.4 Prolog-text preparation and directive rows', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'eyeprolog-iso-74-'));
+    try {
+      writeFileSync(join(directory, 'child.pl'), [
+        'child.',
+        ":- op(500,'xfx',trusts).",
+        'child_rule(carol trusts dave).',
+        '',
+      ].join('\n'));
+      writeFileSync(join(directory, 'once.pl'), 'once_loaded.\n');
+      const source = [
+        ':- op(500,xfx,likes).',
+        ':- char_conversion(x,y).',
+        ':- set_prolog_flag(double_quotes,codes).',
+        ':- dynamic(seen/1).',
+        ':- initialization(assertz(seen(1))).',
+        ':- initialization(assertz(seen(2))).',
+        ":- include('child.pl').",
+        ":- ensure_loaded('once.pl').",
+        ":- ensure_loaded('once.pl').",
+        'relation(alice likes bob).',
+        'parent_rule(alice trusts bob).',
+        'converted(x).',
+        'quoted("ab").',
+        '',
+      ].join('\n');
+      const program = Program.parseSources([{ text: source, filename: 'main.pl', baseDir: directory }], {
+        isoStrict: true,
+        sourceMetadata: true,
+      });
+
+      equal(program.findGroup('child', 0)?.clauses.length, 1, 'include/1 textual inclusion');
+      equal(program.findGroup('once_loaded', 0)?.clauses.length, 1, 'ensure_loaded/1 loads once');
+      equal(program.findGroup('relation', 1)?.clauses[0]?.head?.args[0]?.name, 'likes', 'op/3 affects following text');
+      equal(program.findGroup('parent_rule', 1)?.clauses[0]?.head?.args[0]?.name, 'trusts', 'included op/3 affects following parent text');
+      equal(program.findGroup('converted', 1)?.clauses[0]?.head?.args[0]?.name, 'y', 'char_conversion/2 affects following unquoted source');
+      equal(run(program, { isoStrict: true, goal: 'quoted([97,98])' }).stats.completed_goal_lists > 0, true,
+        'set_prolog_flag/2 affects following source and execution');
+
+      const first = run(program, { isoStrict: true, goal: 'findall(X,seen(X),[1,2])' });
+      const second = run(program, { isoStrict: true, goal: 'findall(X,seen(X),[1,2])' });
+      equal(first.stats.completed_goal_lists > 0, true, 'initialization/1 order');
+      equal(second.stats.completed_goal_lists > 0, true, 'initialization/1 executes once per prepared Program');
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  reporter.test('closes ISO 7.5-7.7 database, conversion, and execution rows', () => {
+    const source = [
+      ':- dynamic(p/1).',
+      ':- dynamic(empty/0).',
+      'p(1).',
+      'p(2).',
+      'body(X) :- X.',
+      '',
+    ].join('\n');
+
+    equal(run(source, {
+      isoStrict: true,
+      goal: 'findall(X,(p(X),retract(p(X))),Xs),Xs=[1,2],\\+p(_)',
+    }).stats.completed_goal_lists > 0, true, 'logical-update view and source clause order');
+    equal(run(source, { isoStrict: true, goal: '\\+ empty' }).stats.completed_goal_lists > 0, true,
+      'declared empty procedure fails as a defined procedure');
+    equal(capture(() => run(source, { isoStrict: true, goal: 'missing' })).formal,
+      'existence_error(procedure)', 'unknown procedure remains distinct from empty procedure');
+    equal(run('', {
+      isoStrict: true,
+      goal: 'assertz(fresh(a)),current_predicate(fresh/1),clause(fresh(a),true)',
+    }).stats.completed_goal_lists > 0, true, 'asserting a new procedure makes it dynamic/public');
+    equal(run(source, { isoStrict: true, goal: 'body(true)' }).stats.completed_goal_lists > 0, true,
+      'source variable body is converted to call/1');
+  });
+
+  reporter.test('closes ISO 7.8 general control-construct and exception rows', () => {
+    equal(run('', { isoStrict: true, goal: 'true' }).stats.completed_goal_lists, 1, 'true/0');
+    equal(run('', { isoStrict: true, goal: 'fail' }).stats.completed_goal_lists, 0, 'fail/0');
+    equal(run('', { isoStrict: true, goal: 'X=true,call(X)' }).stats.completed_goal_lists > 0, true,
+      'call/1 executes the converted goal');
+    equal(run('', { isoStrict: true, goal: '(fail;true)' }).stats.completed_goal_lists > 0, true,
+      'disjunction backtracks to the second branch');
+    equal(run('', { isoStrict: true, goal: '(true->true;fail)' }).stats.completed_goal_lists > 0, true,
+      'if-then-else commits after a successful condition');
+    equal(capture(() => run('', { isoStrict: true, goal: 'call((write(a),3))' })).formal,
+      'type_error(callable)', 'nested non-callable control term is rejected');
+    equal(run('', {
+      isoStrict: true,
+      goal: 'catch(X,error(instantiation_error,_),true)',
+    }).stats.completed_goal_lists > 0, true, 'Corrigendum 2 catch/3 can catch callability errors from its protected goal');
+    equal(run('', {
+      isoStrict: true,
+      goal: 'catch(throw(ball(X)),ball(Y),X=Y)',
+    }).stats.completed_goal_lists > 0, true, 'throw/1 and catch/3 unify through a renamed thrown term');
+  });
+
   reporter.test('rejects EyeProlog module directives', () => {
     const error = capture(() => Program.parse(':- use_module(library(lists)).\n', { isoStrict: true }));
     includes(error.message, 'implementation-specific directive use_module/1', 'message');

package/test/run-regression.mjs

@@ -3705,32 +3705,51 @@ function documentationSyncCases() {
         assertIncludes(arithmetic, '`float_integer_part/1`, `float_fractional_part/1`', 'float-only conversion row');
       },
     },
+    {
+      name: 'ISO 7.4-7.8 execution matrix is closed',
+      run: () => {
+        const compliance = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-COMPLIANCE.md'), 'utf8');
+        const matrix = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-PROLOG-TEXT-EXECUTION-MATRIX.md'), 'utf8');
+        for (const row of [
+          '| 7.4 — Prolog text and directives | covered |',
+          '| 7.5-7.6 — database and term/clause conversion | covered |',
+          '| 7.7 — execution and backtracking | covered |',
+          '| 7.8 — control constructs and exceptions | covered |',
+        ]) assertIncludes(compliance, row, row);
+        for (const section of ['## 7.4 - Prolog text and preparation', '## 7.5 - database model', '## 7.6 - conversion between terms and clauses/goals', '## 7.7 - execution and backtracking', '## 7.8 - control constructs and exceptions']) {
+          assertIncludes(matrix, section, section);
+        }
+      },
+    },
     {
       name: 'ISO exit criteria keep remaining audit work explicit',
       run: () => {
-        const exit = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-EXIT-CRITERIA.md'), 'utf8');
+        const exit = fs.readFileSync(path.join(testRoot, 'conformance', 'ISO-COMPLIANCE.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',
+      name: 'public ISO documentation keeps README concise and the book authoritative',
       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');
+        for (const name of [
+          'ISO-TERM-SEMANTICS-MATRIX.md',
+          'ISO-PROLOG-TEXT-EXECUTION-MATRIX.md',
+          'ISO-EVALUABLE-FUNCTOR-MATRIX.md',
+        ]) assertIncludes(book, name, `book ${name}`);
+        assertIncludes(readme, 'implementation reference is [*The Art of EyeProlog*]', 'README book hand-off');
+        assertIncludes(readme, 'test/conformance/ISO-COMPLIANCE.md', 'README concise audit link');
+        assertEqual(readme.includes('2026-08-23 draft items #73-#76'), false, 'README omits audit-history detail');
+        assertIncludes(profile, 'completed row-level 7.1-7.9 term, preparation/database/control, and arithmetic audits', 'Why EyeProlog audit state');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -7586,16 +7586,17 @@ node test/run-conformance-report.mjs
 `test/conformance/ISO-COMPLIANCE.md` is the processor-requirement ledger for the
 Part 1 conformance audit. It distinguishes implemented/tested families from
 requirements whose normative `shall` clauses, option combinations, or error
-precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
+precedence still need one-by-one closure. `test/conformance/ISO-COMPLIANCE.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 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
+proposals into the licensed baseline. `ISO-TERM-SEMANTICS-MATRIX.md` closes the 7.1-7.3 type/order/unification
+rows, `ISO-PROLOG-TEXT-EXECUTION-MATRIX.md` closes 7.4-7.8 preparation,
+database, conversion, execution, and control, and
+`ISO-EVALUABLE-FUNCTOR-MATRIX.md` closes 7.9/Clause 9 expression and arithmetic
+rows. The exit checklist in `ISO-COMPLIANCE.md` makes the remaining normative and
+unexplained-deviation 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.
 
@@ -7662,7 +7663,7 @@ that Part 1 strict surface.
 This release establishes the strict-mode mechanism required for the ongoing
 conformance audit; it does **not** yet claim that every processor requirement
 has been independently certified. `test/conformance/ISO-COMPLIANCE.md` tracks
-the remaining normative audit work. The executable examples are mostly
+the remaining normative audit work. Public comparison material used during the audit remains review evidence rather than a duplicated vendored corpus. The executable examples are mostly
 EyeProlog-profile programs using host-supplied goals, character lists, explicit
 integrity relations, automatic tabling, and the EyeProlog library. The strict audit also exercises the complete Part 1 flag
 set and the prescribed 8.14 error precedence for `read_term/3`, `write_term/3`,
@@ -7675,13 +7676,13 @@ creation/position/EOF behavior and text-vs-binary permission errors, corrects
 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
+strict mode, closes the row-level 7.1-7.3 term-semantics, 7.4-7.8 preparation/database/control, 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:
+The 7.4-7.8 closure also pins cross-text directive state, include/ensure-loaded lifetime, initialization order and one-shot execution, logical-update visibility, empty-versus-unknown procedures, term-to-body conversion, and the general Part 1 control/exception constructs. These are conformance improvements, while the remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
@@ -7702,8 +7703,8 @@ 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 explicit
-`test/conformance/ISO-EXIT-CRITERIA.md` checklist has no unresolved normative
-audits or unexplained external-corpus deviations.
+exit checklist in `test/conformance/ISO-COMPLIANCE.md` has no unresolved normative
+audits or unexplained deviations.
 
 ### Security and resource use
 

package/why-eyeprolog.md

@@ -28,7 +28,7 @@ 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, 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
+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.9 term, preparation/database/control, and arithmetic audits, offline public conversion/variable-metadata audit fixtures, 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

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

@@ -1,55 +0,0 @@
-# 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-MATRIX.md

@@ -1,48 +0,0 @@
-# ISO Prolog conformance matrix
-
-The normative baseline for the `iso/` corpus is ISO/IEC 13211-1:1995 plus
-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, 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 |
-| 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses`, the complete row-level 8.8-8.10 mode/error-condition audit, source/runtime 7.6.2 conversion through `,/2`, `;/2`, and `->/2` with preserved head/body variable sharing, selected deterministic overlap checks, runtime static/private protection for conjunction, and STC #56 `(:-)/1-2` database protection |
-| 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases, the complete row-level 8.11-8.14 mode/error audit, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream lifecycle/property validation (including closed-stream failure), text-vs-binary permissions, EOF/flush/position, open/close semantics, presence-based `force(true)` close handling, late `get_code/peek_code` in-character-code representation errors, and the exact `alias(A)` collision culprit |
-| 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 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 |
-
-Corrigendum-specific coverage includes double-quoted atom operator priority
-(Cor.1); the added predicates and evaluable functors, bar-operator rules,
-uninstantiation errors, and corrected `catch/3` behavior (Cor.2); and option
-validation, variable-name traversal/output, canonical list output, and negative
-integer powers (Cor.3).
-
-Implementation-defined and implementation-specific choices are indexed
-clause-by-clause in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md),
-with *The Art of EyeProlog* remaining the implementation reference. In
-particular, the index records the unbounded integer model, `double_quotes=chars`,
-`//` rounding toward zero, the ECMAScript binary64 float policy (including the
-9.1.4.2 choice to round generic tiny results while retaining explicit
-functor-specific underflow errors),
-stream/character decisions, and the normal-profile extension boundary.
-
-This is an executable conformance/compatibility matrix, not a certification issued by an
-independent standards body. The Part 2/Part 3-related rows describe tested
-normal-mode compatibility surfaces rather than a claim that every requirement
-of those standards has been closed. Release gating runs the ISO cases and the dedicated
-Part 1 strict-core suite together with the full regression, API, documentation,
-example, and browser suites.