@inventarch/compliance 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+InventArch
+Copyright (c) 2026 InventArch contributors
+
+Licensed under the Apache License, Version 2.0. See LICENSE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @inventarch/compliance
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pure checks over compiled IA records and graph views. validateSchema supports bootstrap; validateGraphSchema uses admitted active graph relationships. Schema/system admission, fragments, declared coverage, selectors, exact variant ambiguity, check declarations and structural adoption feed evaluate(graph, options), which returns a stable immutable revision report.
+
+Supply source diagnostics, discovered system folders and matching-revision kernel/fixture evidence explicitly. Missing observations or adoption clause evaluators produce not-evaluated. Case declarations establish coverage, not execution. Only supplied clause evaluators can establish adoption results. No filesystem I/O, model loop or capability execution occurs here.
+
+An optional trusted evaluator catalog (createEvaluatorCatalog, SPEC C25–C29) lets a host register namespaced evaluators for check.runs, resolve adopted obligations (including the strict-typing-v1 profile), validate evidence receipts and decide whether a transition may be admitted. These are pure functions. The host supplies implementations, codecs, predicates, facts, receipts, the minimum receipt trust, a service-receipt verifier and the current time. It owns execution, scheduling and persistence. Calls without a catalog behave exactly as before. The exported Finding code union now also includes EVIDENCE_CODES; those codes are outside the repository fixture gate (SPEC C29).
+
+[SPEC.md](SPEC.md) owns interfaces, refusal codes and delivery evidence. The package depends on @inventarch/language and @inventarch/graph. Run pnpm compliance:check at the workspace root to verify the real native corpus, kernel, conformance pairs and refusal-code boundaries. --json emits the report; the command prints unavailable checks and exits unsuccessfully on failed checks.

package/SPEC.md

@@ -0,0 +1,128 @@
+# Compliance specification
+
+Evaluator catalog extension: the producer side of trusted evaluator catalog and obligations is implemented by C25–C29 below (EVAL-01..04, OBL-01..03 including the strict-typing-v1 profile mapping; qualification cases EVAL-Q01, Q02, Q07 and Q08, and the producer side of Q03, in tests/evaluator-catalog.test.ts). It is explicit and optional: calls without a catalog keep the built-in-only behavior, and unknown check.runs ids still refuse. Still open and owned elsewhere: the API transactional controller and managed transition seam (spec §4, LK-06), the ia-apps fixed-to-catalog consumer (LK-05), the consumer-side cases EVAL-Q04–Q06 (late edit/reevaluation, concurrent workers and durable intent, silent agents), the consumer side of EVAL-Q03 (a real compiler evaluator and excluded-source detection), and enrolment of the new codes in the repository fixture gate (C29). No scheduler, execution, persistence or native word is added here.
+
+Status: implemented through stage C and the D/R/E integration clauses C21–C23. Task evidence below is chronological; statements of later work within early checkpoints describe that checkpoint only. Shared owners: systems design sections 3–5 and language section 4.3.
+
+## Instance schemas
+
+C01. Pure `validateSchema(record, registry, pool)` returns a `COMP-SCHEMA` assessment with outcome pass, fail or not-evaluated and namespaced findings. `pool` contains admitted target occurrences, including the subject where needed. No I/O or parsing occurs here. Callers exclude language-error previews before validation. A separate verdict constructor adds the caller's explicit revision to assessments; no clock-derived revision. Only compliance emits verdicts.
+
+C02. Resolve the subject's schema through its registered discriminator. A missing registration/schema or mismatched kind is one failure for that subject and consumes its subordinate checks. The floor's system/schema registrations use their actual native schema declarations when present; absence is not waived by this checker.
+
+C03. Require each `must have` section. Under closed, diagnose every unlisted section. Repeated sections form one logical field collection. Cognition and activation are floor-owned and always admitted even under closed; their validity remains language-owned. Head is a virtual field section, never a required body section. Closed applies to keys as well as section names (C04b); open admits any key.
+
+C04. For each schema field, use its section and exact key. The current dialect admits exactly section.key with a single-token key; nested paths and schema spelling of multiword keys are not added here. Must fields require a present field. An absent optional section creates no subordinate field obligation. A missing required section consumes missing-field reports beneath it. Validate every occurrence, so one valid duplicate does not mask a wrong-typed duplicate. A declared key whose type is not `list of T` is exactly one field: `must have` means exactly one for non-list types and `may have` at most one. A second occurrence of such a key, counted across repeated sections and in the virtual head section, is FIELD-DUPLICATE, reported once per schema row at the second occurrence's span, while every occurrence is still type-checked and narrowed (C04a). Only a `list of T` key may repeat. Undeclared keys are not counted (D3, work-system design O-6, 2026-09-25); under open they remain admitted, under closed they are FIELD-UNKNOWN (C04b). Missing required field: FIELD-MISSING; bad present value: FIELD-TYPE. One failed value, including a bad list member, yields one finding at the field.
+
+C04b. Under `closed`, a declared body section admits only the keys the schema declares for it (D1 / W0-L4, work-system design O-6, 2026-09-25). Every other ordinary field is FIELD-UNKNOWN (error) at its own span, `closed @schema <name> does not declare '<section>.<key>'`; the children of an undeclared block fold into its one finding, `- item` lines are not keys, and W0 narrowing still applies to the declared keys beside it. An ordinary field is a compiled field the compiler left as a field. Exempt, because the language reads them itself: the head (virtual, open); the floor grammar sections `relationships`, `cognition` and `activation` (edges, cells, selectors); a field the compiler consumed as a semantic product, decided by span, namely a governance variant clause (`record.variants`; `readVariants` takes every `governance` field except `severity` and `when`) or a contract requirement clause (`record.requirements`, the `REQ-*` lines); and a `section.key` path listed in the kernel `DIMENSION_PATHS` (today `governance.severity`), which the graph reads as a coordinate. Records of the two floor dialect words `schema` and `system` are exempt whole: their body is the schema/system dialect (`sections.must have`, `fields.may have`, `edges.may`, `closed`), and `@schema schema` is closed with no declared field. The two dialect words and the three grammar sections are the only name-based exemptions; every other carrier is recognised by what the compiler emitted for it.
+
+C04a. A field whose schema row carries a W0 narrowing (language L19a) is checked further once its value matches its type, each narrowing yielding at most one finding per field occurrence, list items included: `values` (from `id in [...]`) requires every scalar or quoted text to be a member, compared exactly, else FIELD-VALUE; `target` (from `ref to <word>`) requires every reference's discriminator to equal the word, else FIELD-REF-TARGET, and otherwise, when the caller supplied a reference lookup, warns FIELD-REF-MISSING for a reference no admitted record declares; `form` (from `text form <form>`) requires every text to match the form, else FIELD-FORM. `validateSchema` looks references up in its pool (the subject included) through `resolveTarget` over the candidates sharing the reference's word and name; `validateGraphSchema` looks them up in the admitted graph. An ambiguous target is not missing: identity ties are graph-owned. A narrowed field with no matching value, an absent optional section, or a value that already failed its type raises no narrowing finding.
+
+C05. Value semantics (`matchesType`) and text forms (`matchesForm`, C04a): `iso-date` admits exactly `YYYY-MM-DD` where the month is 01–12 and the day exists in that month, leap years by the Gregorian rule; no time, zone or single-digit part. Text admits scalar, string or prose (including empty quoted text); id admits scalar/string matching an ASCII letter followed by letters/digits/hyphens; qname admits scalar/string with exactly four nonempty canonical identity slots (lowercase system/kind/facet/name, closed kind); number admits a finite decimal scalar/string with optional sign, fraction and exponent, no empty/hex/Infinity; ref admits only typed sigil references; flag admits none (a bare key) or scalar true/false. Block is not a flag. `list of T` requires a list and validates every item against T; an empty list is valid because the dialect has no nonempty-list constraint. Type recognition is over compiled values, not lexical matching of IA source.
+
+C06. Edge obligations use logical outbound active predicates, including inbound assertions authored on other admitted records. Count distinct (target identity, fragment) pairs; equivalent reciprocal assertions do not inflate cardinality. Match target by closed kind or discriminator. Required one/one-or-more means at least one; one and optional cap at one even for a may row. A required field with type flag is present when its bare key occurs. A must optional row has zero minimum (optional explicitly permits absence). A may one-or-more row permits absence but has no maximum. Unconditional edges can establish a static obligation. Conditioned edges or unresolved/ambiguous targets that could change its answer produce EDGE-UNRESOLVED and not-evaluated unless an independently certain failure already establishes fail. A dangling edge cannot be counted as a pass. This checker does not select a coordinate or execute contracts.
+
+C07. Findings use language's location/severity/message shape with IA-COMP codes; stable order is path, line, code, message. Codes: SCHEMA-MISSING, SCHEMA-KIND-MISMATCH, SECTION-MISSING, SECTION-UNKNOWN, FIELD-MISSING, FIELD-UNKNOWN, FIELD-DUPLICATE, FIELD-TYPE, FIELD-VALUE, FIELD-REF-TARGET, FIELD-REF-MISSING, FIELD-FORM, EDGE-CARDINALITY, EDGE-UNRESOLVED. All are errors except EDGE-UNRESOLVED (warning with not-evaluated) and FIELD-REF-MISSING (warning; the assessment still passes, so admission is not blocked by a dangling typed reference). A failed check dominates not-evaluated. Source spans refer to the offending instance; missing structure refers to the containing record or section/block.
+
+## Delivery boundary and evidence
+
+Task 1 must cover all C01–C07 branches with native language compilation, plus direct boundary cases where graph admission is the caller's job. Schema validation is the early reusable part of COMP-SCHEMA/COMP-KERNEL. Enrollment, consent, fragments, coverage, adoption, fixtures, steward/bootstrap, scenario execution and a full revision report remain later work and must never be reported as passing by this API.
+
+Task 1 evidence: 62 compliance tests (native parse/registry/compile instances and scalar boundary tests), 1001 language tests, workspace typecheck/build and a built-package success/refusal consumer pass. The initial nested-path proposal was removed after native dialect probes; no grammar expansion was made.
+
+## Native system admission (Plan 4 Task 3)
+
+C08. `validateSystems(folders, registry, pool)` is pure. A folder supplies its canonical relative path, name, parsed sources and admitted compiled records. The host supplies all discovered folders, including empty ones. Each must contain exactly one system declaration, located at its direct system.ia with the same name. A malformed folder receives SYSTEM-MALFORMED once and consumes its subordinate ownership/steward checks. Parser/registry faults remain owned by language; the host excludes their previews before this check.
+
+C09. Every admitted record in a valid folder uses the folder's own registered word, a word from a directly required system, or a fixed floor word. Floor system/schema are always visible and need no extra requires item. Unregistered words remain language-owned. A foreign registered word yields DISCRIMINATOR-FOREIGN at that record. Nested records are independent subjects. Full resolved dependency order must place each declared requirement before its dependent; a missing registration/system remains language-owned. BOOTSTRAP-ORDER diagnoses a supplied inconsistent order, not a separate hardcoded sorting policy.
+
+C10. A steward reference must be @agent, resolve to exactly one admitted agent occurrence inside that folder, and have an unconditioned governance.applies whose value is a list of discriminator ids including every word minted there. Missing/ambiguous/wrong-kind/foreign steward or missing applies coverage yields one STEWARD-MISSING per system naming missing coverage. This list is an ownership declaration, not execution permission. Agent-system self-steward is admitted; other folders require agent-system directly. The kernel is not a system folder and has its separate exemption.
+
+C11. Each active registration's word must occur on either side of at least one consent row, with wildcard matching; absence yields CONSENT-EMPTY warning and does not invalidate structural admission. Each visible schema is enrolled by exactly one active registration, counting fixed floor registrations. Zero yields SCHEMA-UNREFERENCED; more than one yields SCHEMA-MULTIPLE. Independent warning evidence can coexist with pass; only an unavailable evaluation is not-evaluated. Assessments returned are COMP-SYSTEM, COMP-STEWARD, COMP-BOOTSTRAP, COMP-SCHEMA-ENROLLED and COMP-CONSENT-DECLARED. Actual edge consent remains a separate check.
+
+C12. Native systems own README/SPEC next to their records. The first five and their record closure must compile and pass instance/admission checks without substitute TypeScript providers. Their stewards and methods are authored roles/procedures; this task does not launch agents, execute scenarios or install a hook. Success/refusal mutation tests must use the real floor/system sources. Native sources are authored, not generated from legacy catalogs.
+
+Task 3 evidence: native system admission is exported and consumed by pnpm native:check. The five-system closure has 153 records and 170 passing structural assessments. Nineteen native mutation/connection tests cover C08-C12, alongside 62 schema tests and 21 kernel tests; the language suite remains 1001 passing tests. Typecheck/build pass. No scenario engine or host execution is claimed.
+
+## Full graph and revision checks (stage C)
+
+C13. The full suite consumes an immutable Graph and explicit source diagnostics/folder descriptions. Its registry is graph.registry, and graph winners alone supply semantic subjects. A report retains verdicts keyed by check/scope with graph.revision and a stable aggregate outcome (fail dominates not-evaluated, which dominates pass). Language and graph findings retain their original codes, spans and severity; no second wrapper finding repeats the same fault. Findings sort by path, line, code and message. Exposed results are immutable snapshots. Source diagnostics are supplied explicitly, so absence of source evaluation evidence is not a parse pass.
+
+C14. Full graph schema validation shares C02-C05 field rules but counts admitted graph active edges under C06. Late-resolved edges count, rejected-consent edges do not. A graph-owned edge refusal leaves the dependent predicate obligation not-evaluated without a second absence diagnostic. Fragment cardinality keys use the endpoint the fragment actually addresses. Unresolved/conditioned edges retain uncertainty; do not count a condition as unconditional satisfaction. The early validateSchema(record,registry,pool) API remains for bootstrap without a graph.
+
+C15. COMP-FRAGMENT checks resolved references on every graph edge: phase/Primitive must name an existing target cell and a requirement fragment must name an existing target requirement. Use fragmentEndpoint after inverse normalization. A missing target remains graph-owned; no duplicate missing-fragment error is added. Invalid resolved fragment: FRAGMENT-MISSING. Coverage accepts unconditional active implement edges from a case to a contract requirement, using active direction; the fragment must address the contract endpoint rather than an inverse assertion's case endpoint. Every contract requirement needs a declared case; each contract needs a success case and a failure or refusal case. Conditional/dangling edges cannot establish that static coverage. COVERAGE-MISSING names uncovered requirements; COVERAGE-KIND names missing case classes when requirement coverage itself is complete; uncovered requirements consume subordinate case-class reports. Coverage does not execute cases or satisfy adoption.
+
+C16. COMP-CONSENT and COMP-IDENTITY retain graph-owned refusal findings and report unresolved relationships as not-evaluated where consent cannot be determined. Shadowing is retained as report evidence, not a tie error. COMP-SELECTOR checks compiled terms against closed language axes/values; invalid caller-supplied products cannot establish a pass. COMP-PARSE consumes supplied language diagnostics; a missing set of observations is not-evaluated. COMP-CHECK validates each check.runs id against the implemented inventory; malformed/missing/unknown ids produce CHECK-UNKNOWN once per declaration. Check declarations do not turn a check on or supply execution evidence.
+
+C17. COMP-VARIANT performs exact finite satisfiability per record/key family. Search equal-specificity pairs for overlap not covered by higher-specificity clauses, with absent routing axes included and dimensions read as graph G08. One witness per ambiguous family produces VARIANT-AMBIGUOUS at the first conflicting clause and names the competing source lines and canonical request coordinate. No arbitrary domain-product bound or cutoff; prune impossible/dominated regions. A lower tie covered at every coordinate by stronger clauses is valid. An unconditional family can tie at a coordinate with omitted axes even when every fully supplied coordinate has a stronger clause.
+
+C18. COMP-ADOPTION concerns each admitted active require relationship from an adopter to an @contract. Resolve its requirement clauses using their conditions only when an explicit coordinate is supplied; otherwise a conditional clause remains not-evaluated. Evaluators are supplied explicitly by contract identity and requirement id, receive the graph/adopter/contract/requirement and return pass/fail/not-evaluated plus explanatory text. Missing evaluators and thrown evaluator errors are not-evaluated with named evidence; a reported violation is ADOPTION-FAILED. This is structural verification only, not a code interpreter or permission to execute capability effects. No requirements is not proof of an authored contract; language owns contract shape.
+
+C18 repository consumer: [tools/compliance](../../tools/compliance/SPEC.md#foundation-authoring-adoption) supplies the three foundation-authoring callbacks from actually executed native source scenarios. That adapter checks source revision, adopter and view before using observations, retains missing/stale evidence as not-evaluated, and reports observed violations as failures. This is explicit host registration, not a package default. Database/runtime reports without callbacks remain not-evaluated, and declaration-only COMP-COVERAGE never satisfies COMP-ADOPTION.
+
+C19. COMP-KERNEL and COMP-FIXTURES require caller-supplied matching-revision assessments from actual verification. No supplied result or a stale result produces NOT-EVALUATED. A pure language-fixture runner can consume source and expected products/diagnostics/format companions without reading files; tools discover fixtures and record observed results. Every named refusal must have a tested failing case; unavailable fixture coverage stays explicit. General prose scenario execution remains outside this stage.
+
+C20. Public checks use IA-COMP-FRAGMENT-MISSING, COVERAGE-MISSING, COVERAGE-KIND, SELECTOR-INVALID, CHECK-UNKNOWN, VARIANT-AMBIGUOUS, ADOPTION-FAILED, NOT-EVALUATED and FIXTURE-MISMATCH in addition to C07/C11. NOT-EVALUATED is warning evidence that changes the outcome; warning consent-empty/shadow evidence does not fail an otherwise completed check. Source parse/graph codes remain namespaced by their owners. Every implementation delivery records full-suite, negative/native and built-consumer evidence here.
+
+Stage C Task1 delivered: graph schema/fragment/coverage, selector/check-id/source/consent/identity checks and immutable assessments. Native 153-node closure passes these checks. Thirteen graph-check tests cover removed cases, conditional coverage, missing targets/fragments, inverse cell fragments, late resolution, source-code preservation, malformed selectors/runners and consent-refusal diagnostic consumption. Full suite: 1453 tests/48files; typecheck/build/kernel/dependency pass. Exact variant ambiguity, adoption and assembled revision reports remain next.
+
+Stage C Task2 delivered: exact finite ambiguity with witness coordinates and explicit structural adoption evaluators. Thirteen new tests include 128 bounded families compared against exhaustive graph-query evaluation, partial/full domination, missing axes, fixed dimensions, a nine-axis family, absent/throwing/failed evaluators and conditional/unresolved adoption. 88 compliance tests; 1466 workspace tests/49files, typecheck/build/kernel/dependencies pass. Native declarations alone intentionally leave adoption not-evaluated. Full revision reports and executable fixture evidence remain next.
+
+Stage C Tasks3/acceptance delivered: evaluate produces immutable revision reports, preserving originating codes, graph dimension refusals and shadows. Provisional compile missing-target warnings are replaced by graph resolution for the same assertion. Reports restrict folder semantic checks to graph winners. The pure fixture runner consumes supplied source/companions; tools/compliance reads the real tree, verifies generated kernel bytes and executes 176 language plus 34 boundary fixtures covering every current language/graph/compliance code. The native report has 485 verdicts: 484 pass and one adoption not-evaluated without clause evaluators. No executed prose scenarios are claimed.
+
+Verified 1472 tests/51files (1241 language,92 graph,92 compliance,47 tools), typecheck/build/native/kernel/dependency checks and built-package runtime/declaration consumer. Compliance stage C is delivered; database admission/publication, runtime packets and specialized execution retain their next-plan owners.
+
+C21 (database admission integration). The report assembler may receive prior failed/unavailable admission assessments for subjects subsequently removed from its graph. Retain those observations, coalescing a repeated check/scope at the worst outcome and deduplicating findings. Do not retain earlier candidate-only passes as final evidence. This lets db publish an admitted subset while the compliance report still names refused source subjects. Coverage and adoption are evaluated on the final graph.
+
+C21 delivered with database Task2: report options accept prior non-pass admission observations, coalesce identical check/scope at the worst outcome and deduplicate findings. Candidate-only passes are ignored. The regression test retains removed-subject evidence without duplicate verdicts.
+
+C22. renderHostArtifacts projects admitted systems and their steward declarations into language-reference host artifacts. It validates revision-bound membership and unique host-safe identities. No named authoring procedure or expert methodology is required.
+
+C23. Stage E projections additionally cite and render unconditional cells of the steward's domain playbooks, in stable identity order. Since plan 2026-09-24 §0.1 these are the playbooks the steward `uses` plus those its profile's capabilities list, not every playbook physically in the steward folder; tools/projections/SPEC.md P05-P10 own the steward composition, block-clause and host-table rules. This exposes specialised operation methods without replacing the shared24-cell method. Conditional instructions are not silently rendered as unconditional.
+
+C24 (PT1 source subset). `renderHostArtifacts(records, revision, membership?)` accepts optional `ProjectionMembership`: the matching revision and unique `{path, system, root}` observations for every source path in the supplied admitted view, with both system/root null outside physical system folders. The composition root obtains these through public db `systemMember`; compliance never imports db or resolves source mounts. Validate observations against supplied records, canonical relative paths, direct declaration location and unique system/steward occurrences. Associate admitted project contributions by logical system membership across physical roots; retain exact adopted citations and mark adopted definitions immutable. Missing/stale/conflicting observations or required scope-excluded records refuse with the existing single projection diagnostic and no partial output. The two-argument compatibility form supports only the existing authored local layout; adopted callers supply observations. Equal local inputs preserve artifact bytes. This does not implement resource loading, arbitrary plugin compilation or installed-generation admission.
+
+## Trusted evaluator catalog, obligations and evidence (spec-0007 producer)
+
+C25 (catalog v1, EVAL-01). Pure `createEvaluatorCatalog({format, entries}, {codecs, builtins?})`. The top level must be exactly `{format, entries}` with format `ia-evaluator-catalog/1.<minor>`; an unknown key (e.g. `revocations`), another major or another shape is CATALOG-VERSION. Minor-version handling: any minor of major 1 is accepted, but every entry must use exactly the v1 fields, so a later minor that adds behavior is refused rather than silently ignored; the declared format, minor included, is part of the digest. An entry has exactly id, contractVersion, implementationVersion, implementationDigest, inputSchemaId, outputSchemaId, supportedScopes, effects, environmentProfile, limits, evidencePolicy and availability; an unknown or missing field is CATALOG-ENTRY-INVALID. The id is a lowercase namespaced `id` (at least one hyphen, e.g. `acme-strict-typing`) so it stays a valid native `check.runs` value. Only CHECK_IDS are built in (D4). `options.builtins` lists host-reserved ids (validated as `A-Z`/`a-z` ids, otherwise TypeError); an entry id equal case-insensitively to a CHECK_IDS or reserved id, or in the reserved `comp` namespace, is CATALOG-BUILTIN-OVERRIDE. Reserved ids are recorded as `catalog.reserved`; they never pass COMP-CHECK and never resolve as evaluators. Versions are MAJOR.MINOR.PATCH; a contractVersion major outside EVALUATOR_CONTRACT_MAJORS (1) is CATALOG-VERSION. implementationDigest is `sha256:<64 hex>`. inputSchemaId/outputSchemaId are `name@major` ids that must be in the host codec registry, otherwise CATALOG-CODEC-UNKNOWN; a codec is trusted host code with `validate` and an optional `normalize`. supportedScopes (nonempty) and effects are unique ids. environmentProfile is `{id, credentials: none | scoped}`; ambient credentials are not expressible. limits require positive safe-integer timeoutMs, memoryBytes, outputBytes and concurrency (CATALOG-LIMITS). evidencePolicy is `{kind: fresh-run}` or `{kind: reusable, maxAgeMs, environmentSensitive}`. availability is `{status: supported}` or `{status: unavailable | revoked, reason}` with a printable single-line reason of at most 200 characters and no credential assignment. A repeated id@implementationVersion is CATALOG-DUPLICATE when the digests agree and CATALOG-DIGEST-CONFLICT when they differ; more than one supported version of one id is CATALOG-DUPLICATE. Findings carry the 1-based input index of the offending entry. Any finding refuses the whole catalog with no partial result. The accepted catalog is deeply frozen, entries sorted by id and version, with digest `sha256` of the canonical serialization of the format, entries, built-in and reserved ids; equal inputs in any entry order give equal digests. Only objects returned by this constructor are accepted by the functions below (`isEvaluatorCatalog`); a copied or hand-built object is a TypeError.
+
+C26 (check.runs with a catalog, EVAL-02, EVAL-Q01/Q02). `validateCheck(node, catalog?)` and `evaluate(graph, {catalog})`. Without a catalog the result is byte-identical to C16. With one, a CHECK_IDS id passes as before; otherwise `selectEvaluator` picks the id's supported entry, else its highest listed version. Supported passes. Revoked is EVALUATOR-REVOKED, a blocking error. Unavailable is an EVALUATOR-UNAVAILABLE warning and the assessment is not-evaluated (D5): an unavailable evaluator does not refute the declaration, and blocking belongs to admission of a required obligation, while an optional one stays visibly unevaluated (EVAL-02). An id in neither set, including a host-reserved id, is still CHECK-UNKNOWN. Native `check.runs` records and schemas are unchanged. Catalog text never names a callback, command or path: `bindEvaluators(catalog, implementations)` associates trusted host implementations keyed `${id}@${implementationDigest}`, and any key naming an unknown, substituted, unavailable or revoked implementation is EVALUATOR-SUBSTITUTED and refuses the whole binding. The host must bind before invoking; binding invokes nothing, and admission independently checks each receipt's evaluator id, version and digest against the catalog (C28).
+
+C27 (obligation resolution, OBL-01..03, EVAL-02). Pure `resolveObligations(input)` takes the subject, policy revision, catalog, the catalog digest the policy pins, captured scope facts (JSON data), the root adoption set, the selected law/contract/check occurrences (identity, word, adoption, requirement fragment, runs, provenance `{path, line}`, optional applicability predicate id, required flag and JSON input), trusted versioned applicability predicates (`name@version`) and package metadata directives. It returns a deeply frozen resolution sorted by `obligationId` (`obl:` sha256 of subject, occurrence, requirement and runs), each with subject, requirement, provenance (path, line, adoption, source), applicability, required, evaluator identity (built-ins use version `builtin`, digest `builtin:<id>` and fresh-run evidence), `inputDigest` and evidence policy. The input must be JSON data and must satisfy the evaluator's input codec; the digest covers the codec-normalized value, so equivalent inputs share a digest. Predicates receive a deeply frozen copy of the facts, never the caller's object. Applicability is applicable, not-applicable or undetermined. not-applicable always carries resolver evidence: `basis: predicate` with the predicate id@version, or `basis: package-metadata` with the directive source. A missing, throwing or malformed predicate is undetermined with a fixed message that never echoes predicate output. Undetermined required applicability is OBLIGATION-UNDETERMINED (blocking). OBLIGATION-UNRESOLVED covers: a malformed occurrence (missing provenance included) or adoption; an adoption or runs id that does not resolve (a reserved id never resolves, D4); an input that is not JSON or fails its codec; a package directive that is malformed (the action set is closed to `optional` and `disable`, and the source must be sanitized) or names no selected obligation (M3). OBLIGATION-CONFLICT covers a pinned catalog digest that differs, one adoption declared with conflicting source or mandatory status, and one obligation selected twice with different content. Either refuses with status `refused` and no obligations. A root-adopted mandatory obligation is always required. Package metadata never changes any root-adopted obligation, whether the root made it required, optional or mandatory: the directive is ignored with an OBLIGATION-WEAKENED warning (D1; spec-0007 OBL-01, source precedence cannot silently weaken root requirements). Metadata may relax or disable package-adopted obligations only. Every resolution carries `digest = resolutionDigest(content)` over its canonical content, which includes the catalog digest and policy revision, and is recorded as issued by this module (D2). `inspectObligations(input)` returns the same selection as rows with support (builtin, supported, unavailable, revoked or unknown), versions, applicability and required flag, including unresolved rows, and never calls an evaluator. Predicates and codecs are the only host code called.
+
+C28 (receipts and admission, EVAL-03/04, EVAL-Q07/Q08). Receipt format `ia-evidence-receipt/1` has exactly format, receiptId, attemptId, obligationId, subject, inputDigest, digests {candidate, native, code, policy, dependency}, environment {id, toolchain}, evaluator {id, implementationVersion, implementationDigest}, catalogDigest, policyRevision, observedAt, completedAt, result (passed, failed, unavailable, error, cancelled, not-evaluated, not-applicable), evidenceDigest, issuer and trust (local-unsigned or service-associated). Text fields, receiptId and issuer included, must be sanitized single-line text. `validateReceipt(receipt, expectation, now)` takes an explicit ISO-8601 UTC `now`; it and every receipt time must be a real calendar instant (round-trip checked, so 2026-02-30 is invalid). The checks run in this order:
+- shape and time order: RECEIPT-INVALID
+- obligation and subject: RECEIPT-SUBJECT
+- evaluator known to the catalog with the same digest: RECEIPT-EVALUATOR
+- evaluator not revoked: RECEIPT-REVOKED
+- evaluator equal to the obligation's evaluator: RECEIPT-EVALUATOR
+- code digest: RECEIPT-CODE
+- toolchain: RECEIPT-TOOLCHAIN
+- trust: RECEIPT-UNTRUSTED (D3). Trust is never self-asserted. A service-associated receipt counts only when the host passed an explicit `verifyServiceReceipt` callback that returns true for a frozen copy of it; the issuer string alone never elevates trust. `minimumTrust` is required, with no default: `service-associated` refuses local receipts.
+- candidate, native, policy, dependency and input digests, policy revision, catalog digest and, for fresh-run or environment-sensitive policy, environment id: RECEIPT-STALE
+- fresh-run attempt identity: RECEIPT-FRESH-RUN
+- reusable maximum age: RECEIPT-EXPIRED
+
+`evidenceKey` is the EVAL-04 deduplication key over candidate, obligation, evaluator, policy revision and digest, the environment `{id, toolchain}` (toolchain only when environment-insensitive; no other fields) and, for fresh-run, the attempt.
+
+`acceptEvaluatorOutput(catalog, obligation, observation, {secrets?})` never throws for evaluator output. It maps a host observation to a result:
+- unsupported evaluators are `unavailable`;
+- timeouts, crashes, a missing or oversized byte length, output that is not JSON data (a Date, Map, function, cycle or non-finite number), an envelope other than `{result: passed | failed, evidence, diagnostics?}`, a hostile object that throws on read, and codec rejection or throw are all `error`, with EVALUATOR-OUTPUT-INVALID and fixed messages.
+
+Failed diagnostics are sliced to 20 entries before filtering, and each line is redacted and then truncated to 240 characters. Redaction runs in this order: control characters are normalized to spaces (in the lines and in the supplied secrets, M2), then supplied secret values, bearer tokens, quoted keys (`"password":"x"`), `KEY=value` or `KEY: value` where the key contains token, secret, password, passwd, api_key, credential, auth or private_key as a substring (e.g. `GITHUB_TOKEN=`, `AWS_SECRET_ACCESS_KEY=`), and `key 'value'` forms are replaced by `[redacted]`. A built-in obligation is a TypeError there. `adaptBuiltinVerdict(obligation, verdict?)` maps a built-in verdict to the envelope: pass is passed, fail is failed, not-evaluated or absent is not-evaluated (spec §5 preserves unevaluated built-in outcomes).
+
+`admitTransition(resolution, receipts, context, now)` first verifies the resolution (D2): its digest must recompute from its content, and it must either be resolver-issued in this process (the frozen, branded object) or match `context.expectedResolutionDigest` pinned by the host. Every obligation must be structurally sound: the id recomputes; built-in evaluators are CHECK_IDS with the built-in digest; catalog evaluators match the catalog's id, version, digest, contract version and evidence policy; not-applicable carries predicate or package-metadata evidence and never package-metadata on a root adoption. Otherwise the decision is OBLIGATION-UNVERIFIED and not admitted. The digest is an integrity check, not authentication: a resolution that crosses a trust boundary must have its digest pinned by the host. Admission then requires the same catalog and policy, and that every required applicable obligation has a valid passed receipt of at least `minimumTrust` as its latest valid result (a same-time non-pass wins). The following block a required obligation:
+- failed (OBLIGATION-FAILED);
+- unavailable, error, cancelled, not-evaluated, evaluator-claimed not-applicable, or missing or invalid evidence (OBLIGATION-BLOCKED);
+- undetermined applicability;
+- an unavailable or revoked evaluator.
+
+Resolver not-applicable with evidence does not block. An optional obligation never blocks and is reported as `optional-unevaluated`, or `optional-failed` when its latest valid receipt failed. Each decision records the trust of the receipt it relied on, and the transition records `minimumTrust` and `reliedTrust` (the weakest trust among satisfying receipts, or none). A local unsigned receipt is a local diagnostic. None of these functions reads files, a clock or the network, schedules or executes anything, or persists receipts.
+
+C29 (evaluation profiles, OBL-02; facilitator decision D6). `EVALUATION_PROFILES['strict-typing-v1']` is the consumer contract id mapping to three requirements: `configuration`, `included-file-coverage` and `compiler-run`. `profileOccurrences('strict-typing-v1', binding)` expands one selected law or contract occurrence into three required occurrences with requirements `strict-typing-v1/<name>`, each discharged by a host catalog evaluator named in the binding. A built-in id, a non-catalog id, an unknown profile or a missing or extra mapping is a TypeError. The profile is not a native word. Declarations, native cases and check records never become results by presence: the three obligations are admitted only with valid passed receipts, so a real compiler run requires an installed evaluator and its receipt.
+
+Facilitator decisions recorded for LK-04 repair (2026-09-28): D1 package metadata never weakens a root-adopted obligation (C27); D2 admission is bound to a verified resolver-issued resolution (C27, C28); D3 service trust needs a host verifier, `minimumTrust` is required and trust is recorded (C28); D4 only CHECK_IDS are built in, `options.builtins` only reserves ids (C25, C26); D5 COMP-CHECK treats revoked as an error and unavailable as not-evaluated (C26); D6 the strict-typing-v1 producer mapping belongs to this package (C29).
+
+Public type note: `Finding['code']` now also admits `EvidenceCode`, an additive widening of the exported union; consumers that switch exhaustively over `Finding['code']` must handle the new codes. C25–C29 codes are exported as `EVIDENCE_CODES`, separate from COMP_CODES. They are outside the repository fixture gate: tools/compliance/check.ts requires a boundary fixture for every COMP_CODES code, and tools/compliance/check.test.ts pins the boundary count. Open follow-up (repository-tool owner): enrol EVIDENCE_CODES there with boundary fixtures, and qualify the coverage claim beside tools/compliance/check.ts:63, which today covers COMP_CODES only. Their refusals are covered by tests/evaluator-catalog.test.ts.
+
+LK-04 delivered (2026-09-28): C25–C28 with 23 tests. LK-04 repair (2026-09-28) added D1–D6, the M2/M3 fixes and C29, bringing tests/evaluator-catalog.test.ts to 35 tests. They cover EVAL-Q01, Q02, Q07, Q08, the producer side of Q03, OBL-01..03 and each catalog, binding, resolution, receipt and admission refusal, plus a byte-identical report regression without a catalog. The pre-change report digests on the native corpus (with and without supplied observations) were unchanged after the original change and after the repair.

package/dist/adoption.d.ts

@@ -0,0 +1,18 @@
+import type { Requirement } from '@inventarch/language';
+import type { Coordinate, Graph, Node } from '@inventarch/graph';
+import type { Assessment } from './types.js';
+export interface ClauseContext {
+    readonly graph: Graph;
+    readonly adopter: Node;
+    readonly contract: Node;
+    readonly requirement: Requirement;
+    readonly coordinate?: Coordinate;
+}
+export interface ClauseResult {
+    readonly outcome: Assessment['outcome'];
+    readonly message: string;
+}
+export type ClauseEvaluator = (context: ClauseContext) => ClauseResult;
+export type AdoptionEvaluators = ReadonlyMap<string, ReadonlyMap<string, ClauseEvaluator>>;
+export declare function validateAdoption(graph: Graph, evaluators?: AdoptionEvaluators, input?: Coordinate): readonly Assessment[];
+//# sourceMappingURL=adoption.d.ts.map

package/dist/adoption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adoption.d.ts","sourceRoot":"","sources":["../src/adoption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGjE,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,YAAY,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;CAClC;AACD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AACD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,aAAa,KAAK,YAAY,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;AAC3F,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,UAAU,GAAE,kBAA8B,EAC1C,KAAK,CAAC,EAAE,UAAU,GACjB,SAAS,UAAU,EAAE,CAwGvB"}

package/dist/adoption.js

@@ -0,0 +1,76 @@
+import { conditionHolds, validateCoordinate } from '@inventarch/graph';
+import { finding } from './graph-checks.js';
+import { assess } from './types.js';
+export function validateAdoption(graph, evaluators = new Map(), input) {
+    const coordinate = input === undefined ? undefined : validateCoordinate(input), assessments = [];
+    for (const adopter of graph.nodes.values()) {
+        const adoptions = graph.out.get(adopter.identity)?.get('require') ?? [];
+        // Several assertions of one adoption cannot execute a clause twice.
+        const byContract = new Map();
+        for (const edge of adoptions) {
+            if (edge.to === null) {
+                const registration = graph.registry.registrations.get('contract');
+                const refersToContract = edge.reference.kind === 'ref'
+                    ? edge.reference.discriminator === 'contract'
+                    : registration !== undefined &&
+                        edge.reference.identity.startsWith(`${registration.system}/${registration.kind}/`) &&
+                        registration.facets.includes(edge.reference.identity.split('/')[2] ?? '');
+                if (refersToContract)
+                    assessments.push(assess('COMP-ADOPTION', `${adopter.identity}->${edge.reference.kind === 'ref' ? `@contract ${edge.reference.name}` : edge.reference.identity}`, [], true));
+                continue; // graph consent assessment retains the missing-target finding
+            }
+            if (graph.nodes.get(edge.to)?.discriminator !== 'contract')
+                continue;
+            const edges = byContract.get(edge.to) ?? [];
+            byContract.set(edge.to, [...edges, edge]);
+        }
+        for (const [identity, edges] of byContract) {
+            const contract = graph.nodes.get(identity), findings = [];
+            const active = edges.some((edge) => edge.condition === undefined ||
+                (coordinate !== undefined &&
+                    conditionHolds(edge.condition, graph.nodes.get(edge.conditionSubject).dimensions, coordinate)));
+            if (!active) {
+                if (coordinate === undefined)
+                    findings.push(finding('IA-COMP-NOT-EVALUATED', adopter, `Conditional adoption of ${identity} needs an explicit coordinate`, edges[0].source.line, true));
+                else
+                    continue; // this coordinate does not adopt the contract
+            }
+            else
+                for (const requirement of contract.requirements) {
+                    if (requirement.condition !== undefined && coordinate === undefined) {
+                        findings.push(finding('IA-COMP-NOT-EVALUATED', adopter, `${identity}#${requirement.id}: conditional clause needs an explicit coordinate`, edges[0].source.line, true));
+                        continue;
+                    }
+                    if (coordinate !== undefined && !conditionHolds(requirement.condition, contract.dimensions, coordinate))
+                        continue;
+                    const evaluator = evaluators.get(identity)?.get(requirement.id);
+                    let result;
+                    if (evaluator === undefined)
+                        result = { outcome: 'not-evaluated', message: 'No structural evaluator is supplied' };
+                    else
+                        try {
+                            result = evaluator({
+                                graph,
+                                adopter,
+                                contract,
+                                requirement,
+                                ...(coordinate === undefined ? {} : { coordinate }),
+                            });
+                            if (!['pass', 'fail', 'not-evaluated'].includes(result.outcome) || typeof result.message !== 'string')
+                                throw new Error('Invalid evaluator result');
+                        }
+                        catch (error) {
+                            result = {
+                                outcome: 'not-evaluated',
+                                message: `Evaluator unavailable: ${error instanceof Error ? error.message : String(error)}`,
+                            };
+                        }
+                    if (result.outcome !== 'pass')
+                        findings.push(finding(result.outcome === 'fail' ? 'IA-COMP-ADOPTION-FAILED' : 'IA-COMP-NOT-EVALUATED', adopter, `${identity}#${requirement.id}: ${result.message}`, edges[0].source.line, result.outcome !== 'fail'));
+                }
+            assessments.push(assess('COMP-ADOPTION', `${adopter.identity}->${identity}`, findings));
+        }
+    }
+    return Object.freeze(assessments.sort((a, b) => (a.scope < b.scope ? -1 : a.scope > b.scope ? 1 : 0)));
+}
+//# sourceMappingURL=adoption.js.map

package/dist/adoption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adoption.js","sourceRoot":"","sources":["../src/adoption.ts"],"names":[],"mappings":"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"}

package/dist/catalog.d.ts

@@ -0,0 +1,112 @@
+import type { Assessment } from './types.js';
+/**
+ * Current catalog format (C25). Any minor of major 1 is accepted but must use exactly the v1 fields, so a minor
+ * that adds behavior is refused rather than ignored; the declared minor is part of the catalog digest.
+ */
+export declare const EVALUATOR_CATALOG_FORMAT = "ia-evaluator-catalog/1.0";
+/** Evaluator invocation-contract majors this package understands. */
+export declare const EVALUATOR_CONTRACT_MAJORS: readonly [1];
+export interface EvaluatorLimits {
+    readonly timeoutMs: number;
+    readonly memoryBytes: number;
+    readonly outputBytes: number;
+    readonly concurrency: number;
+}
+export type EvidencePolicy = {
+    readonly kind: 'fresh-run';
+} | {
+    readonly kind: 'reusable';
+    readonly maxAgeMs: number;
+    readonly environmentSensitive: boolean;
+};
+export type EvaluatorAvailability = {
+    readonly status: 'supported';
+} | {
+    readonly status: 'unavailable' | 'revoked';
+    readonly reason: string;
+};
+export interface EnvironmentProfile {
+    readonly id: string;
+    readonly credentials: 'none' | 'scoped';
+}
+export interface EvaluatorEntry {
+    readonly id: string;
+    readonly contractVersion: string;
+    readonly implementationVersion: string;
+    readonly implementationDigest: string;
+    readonly inputSchemaId: string;
+    readonly outputSchemaId: string;
+    readonly supportedScopes: readonly string[];
+    readonly effects: readonly string[];
+    readonly environmentProfile: EnvironmentProfile;
+    readonly limits: EvaluatorLimits;
+    readonly evidencePolicy: EvidencePolicy;
+    readonly availability: EvaluatorAvailability;
+}
+/**
+ * A host-registered codec. `validate` and optional `normalize` are trusted host code; they never come from catalog
+ * text. The input codec validates and normalizes obligation inputs (C27); the output codec validates evidence (C28).
+ */
+export interface EvaluatorCodec {
+    readonly id: string;
+    readonly validate: (value: unknown) => boolean;
+    readonly normalize?: (value: unknown) => unknown;
+}
+export interface CatalogInput {
+    readonly format: string;
+    readonly entries: readonly unknown[];
+}
+export interface CatalogOptions {
+    readonly codecs: ReadonlyMap<string, EvaluatorCodec> | readonly EvaluatorCodec[];
+    /**
+     * Additional host-reserved ids (D4). They only block catalog overrides; they never pass COMP-CHECK and never
+     * resolve as evaluators. Only CHECK_IDS are built in.
+     */
+    readonly builtins?: readonly string[];
+}
+export interface EvaluatorCatalog {
+    readonly format: string;
+    readonly digest: string;
+    readonly entries: readonly EvaluatorEntry[];
+    /** Always exactly CHECK_IDS. */
+    readonly builtins: readonly string[];
+    /** Host-reserved ids from options.builtins, excluding CHECK_IDS, sorted. */
+    readonly reserved: readonly string[];
+}
+export type CatalogResult = {
+    readonly ok: true;
+    readonly catalog: EvaluatorCatalog;
+    readonly assessment: Assessment;
+} | {
+    readonly ok: false;
+    readonly assessment: Assessment;
+};
+export interface EvaluatorBinding<T> {
+    readonly assessment: Assessment;
+    /** The host implementation for an exact supported id and implementation digest, or undefined. */
+    readonly implementation: (id: string, implementationDigest: string) => T | undefined;
+}
+export declare const EVALUATOR_ID: RegExp;
+export declare const DIGEST: RegExp;
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Pure v1 catalog constructor (C25). Refuses unknown format majors, malformed entries, invalid limits,
+ * unknown codecs, built-in overrides, duplicate id/version, digest disagreement and more than one
+ * supported implementation of an id. The result is frozen and carries a deterministic digest.
+ */
+export declare function createEvaluatorCatalog(input: CatalogInput, options: CatalogOptions): CatalogResult;
+/** True only for a catalog returned by createEvaluatorCatalog in this module instance. */
+export declare function isEvaluatorCatalog(value: unknown): value is EvaluatorCatalog;
+export declare function assertCatalog(value: unknown): asserts value is EvaluatorCatalog;
+export declare function codecOf(catalog: EvaluatorCatalog, id: string): EvaluatorCodec | undefined;
+/** The entry check.runs selects: the supported implementation, else the highest listed version. */
+export declare function selectEvaluator(catalog: EvaluatorCatalog, id: string): EvaluatorEntry | undefined;
+export declare function catalogEntry(catalog: EvaluatorCatalog, id: string, implementationVersion: string): EvaluatorEntry | undefined;
+/**
+ * Associate trusted host implementations with supported entries, keyed `${id}@${implementationDigest}` (EVAL-02).
+ * Any key naming an unknown, substituted, unavailable or revoked implementation refuses the whole binding. The host
+ * must bind before it invokes anything; binding invokes nothing, and admission separately checks every receipt's
+ * evaluator id, version and digest against the catalog (C28), so an unbound or substituted run cannot pass.
+ */
+export declare function bindEvaluators<T>(catalog: EvaluatorCatalog, implementations: ReadonlyMap<string, T>): EvaluatorBinding<T>;
+//# sourceMappingURL=catalog.d.ts.map