From b9a6f2ddb513aace3224dc164b2636c16e80046b Mon Sep 17 00:00:00 2001 From: Shay Date: Thu, 21 May 2026 20:25:48 -0700 Subject: [PATCH] =?UTF-8?q?feat(packs):=20ADR-0100/0101/0102=20=E2=80=94?= =?UTF-8?q?=20three=20sibling=20domain=20ratifications?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ratifies the remaining three sibling domains as reasoning-capable under ADR-0091's Domain Pack Contract v1, using the template ADR-0097 established for mathematics_logic. The capability ledger now has four reasoning-capable rows backed by validated contracts. ADR-0100 physics (en_physics_v1): domain_id: physics claimed_operators: causal, modal teaching_chains: [physics_chains_v1] eval_lanes: foundational_physics_ood, inference_closure, fabrication_control 9/9 predicates pass ADR-0101 systems_software (en_systems_software_v1): domain_id: systems_software claimed_operators: transitive, causal teaching_chains: [systems_software_chains_v1] eval_lanes: symbolic_logic, inference_closure, fabrication_control 9/9 predicates pass ADR-0102 hebrew_greek_textual_reasoning (FIRST MULTI-PACK ratification): domain_id: hebrew_greek_textual_reasoning claimed_operators: causal, contradiction teaching_chains: [hebrew_greek_textual_reasoning_chains_v1] eval_lanes: inference_closure, fabrication_control (universal lanes only — language-specific fluency lanes lack holdout splits; a separate ADR adds those when holdouts ship) packs: grc_logos_micro_v1, grc_logos_cognition_v1, he_logos_micro_v1, he_core_cognition_v1 all four pack contracts identical (uniformity invariant pinned); all four 9/9 predicates pass pre-existing gap: hebrew/greek manifests lacked a provenance field entirely; ratification fills that uniformly across the four packs 44 new ratification tests in test_adr_0100_0102_sibling_ratifications.py: - 6 parametrized 9-predicate validation tests (one per pack) - 21 per-domain ledger status assertions (status, reasoning_capable, expert_demo gated, no_open_gaps, provenance points at correct ADR, operator_chain_coverage, intent_shapes minimum) — 7 cases × 3 domains - 15 per-domain contract field shape assertions (teaching_chains, eval_lanes, splits coverage, axioms/rules null, primary reviewer) — 5 cases × 3 domains - 2 ADR-0102 multi-pack uniformity invariants (all four packs carry the contract; contracts identical across packs) Capability ledger after ratification: systems_software : reasoning-capable mathematics_logic : reasoning-capable physics : reasoning-capable hebrew_greek_textual_reasoning : reasoning-capable philosophy_theology : reasoning-capable (no contract; pre-existing) Lane SHA pin update: - public_demo pin refreshed (21751aaf.. → 71090323..) — the ratification adds new manifest fields (provenance, domain_contract_*) that surface in pack-related demo paths; intentional ADR-tracked change per the verifier doctrine Smoke 67/67, packs 6/6, sibling ratifications 44/44, cognition eval byte-identical 100/100/100/100; all 6 lanes match pinned SHAs: reviewer_registry 681a2aab.. miner_loop_closure 9f071733.. domain_contract_validation f9c06cde.. fabrication_control_summary 01e1b6b7.. demo_composition 27d83824.. public_demo 71090323.. --- ...-physics-reasoning-capable-ratification.md | 96 ++++++++ ...software-reasoning-capable-ratification.md | 101 ++++++++ ...ew-greek-reasoning-capable-ratification.md | 136 +++++++++++ evals/public_demo/results/v1_dev.json | 2 +- .../data/en_physics_v1/manifest.json | 26 +- .../data/en_systems_software_v1/manifest.json | 26 +- .../data/grc_logos_cognition_v1/manifest.json | 22 +- .../data/grc_logos_micro_v1/manifest.json | 22 +- .../data/he_core_cognition_v1/manifest.json | 22 +- .../data/he_logos_micro_v1/manifest.json | 22 +- scripts/verify_lane_shas.py | 2 +- ...est_adr_0100_0102_sibling_ratifications.py | 223 ++++++++++++++++++ 12 files changed, 692 insertions(+), 8 deletions(-) create mode 100644 docs/decisions/ADR-0100-physics-reasoning-capable-ratification.md create mode 100644 docs/decisions/ADR-0101-systems-software-reasoning-capable-ratification.md create mode 100644 docs/decisions/ADR-0102-hebrew-greek-reasoning-capable-ratification.md create mode 100644 tests/test_adr_0100_0102_sibling_ratifications.py diff --git a/docs/decisions/ADR-0100-physics-reasoning-capable-ratification.md b/docs/decisions/ADR-0100-physics-reasoning-capable-ratification.md new file mode 100644 index 00000000..ff74bbe9 --- /dev/null +++ b/docs/decisions/ADR-0100-physics-reasoning-capable-ratification.md @@ -0,0 +1,96 @@ +# ADR-0100 — Physics Reasoning-Capable Ratification + +**Status:** Proposed +**Date:** 2026-05-21 +**Author:** CORE agents + reviewers +**Depends on:** ADR-0091, ADR-0092, ADR-0093, ADR-0096, ADR-0097 + +--- + +## Context + +The physics substrate is structurally complete: + +- `language_packs/data/en_physics_v1/` ships with manifest, lexicon, glosses. +- `teaching/domain_chains/physics_chains_v1.jsonl` exists. +- `evals/foundational_physics_ood/` exists with dev/public/holdouts. +- `docs/gaps.md` marks every physics gap closed: + `gap:physics_pack_absent`, `gap:physics_causal_chains_below_threshold`, + `gap:physics_modal_chains_below_threshold`, + `gap:physics_intent_shapes_below_threshold` — all `[x]`. +- Chain coverage: causal=8, modal=8 (≥8 per claimed operator family ✓); + five intent shapes populated (cause, comparison, correction, procedure, + verification — ≥3 ✓). + +What's missing is the ADR-0091 formal ratification step, matching the +template established by ADR-0097 for `mathematics_logic`. + +--- + +## Decision + +Ratify `en_physics_v1` as `reasoning-capable` under ADR-0091 by emitting +the contract fields into its manifest and passing +`core capability domain-contract validate en_physics_v1`. + +### Manifest additions + +```jsonc +{ + "domain_contract_version": 1, + "domain_id": "physics", + "axioms": null, + "rules": null, + "teaching_chains": ["physics_chains_v1"], + "eval_lanes": [ + {"lane": "foundational_physics_ood", "version": "v1", + "splits": ["dev", "public", "holdout"]}, + {"lane": "inference_closure", "version": "v1", + "splits": ["dev", "public", "holdout"]}, + {"lane": "fabrication_control", "version": "v1", + "splits": ["dev", "public", "holdout"]} + ], + "reviewers": ["shay-j"], + "known_gaps": [], + "provenance": "adr-0100:reviewed:2026-05-21" +} +``` + +Claimed operator families (`DOMAIN_OPERATOR_CLAIMS`): `causal`, `modal`. +`axioms` and `rules` stay `null` at v1 — physics demonstrates reasoning +through reviewed causal/modal chain composition, not declarative axioms. + +### What this ADR does not do + +- Does not introduce new lemmas, chains, or evals. +- Does not promote to `expert-demo`. +- Does not modify runtime mount behavior. + +--- + +## Invariant + +`physics_reasoning_capable_ledger_row` — `core capability ledger` emits +a row for `domain_id: physics` with `status: reasoning-capable`, +provenance pointing at this ADR, and `expert_demo: False` until a +future ADR attaches the required audit-tour-equivalent reports. + +--- + +## Lane + +No new lane. The four existing lanes carry the evidence: + +- `foundational_physics_ood/` (positive coverage) +- `inference_closure/` (composition) +- `fabrication_control/` (negative control, ADR-0096) +- `evals/domain_contract_validation/` (ADR-0093 confirms predicates fire) + +--- + +## PR Checklist + +- Capability added: second ratified `reasoning-capable` domain. +- Invariant proved: `physics_reasoning_capable_ledger_row`. +- Hidden normalization / stochastic fallback / approximate recall / unreviewed mutation: none. +- Trust boundary: manifest edit through reviewed flow; checksums unchanged. diff --git a/docs/decisions/ADR-0101-systems-software-reasoning-capable-ratification.md b/docs/decisions/ADR-0101-systems-software-reasoning-capable-ratification.md new file mode 100644 index 00000000..6611f43d --- /dev/null +++ b/docs/decisions/ADR-0101-systems-software-reasoning-capable-ratification.md @@ -0,0 +1,101 @@ +# ADR-0101 — Systems-Software Reasoning-Capable Ratification + +**Status:** Proposed +**Date:** 2026-05-21 +**Author:** CORE agents + reviewers +**Depends on:** ADR-0091, ADR-0092, ADR-0093, ADR-0096, ADR-0097 + +--- + +## Context + +The systems_software substrate is structurally complete: + +- `language_packs/data/en_systems_software_v1/` ships with manifest, + lexicon, glosses. +- `teaching/domain_chains/systems_software_chains_v1.jsonl` exists. +- `evals/symbolic_logic/` exists with dev/public/holdouts (the + closest in-tree lane for systems/software reasoning at v1). +- `docs/gaps.md` marks every systems_software gap closed: + `gap:systems_software_pack_absent`, + `gap:systems_software_transitive_chains_below_threshold`, + `gap:systems_software_causal_chains_below_threshold`, + `gap:systems_software_intent_shapes_below_threshold` — all `[x]`. +- Chain coverage: causal=8, transitive=8 (≥8 per claimed operator + family ✓); five intent shapes populated (≥3 ✓). + +What's missing is the ADR-0091 formal ratification step, matching the +template established by ADR-0097 for `mathematics_logic`. + +--- + +## Decision + +Ratify `en_systems_software_v1` as `reasoning-capable` under ADR-0091 +by emitting the contract fields into its manifest and passing +`core capability domain-contract validate en_systems_software_v1`. + +### Manifest additions + +```jsonc +{ + "domain_contract_version": 1, + "domain_id": "systems_software", + "axioms": null, + "rules": null, + "teaching_chains": ["systems_software_chains_v1"], + "eval_lanes": [ + {"lane": "symbolic_logic", "version": "v1", + "splits": ["dev", "public", "holdout"]}, + {"lane": "inference_closure", "version": "v1", + "splits": ["dev", "public", "holdout"]}, + {"lane": "fabrication_control", "version": "v1", + "splits": ["dev", "public", "holdout"]} + ], + "reviewers": ["shay-j"], + "known_gaps": [], + "provenance": "adr-0101:reviewed:2026-05-21" +} +``` + +Claimed operator families (`DOMAIN_OPERATOR_CLAIMS`): `transitive`, +`causal`. `axioms` and `rules` stay `null` at v1 — systems-software +reasoning is demonstrated through reviewed causal/transitive chain +composition over invariants, boundaries, and dependencies. + +### Eval lane choice — `symbolic_logic` + +Systems-software lacks a dedicated v1 evaluation lane. `symbolic_logic` +is the closest in-tree fit: it pins reasoning over typed relations +(implication, contradiction, dependency) that the systems_software +chain corpus exercises. A future ADR may introduce a +`systems_software_design_ood` lane and supersede this declaration. + +--- + +## Invariant + +`systems_software_reasoning_capable_ledger_row` — `core capability +ledger` emits a row for `domain_id: systems_software` with +`status: reasoning-capable`, provenance pointing at this ADR, and +`expert_demo: False` until a future ADR attaches the required reports. + +--- + +## Lane + +No new lane. Existing lanes carry the evidence: + +- `symbolic_logic/` (reasoning over typed relations) +- `inference_closure/` (composition) +- `fabrication_control/` (negative control, ADR-0096) +- `evals/domain_contract_validation/` (ADR-0093 confirms predicates fire) + +--- + +## PR Checklist + +- Capability added: third ratified `reasoning-capable` domain. +- Invariant proved: `systems_software_reasoning_capable_ledger_row`. +- Hidden normalization / stochastic fallback / approximate recall / unreviewed mutation: none. +- Trust boundary: manifest edit through reviewed flow; checksums unchanged. diff --git a/docs/decisions/ADR-0102-hebrew-greek-reasoning-capable-ratification.md b/docs/decisions/ADR-0102-hebrew-greek-reasoning-capable-ratification.md new file mode 100644 index 00000000..c682d69c --- /dev/null +++ b/docs/decisions/ADR-0102-hebrew-greek-reasoning-capable-ratification.md @@ -0,0 +1,136 @@ +# ADR-0102 — Hebrew-Greek Textual-Reasoning Reasoning-Capable Ratification + +**Status:** Proposed +**Date:** 2026-05-21 +**Author:** CORE agents + reviewers +**Depends on:** ADR-0091, ADR-0092, ADR-0093, ADR-0096, ADR-0097 + +--- + +## Context + +The hebrew_greek_textual_reasoning substrate is structurally complete +across four packs: + +- `grc_logos_micro_v1`, `grc_logos_cognition_v1`, + `he_logos_micro_v1`, `he_core_cognition_v1`. +- `teaching/domain_chains/hebrew_greek_textual_reasoning_chains_v1.jsonl`. +- `docs/gaps.md` marks every relevant gap closed: + `gap:grc_he_glosses_absent`, `gap:grc_he_chains_absent`, + `gap:grc_logos_micro_v1_gloss_coverage_below_threshold`, + `gap:grc_logos_cognition_v1_gloss_coverage_below_threshold`, + `gap:he_logos_micro_v1_gloss_coverage_below_threshold`, + `gap:he_core_cognition_v1_gloss_coverage_below_threshold`, + `gap:hebrew_greek_textual_reasoning_causal_chains_below_threshold`, + `gap:hebrew_greek_textual_reasoning_contradiction_chains_below_threshold`, + `gap:hebrew_greek_textual_reasoning_intent_shapes_below_threshold` + — all `[x]`. +- Chain coverage: causal=8, contradiction=8 (≥8 per claimed operator + family ✓); five intent shapes populated (≥3 ✓). + +Unlike `mathematics_logic` / `physics` / `systems_software`, this is a +**multi-pack domain**: `DOMAIN_PACKS["hebrew_greek_textual_reasoning"]` +enumerates four packs. ADR-0091's predicates evaluate per pack; the +ledger row aggregates. Each of the four packs must carry the same +domain contract so the per-pack `core capability domain-contract +validate` passes uniformly. + +--- + +## Decision + +Ratify all four hebrew/greek packs as `reasoning-capable` under +ADR-0091 by emitting the contract fields into each manifest. Each pack +declares the same `domain_id`, `teaching_chains`, `eval_lanes`, and +reviewers; the only field that varies per pack is `provenance` +(remains pack-scoped audit trail). + +### Manifest additions (all four packs) + +```jsonc +{ + "domain_contract_version": 1, + "domain_id": "hebrew_greek_textual_reasoning", + "axioms": null, + "rules": null, + "teaching_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "eval_lanes": [ + {"lane": "inference_closure", "version": "v1", + "splits": ["dev", "public", "holdout"]}, + {"lane": "fabrication_control", "version": "v1", + "splits": ["dev", "public", "holdout"]} + ], + "reviewers": ["shay-j"], + "known_gaps": [], + "provenance": "adr-0102:reviewed:2026-05-21" +} +``` + +Claimed operator families (`DOMAIN_OPERATOR_CLAIMS`): `causal`, +`contradiction`. `axioms` and `rules` stay `null` at v1. + +### Eval lane scope + +Only universal lanes (`inference_closure`, `fabrication_control`) are +declared. The language-specific fluency lanes +(`evals/hebrew_fluency/`, `evals/koine_greek_fluency/`) currently ship +dev/public only — without a sealed holdout split they fail ADR-0091 +predicate P7. Adding holdouts to those lanes is a separate ADR; until +that lands, the universal lanes alone are sufficient for +`reasoning-capable` status. + +### Pre-existing manifest gap + +The four hebrew/greek manifests currently lack a `provenance` field +entirely (unlike the three English domain packs). This ratification +fills that gap as a side-effect; future audits of pack provenance +trails across all packs become uniform. + +--- + +## Invariant + +`hebrew_greek_reasoning_capable_ledger_row` — `core capability ledger` +emits a row for `domain_id: hebrew_greek_textual_reasoning` with +`status: reasoning-capable`, provenance pointing at this ADR (uniform +across all four packs), and `expert_demo: False` until a future ADR +attaches the required reports. + +`hebrew_greek_pack_contracts_uniform` — all four packs declare +identical contract fields (except provenance audit trail), so +multi-pack ratification cannot drift between packs without an +explicit ADR. + +--- + +## Lane + +No new lane. Existing lanes carry the evidence: + +- `inference_closure/` (composition) +- `fabrication_control/` (negative control, ADR-0096) +- `evals/domain_contract_validation/` (ADR-0093 confirms predicates + fire on each of the four packs) + +--- + +## Consequences + +- First multi-pack domain ratification. Demonstrates the contract + works the same way for single-pack and multi-pack domains. +- All four hebrew/greek manifests gain a provenance field. +- Future language-specific eval lanes (Hebrew, Koine Greek) can be + added to the contract once they ship holdout splits. + +--- + +## PR Checklist + +- Capability added: fourth ratified `reasoning-capable` domain, + multi-pack. +- Invariants proved: `hebrew_greek_reasoning_capable_ledger_row`, + `hebrew_greek_pack_contracts_uniform`. +- Hidden normalization / stochastic fallback / approximate recall / + unreviewed mutation: none. +- Trust boundary: four manifest edits through reviewed flow; + checksums unchanged. diff --git a/evals/public_demo/results/v1_dev.json b/evals/public_demo/results/v1_dev.json index 9a75e69d..7b544c4d 100644 --- a/evals/public_demo/results/v1_dev.json +++ b/evals/public_demo/results/v1_dev.json @@ -13,7 +13,7 @@ { "case_id": "determinism_run_to_run_byte_equality", "details": { - "sha256": "a8a24def3636ecf34e3ade88fde932ad7dce9469862a9f927303dd1677fd1115" + "sha256": "f35ba6c28f008f7f80eef51fdecd36c951b7f38eea1d64dc163c5f45e5c86050" }, "divergence": null, "passed": true diff --git a/language_packs/data/en_physics_v1/manifest.json b/language_packs/data/en_physics_v1/manifest.json index 6d82d316..6db2912a 100644 --- a/language_packs/data/en_physics_v1/manifest.json +++ b/language_packs/data/en_physics_v1/manifest.json @@ -12,5 +12,29 @@ "oov_policy": "tagged_fallback", "glosses_checksum": "2d813897f06e0ac777044094a788710454e0e66d4a3725c0ed2436edbfc67830", "definitional_layer": false, - "provenance": "adr-0090:domain_seed:2026-05-21" + "provenance": "adr-0100:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "physics", + "axioms": null, + "rules": null, + "teaching_chains": ["physics_chains_v1"], + "eval_lanes": [ + { + "lane": "foundational_physics_ood", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/language_packs/data/en_systems_software_v1/manifest.json b/language_packs/data/en_systems_software_v1/manifest.json index 449e1a50..6614f074 100644 --- a/language_packs/data/en_systems_software_v1/manifest.json +++ b/language_packs/data/en_systems_software_v1/manifest.json @@ -12,5 +12,29 @@ "oov_policy": "tagged_fallback", "glosses_checksum": "189a8686c02ac7a0801ef4d32fd52e551b5b88a1937d1e4efa7d449d16e74833", "definitional_layer": false, - "provenance": "adr-0090:domain_seed:2026-05-21" + "provenance": "adr-0101:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "systems_software", + "axioms": null, + "rules": null, + "teaching_chains": ["systems_software_chains_v1"], + "eval_lanes": [ + { + "lane": "symbolic_logic", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/language_packs/data/grc_logos_cognition_v1/manifest.json b/language_packs/data/grc_logos_cognition_v1/manifest.json index d633da65..b9d697a7 100644 --- a/language_packs/data/grc_logos_cognition_v1/manifest.json +++ b/language_packs/data/grc_logos_cognition_v1/manifest.json @@ -10,5 +10,25 @@ "version": "1.0.0", "gate_engaged": true, "oov_policy": "fail_closed", - "glosses_checksum": "6b1e83010b2065ceedb0988e2020ee13999a1883e6399f1ca8908235683d7e42" + "glosses_checksum": "6b1e83010b2065ceedb0988e2020ee13999a1883e6399f1ca8908235683d7e42", + "provenance": "adr-0102:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "hebrew_greek_textual_reasoning", + "axioms": null, + "rules": null, + "teaching_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "eval_lanes": [ + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/language_packs/data/grc_logos_micro_v1/manifest.json b/language_packs/data/grc_logos_micro_v1/manifest.json index 0cf4bbff..bd58aad4 100644 --- a/language_packs/data/grc_logos_micro_v1/manifest.json +++ b/language_packs/data/grc_logos_micro_v1/manifest.json @@ -10,5 +10,25 @@ "version": "1.0.0", "gate_engaged": true, "oov_policy": "fail_closed", - "glosses_checksum": "cfc5c3b3dafcd8290cff484039af34c8a17a826e40a3c8fa1ffe97e32c36934c" + "glosses_checksum": "cfc5c3b3dafcd8290cff484039af34c8a17a826e40a3c8fa1ffe97e32c36934c", + "provenance": "adr-0102:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "hebrew_greek_textual_reasoning", + "axioms": null, + "rules": null, + "teaching_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "eval_lanes": [ + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/language_packs/data/he_core_cognition_v1/manifest.json b/language_packs/data/he_core_cognition_v1/manifest.json index a19186d7..40d2f055 100644 --- a/language_packs/data/he_core_cognition_v1/manifest.json +++ b/language_packs/data/he_core_cognition_v1/manifest.json @@ -10,5 +10,25 @@ "version": "1.0.0", "gate_engaged": true, "oov_policy": "fail_closed", - "glosses_checksum": "286acaf29fd2b3cc01ff5537f2b1552788ba2d495f977517ec5e4acd2a564ac5" + "glosses_checksum": "286acaf29fd2b3cc01ff5537f2b1552788ba2d495f977517ec5e4acd2a564ac5", + "provenance": "adr-0102:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "hebrew_greek_textual_reasoning", + "axioms": null, + "rules": null, + "teaching_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "eval_lanes": [ + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/language_packs/data/he_logos_micro_v1/manifest.json b/language_packs/data/he_logos_micro_v1/manifest.json index ed2a0abd..2e4c9439 100644 --- a/language_packs/data/he_logos_micro_v1/manifest.json +++ b/language_packs/data/he_logos_micro_v1/manifest.json @@ -10,5 +10,25 @@ "version": "1.0.0", "gate_engaged": true, "oov_policy": "fail_closed", - "glosses_checksum": "2d00c18735fa81b6d1f3ece754c132924bf8a2b83241d1561370bef52e8816e1" + "glosses_checksum": "2d00c18735fa81b6d1f3ece754c132924bf8a2b83241d1561370bef52e8816e1", + "provenance": "adr-0102:reviewed:2026-05-21", + "domain_contract_version": 1, + "domain_id": "hebrew_greek_textual_reasoning", + "axioms": null, + "rules": null, + "teaching_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "eval_lanes": [ + { + "lane": "inference_closure", + "version": "v1", + "splits": ["dev", "public", "holdout"] + }, + { + "lane": "fabrication_control", + "version": "v1", + "splits": ["dev", "public", "holdout"] + } + ], + "reviewers": ["shay-j"], + "known_gaps": [] } diff --git a/scripts/verify_lane_shas.py b/scripts/verify_lane_shas.py index cf7a7841..022339cd 100644 --- a/scripts/verify_lane_shas.py +++ b/scripts/verify_lane_shas.py @@ -49,7 +49,7 @@ PINNED_SHAS: dict[str, str] = { "domain_contract_validation": "f9c06cdeea8fb36a0d3c320007618c3afc92d67702ef31bd36ebd9ae9ced473f", "fabrication_control_summary": "01e1b6b711141f2b4a14551d7df3ea482d8d6dd7b364a25c509f4f8d08cda8a8", "demo_composition": "27d838241bf3ed9e15d0e918ec6d89a823494d7e17c2dab9777825af7188f20f", - "public_demo": "21751aaf2b60897ec7ca9b6498219e3c5eb28aec6b17eb77369ed139db093b29", + "public_demo": "71090323943b3b09bf563d3d5217426922ab027f9a20bee3af4173435dda4c8c", } diff --git a/tests/test_adr_0100_0102_sibling_ratifications.py b/tests/test_adr_0100_0102_sibling_ratifications.py new file mode 100644 index 00000000..be84fd36 --- /dev/null +++ b/tests/test_adr_0100_0102_sibling_ratifications.py @@ -0,0 +1,223 @@ +"""ADR-0100 / ADR-0101 / ADR-0102 — sibling domain ratification tests. + +Pins the load-bearing invariants for the three sibling domains +ratified after ADR-0097's mathematics_logic template: + +- ADR-0100 ``physics`` +- ADR-0101 ``systems_software`` +- ADR-0102 ``hebrew_greek_textual_reasoning`` (multi-pack) + +Each domain's capability ledger row must report ``reasoning-capable``, +provenance must point at the right ADR, and ``expert-demo`` stays +gated for a future ADR. +""" + +from __future__ import annotations + +import pytest + +from core.capability import evaluate_domain_contract, ledger_report + + +_DOMAINS: dict[str, dict] = { + "physics": { + "adr": "adr-0100", + "packs": ("en_physics_v1",), + "claimed_operators": ("causal", "modal"), + "min_intent_shapes": 3, + "expected_chains": ["physics_chains_v1"], + "expected_lanes": { + "foundational_physics_ood", + "inference_closure", + "fabrication_control", + }, + }, + "systems_software": { + "adr": "adr-0101", + "packs": ("en_systems_software_v1",), + "claimed_operators": ("transitive", "causal"), + "min_intent_shapes": 3, + "expected_chains": ["systems_software_chains_v1"], + "expected_lanes": { + "symbolic_logic", + "inference_closure", + "fabrication_control", + }, + }, + "hebrew_greek_textual_reasoning": { + "adr": "adr-0102", + "packs": ( + "grc_logos_micro_v1", + "grc_logos_cognition_v1", + "he_logos_micro_v1", + "he_core_cognition_v1", + ), + "claimed_operators": ("causal", "contradiction"), + "min_intent_shapes": 3, + "expected_chains": ["hebrew_greek_textual_reasoning_chains_v1"], + "expected_lanes": {"inference_closure", "fabrication_control"}, + }, +} + + +def _ledger_row(domain_id: str) -> dict: + report = ledger_report() + rows = {row["domain"]: row for row in report["domains"]} + assert domain_id in rows, f"missing ledger row for {domain_id!r}" + return rows[domain_id] + + +# --------------------------------------------------------------------------- +# Per-pack 9-predicate validation +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "pack_id,domain_id", + [ + (pack, domain) + for domain, spec in _DOMAINS.items() + for pack in spec["packs"] + ], +) +def test_pack_passes_all_nine_predicates( + pack_id: str, domain_id: str +) -> None: + report = evaluate_domain_contract(pack_id) + assert report.contract_present is True, ( + f"{pack_id} missing domain contract" + ) + assert report.contract_valid is True, ( + f"{pack_id} contract parse errors: {report.contract_errors}" + ) + failing = [p.predicate_id for p in report.predicates if not p.passed] + assert failing == [], ( + f"{pack_id} failing predicates: {failing}" + ) + assert report.domain_id == domain_id + + +# --------------------------------------------------------------------------- +# Per-domain ledger status (invariants per ADR) +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize("domain_id", list(_DOMAINS.keys())) +class TestLedgerStatus: + def test_status_is_reasoning_capable(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + assert row["status"] == "reasoning-capable" + + def test_reasoning_capable_predicate_true(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + assert row["predicates"]["reasoning_capable"] is True + + def test_expert_demo_predicate_false(self, domain_id: str) -> None: + """Each ratification ADR explicitly defers expert-demo.""" + row = _ledger_row(domain_id) + assert row["predicates"]["expert_demo"] is False + + def test_no_open_gaps(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + assert row["open_gaps"] == [] + + def test_provenance_points_at_correct_adr(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + contracts = row["domain_contracts"] + assert contracts, f"{domain_id} ledger row has no domain_contracts" + expected_prefix = _DOMAINS[domain_id]["adr"] + ":reviewed:" + provenances = [c["contract"]["provenance"] for c in contracts] + assert all( + p.startswith(expected_prefix) for p in provenances + ), f"{domain_id}: provenance mismatch, got {provenances}" + + def test_operator_chain_coverage(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + coverage = row["operator_chain_coverage"] + for op in _DOMAINS[domain_id]["claimed_operators"]: + assert coverage[op]["ready"] is True, ( + f"{domain_id} op {op!r} not ready: {coverage[op]}" + ) + assert coverage[op]["chains_present"] >= 8 + + def test_intent_shapes_meet_minimum(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + assert row["intent_shapes_present"] >= _DOMAINS[domain_id]["min_intent_shapes"] + + +# --------------------------------------------------------------------------- +# Per-domain contract field shape +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize("domain_id", list(_DOMAINS.keys())) +class TestContractFields: + def test_teaching_chains_match(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + for contract_entry in row["domain_contracts"]: + chains = contract_entry["contract"]["teaching_chains"] + assert chains == _DOMAINS[domain_id]["expected_chains"], ( + f"{domain_id} ({contract_entry['pack_id']}): unexpected " + f"teaching_chains {chains}" + ) + + def test_expected_eval_lanes(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + for contract_entry in row["domain_contracts"]: + lanes = {lane["lane"] for lane in contract_entry["contract"]["eval_lanes"]} + assert lanes == _DOMAINS[domain_id]["expected_lanes"], ( + f"{domain_id} ({contract_entry['pack_id']}): expected " + f"lanes {_DOMAINS[domain_id]['expected_lanes']}, got {lanes}" + ) + + def test_all_lanes_cover_three_splits(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + for contract_entry in row["domain_contracts"]: + for lane in contract_entry["contract"]["eval_lanes"]: + assert set(lane["splits"]) == {"dev", "public", "holdout"}, ( + f"{domain_id}: lane {lane['lane']!r} declares " + f"{lane['splits']}, expected dev/public/holdout" + ) + + def test_axioms_and_rules_null_at_v1(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + for contract_entry in row["domain_contracts"]: + contract = contract_entry["contract"] + assert contract["axioms"] is None + assert contract["rules"] is None + + def test_primary_reviewer_resolves(self, domain_id: str) -> None: + row = _ledger_row(domain_id) + for contract_entry in row["domain_contracts"]: + assert contract_entry["contract"]["reviewers"] == ["shay-j"] + + +# --------------------------------------------------------------------------- +# ADR-0102 specific — multi-pack uniformity invariant +# --------------------------------------------------------------------------- + + +class TestHebrewGreekMultiPackUniformity: + """ADR-0102 invariant: all four packs declare uniform contract.""" + + def test_all_four_packs_carry_contract(self) -> None: + row = _ledger_row("hebrew_greek_textual_reasoning") + contract_pack_ids = {c["pack_id"] for c in row["domain_contracts"]} + assert contract_pack_ids == set( + _DOMAINS["hebrew_greek_textual_reasoning"]["packs"] + ) + + def test_contracts_identical_modulo_pack_id(self) -> None: + row = _ledger_row("hebrew_greek_textual_reasoning") + # Strip pack_id so we can compare the remaining contract fields + # for cross-pack uniformity. + canonical = None + for entry in row["domain_contracts"]: + contract = dict(entry["contract"]) + if canonical is None: + canonical = contract + continue + assert contract == canonical, ( + f"hebrew/greek pack {entry['pack_id']} drifted from canonical: " + f"{contract!r} vs {canonical!r}" + )