refactor(cli): decompose cli into dedicated modules

core/cli_capability.py

@@ -0,0 +1,379 @@
+"""Extracted commands."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+
+
+def cmd_capability_chains(args: argparse.Namespace) -> int:
+    from core.capability import chain_report
+
+    report = chain_report()
+    print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+    return 0
+
+
+def cmd_capability_flags(args: argparse.Namespace) -> int:
+    from core.capability import flag_report
+
+    report = flag_report()
+    print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+    return 0
+
+
+def cmd_capability_ledger(args: argparse.Namespace) -> int:
+    from core.capability import ledger_report
+
+    report = ledger_report()
+    print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+    return 0
+
+
+def cmd_capability_artifact(args: argparse.Namespace) -> int:
+    from core.capability import CapabilityArtifactQuery, artifact_report
+
+    report = artifact_report(
+        CapabilityArtifactQuery(lane=args.lane, split=args.split, version=args.version)
+    )
+    print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+    return 0
+
+
+def cmd_capability_domain_contract(args: argparse.Namespace) -> int:
+    """ADR-0093 domain-contract dry-run validator.
+
+    Default behavior runs the nine ADR-0091 predicates plus eval-lane
+    artifact resolution and exits non-zero on any predicate failure.
+    The legacy structural-only output remains available via
+    ``--structural-only`` for callers that depend on the prior shape.
+    """
+    from language_packs.domain_contract import validate_domain_contract_pack
+
+    if getattr(args, "structural_only", False):
+        report = validate_domain_contract_pack(args.pack_id).as_dict()
+        print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+        return 0 if report["valid"] else 1
+
+    from core.capability.domain_contract_predicates import evaluate_domain_contract
+
+    predicate_report = evaluate_domain_contract(args.pack_id).as_dict()
+    print(
+        json.dumps(predicate_report, indent=2, sort_keys=True)
+        if args.json
+        else predicate_report
+    )
+    return 0 if predicate_report["all_passed"] else 1
+
+
+def cmd_capability_evidence_plan(args: argparse.Namespace) -> int:
+    from core.capability import evidence_plan_report
+
+    report = evidence_plan_report()
+    print(json.dumps(report, indent=2, sort_keys=True) if args.json else report)
+    return 0
+
+
+def cmd_capability_perturbation(args: argparse.Namespace) -> int:
+    """ADR-0114a Obligation #5 — reasoning-isolation perturbation suite for B3.
+
+    Generates and scores invariance-preserving and invariance-breaking
+    perturbations over B3 (bounded grammar) expected-correct cases.
+    Writes the report to ``evals/obligation_5_perturbation/<lane_id>.json``.
+    Exit 0 iff both preserving_rate == 1.0 AND breaking_rate == 1.0.
+    """
+    from pathlib import Path as _Path
+    from core.capability.perturbation_b3 import (
+        validate_perturbation_suite,
+        emit_perturbation_report,
+    )
+
+    lane_id = args.lane_id
+    report = validate_perturbation_suite(lane_id=lane_id)
+
+    out_dir = _Path(__file__).resolve().parent.parent / "evals" / "obligation_5_perturbation"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / f"{lane_id}.json"
+    emit_perturbation_report(report, out_path)
+
+    if args.json:
+        print(json.dumps(report.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"lane_id:             {report.lane_id}")
+        print(f"cases_total:         {report.cases_total}")
+        print(f"cases_expected_correct: {report.cases_expected_correct}")
+        print(
+            f"preserving: {report.preserving_correct}/{report.preserving_attempted} "
+            f"= {report.preserving_rate:.4f}"
+        )
+        print(
+            f"breaking:   {report.breaking_correct}/{report.breaking_attempted} "
+            f"= {report.breaking_rate:.4f}"
+        )
+        print(f"obligation_5_passed: {report.obligation_5_passed}")
+        print(f"report_digest:       {report.report_digest}")
+        print(f"artifact:            {out_path}")
+        if not report.obligation_5_passed:
+            print(f"refusal_reason: {report.refusal_reason}")
+    return 0 if report.obligation_5_passed else 1
+
+
+def cmd_capability_math_expert_gate(args: argparse.Namespace) -> int:
+    """ADR-0131.4 — evaluate the composite math-expert promotion gate
+    (Benchmark 1 + 2 + 3, ADR-0131's revision of ADR-0120's single-lane
+    coverage check). Emits ``expert_claims_math_v1.json`` to ``--out``
+    (default: ``evals/math_expert_claims/v1/expert_claims_math_v1.json``).
+    Exit 0 iff every benchmark passes."""
+    from core.capability.composite_math_gate import (
+        emit_expert_claims_artifact,
+        evaluate_composite_math_gate,
+    )
+
+    verdict = evaluate_composite_math_gate()
+    out_path = Path(args.out) if args.out else (
+        Path(__file__).resolve().parent.parent
+        / "evals" / "math_expert_claims" / "v1" / "expert_claims_math_v1.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_expert_claims_artifact(verdict, out_path)
+
+    if args.json:
+        print(json.dumps(verdict.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"composite_gate_passed: {verdict.composite_gate_passed}")
+        print(f"claim_digest:          {verdict.claim_digest}")
+        print(f"artifact:              {out_path}")
+        for b in verdict.benchmarks:
+            print(
+                f"  {b.benchmark_id:>20}  passed={b.passed}  "
+                f"correct={b.correct}/{b.cases_total}  wrong={b.wrong}  "
+                f"rate={b.correct_rate:.4f}"
+            )
+        hd = verdict.honest_disclosure
+        print(
+            f"GSM8K honest disclosure: admission={hd.get('admitted_solved', 0)}/"
+            f"{hd.get('cases_total', 0)}, wrong={hd.get('admitted_wrong', 0)}, "
+            f"substrate={hd.get('substrate', '?')}"
+        )
+        if not verdict.composite_gate_passed:
+            print(f"refusal_reason: {verdict.refusal_reason}")
+    return 0 if verdict.composite_gate_passed else 1
+
+
+def cmd_capability_pack_provenance(args: argparse.Namespace) -> int:
+    """ADR-0114a Obligation #10 — external audit that every solver
+    step's ``pack_lemma_id`` resolves to a real entry in the domain's
+    operator pack lexicon. Defaults to B3 (bounded grammar) under
+    ``en_arithmetic_v1``. Emits report to ``--out`` (default:
+    ``evals/obligation_10_pack_provenance/<lane_id>.json``).
+    Exit 0 iff obligation passes."""
+    from core.capability.pack_provenance import (
+        emit_provenance_report,
+        validate_lane,
+    )
+
+    report = validate_lane()
+    out_path = Path(args.out) if args.out else (
+        Path(__file__).resolve().parent.parent
+        / "evals" / "obligation_10_pack_provenance"
+        / f"{report.lane_id}.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_provenance_report(report, out_path)
+
+    if args.json:
+        print(json.dumps(report.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"lane:                       {report.lane_id}")
+        print(f"pack_id:                    {report.pack_id}")
+        print(f"cases_total:                {report.cases_total}")
+        print(f"cases_validated:            {report.cases_validated}")
+        print(f"cases_skipped_unsolved:     {report.cases_skipped_unsolved}")
+        print(f"cases_violated:             {report.cases_violated}")
+        print(f"obligation_10_passed:       {report.obligation_10_passed}")
+        print("distinct_lemma_ids_observed:")
+        for lid in report.distinct_lemma_ids_observed:
+            print(f"  - {lid}")
+        print(f"artifact:                   {out_path}")
+        if report.refusal_reason:
+            print(f"refusal_reason:             {report.refusal_reason}")
+    return 0 if report.obligation_10_passed else 1
+
+
+def cmd_capability_adversarial(args: argparse.Namespace) -> int:
+    """ADR-0114a Obligation #8 — adversarial generation auditor. Runs
+    a committed adversarial case set through the candidate-graph
+    pipeline; gate is ``wrong == 0`` across all families AND
+    ``cases_total >= 30`` AND ``families_total >= 8``. Default cases
+    set ``evals/obligation_8_adversarial/v1/cases.jsonl``; writes
+    report to ``--out`` (default
+    ``evals/obligation_8_adversarial/<lane_id>.json``). Exit 0 iff
+    obligation passes."""
+    from core.capability.adversarial import (
+        emit_adversarial_report,
+        evaluate_adversarial,
+    )
+
+    report = evaluate_adversarial()
+    out_path = Path(args.out) if args.out else (
+        Path(__file__).resolve().parent.parent
+        / "evals" / "obligation_8_adversarial"
+        / f"{report.lane_id}.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_adversarial_report(report, out_path)
+
+    if args.json:
+        print(json.dumps(report.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"lane:                {report.lane_id}")
+        print(f"cases_total:         {report.cases_total}  (min {report.cases_total >= 30 and 'OK' or 'FAIL'})")
+        print(f"families_total:      {report.families_total}  ({'OK' if report.families_total >= 8 else 'FAIL'})")
+        print(f"cases_refused:       {report.cases_refused}")
+        print(f"cases_solved:        {report.cases_solved}")
+        print(f"cases_wrong:         {report.cases_wrong} (gate: must be 0)")
+        print(f"obligation_8_passed: {report.obligation_8_passed}")
+        print()
+        print(f"  {'family':<22} {'total':<7} {'refused':<8} {'solved':<8} {'wrong'}")
+        for f in report.families:
+            print(f"  {f.family:<22} {f.cases_total:<7} {f.cases_refused:<8} {f.cases_solved:<8} {f.cases_wrong}")
+        print(f"\nartifact: {out_path}")
+        if report.refusal_reason:
+            print(f"refusal_reason: {report.refusal_reason}")
+    return 0 if report.obligation_8_passed else 1
+
+
+def cmd_capability_depth_curve(args: argparse.Namespace) -> int:
+    """ADR-0114a Obligation #6 — compositional-depth curve. Re-runs the
+    lane's expected-correct cases, buckets by ``len(trace.steps)``,
+    asserts ``accuracy(N) >= accuracy(depth_1) * (1 - eps)^(N-1)`` for
+    eps = 0.05. Defaults to B3 (bounded grammar). Emits report to
+    ``--out`` (default ``evals/obligation_6_depth_curve/<lane_id>.json``).
+    Exit 0 iff the assertion holds."""
+    from core.capability.depth_curve import (
+        emit_depth_curve_report,
+        evaluate_depth_curve,
+    )
+
+    report = evaluate_depth_curve()
+    out_path = Path(args.out) if args.out else (
+        Path(__file__).resolve().parent.parent
+        / "evals" / "obligation_6_depth_curve"
+        / f"{report.lane_id}.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_depth_curve_report(report, out_path)
+
+    if args.json:
+        print(json.dumps(report.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"lane:                          {report.lane_id}")
+        print(f"cases_total:                   {report.cases_total}")
+        print(f"cases_solved:                  {report.cases_solved}")
+        print(f"epsilon:                       {report.epsilon}")
+        print(f"mechanism_wired:               {report.obligation_6_mechanism_wired}")
+        print(f"assertion_holds:               {report.obligation_6_assertion_holds}")
+        print(f"coverage_sufficient:           {report.coverage_sufficient}")
+        print(f"populated_buckets:             {list(report.populated_buckets)}")
+        print()
+        print(f"  {'bucket':<12} {'total':<7} {'correct':<8} {'accuracy':<10} {'bound':<10} {'satisfied'}")
+        for b in report.buckets:
+            bound = f"{b.bound_required:.4f}" if b.bound_required is not None else "(anchor)"
+            print(f"  {b.bucket:<12} {b.cases_total:<7} {b.cases_correct:<8} {b.accuracy:<10.4f} {bound:<10} {b.bound_satisfied}")
+        print(f"\nartifact: {out_path}")
+        if report.refusal_reason:
+            print(f"refusal_reason: {report.refusal_reason}")
+    return 0 if report.obligation_6_assertion_holds else 1
+
+
+def cmd_capability_ood_ratio(args: argparse.Namespace) -> int:
+    """ADR-0114a Obligation #2 — OOD surface variation ratio auditor.
+
+    Reads the B3 public ``report.json`` and the OOD lane ``report.json``,
+    computes ``ood_ratio = ood_accuracy / public_accuracy``, and exits 0
+    iff ratio >= 0.95 AND ood wrong == 0. Writes report to ``--out``
+    (default: ``evals/obligation_2_ood_ratio/<lane_id>.json``)."""
+    from core.capability.ood_ratio import (
+        emit_ood_ratio_report,
+        evaluate_ood_ratio,
+    )
+    from evals.obligation_2_ood_ratio.v1.runner import build_report, load_cases, write_report as write_ood_report
+
+    _repo_root = Path(__file__).resolve().parent.parent
+
+    # Regenerate OOD report so auditor always reads fresh results.
+    ood_report_path = _repo_root / "evals" / "obligation_2_ood_ratio" / "v1" / "report.json"
+    ood_cases = load_cases()
+    ood_runner_report = build_report(ood_cases)
+    write_ood_report(ood_runner_report, ood_report_path)
+
+    report = evaluate_ood_ratio()
+    out_path = Path(args.out) if args.out else (
+        _repo_root
+        / "evals" / "obligation_2_ood_ratio"
+        / f"{report.lane_id}.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_ood_ratio_report(report, out_path)
+
+    if args.json:
+        print(json.dumps(report.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"lane:                        {report.lane_id}")
+        print(f"public_accuracy:             {report.public_accuracy:.4f}  ({report.public_cases_correct}/{report.public_cases_total})")
+        print(f"ood_accuracy:                {report.ood_accuracy:.4f}  ({report.ood_cases_correct}/{report.ood_cases_total})")
+        print(f"ood_ratio:                   {report.ood_ratio:.4f}")
+        print(f"obligation_2_ratio_satisfied:{report.obligation_2_ratio_satisfied}")
+        print(f"obligation_2_wrong_zero:     {report.obligation_2_wrong_zero}")
+        print(f"obligation_2_passed:         {report.obligation_2_passed}")
+        print(f"artifact:                    {out_path}")
+        if report.refusal_reason:
+            print(f"refusal_reason:              {report.refusal_reason}")
+    return 0 if report.obligation_2_passed else 1
+
+
+def cmd_capability_math_expert_promote(args: argparse.Namespace) -> int:
+    """ADR-0120 math-expert promotion composer. Collects all 10 ADR-0114a
+    obligation verdicts + the ADR-0131.4 composite math gate verdict +
+    the reviewer-signed claim entry from ``docs/reviewers.yaml``;
+    emits a deterministic ``expert_claims_math_v1_signed.json``
+    artifact. Exit 0 iff ``promote_admitted == True``.
+    """
+    from core.capability.expert_promotion_math import (
+        emit_promotion_artifact,
+        evaluate_math_expert_promotion,
+    )
+
+    verdict = evaluate_math_expert_promotion()
+    out_path = Path(args.out) if args.out else (
+        Path(__file__).resolve().parent.parent
+        / "evals" / "math_expert_claims" / "v1" / "expert_claims_math_v1_signed.json"
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    emit_promotion_artifact(verdict, out_path)
+
+    if args.json:
+        print(json.dumps(verdict.as_dict(), indent=2, sort_keys=True))
+    else:
+        print(f"domain:                      {verdict.domain}")
+        print()
+        print(f"  {'id':<4} {'passed':<7} title")
+        for o in verdict.obligations:
+            print(f"  {o.obligation_id:<4} {str(o.passed):<7} {o.title}")
+            if not o.passed:
+                print(f"          refusal: {o.refusal_reason}")
+        print()
+        print(f"composite_gate_passed:       {verdict.composite_gate_passed}")
+        print(f"all_obligations_passed:      {verdict.all_obligations_passed}")
+        print(f"technical_pass:              {verdict.technical_pass}")
+        print(f"claim_digest:                {verdict.claim_digest}")
+        print(f"reviewer_signature_present:  {verdict.reviewer_signature is not None}")
+        print(f"reviewer_signature_matches:  {verdict.reviewer_signature_matches}")
+        print(f"promote_admitted:            {verdict.promote_admitted}")
+        print(f"artifact:                    {out_path}")
+        if verdict.refusal_reason:
+            print()
+            print("refusal_reason:")
+            print(f"  {verdict.refusal_reason}")
+    return 0 if verdict.promote_admitted else 1
+
+

core/cli_doctor.py

@@ -0,0 +1,73 @@
+"""Doctor/package-health CLI command handler."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from core import cli_rust
+
+
+DEFAULT_REPO_ROOT = Path(__file__).resolve().parent.parent
+
+IMPORT_CHECKS: tuple[tuple[str, str], ...] = (
+    ("algebra", "algebra"),
+    ("alignment", "alignment.graph"),
+    ("benchmarks", "benchmarks.run_benchmarks"),
+    ("calibration", "calibration"),
+    ("chat", "chat.runtime"),
+    ("core_ingest", "core_ingest"),
+    ("demos", "demos.claude_tool_authority"),
+    ("engine_state", "engine_state"),
+    ("evals", "evals.framework"),
+    ("language_packs", "language_packs"),
+    ("morphology", "morphology.registry"),
+    ("packs", "packs.safety.loader"),
+    ("scripts", "scripts.run_pulse"),
+    ("sensorium", "sensorium.protocol"),
+    ("teaching", "teaching"),
+    ("workbench", "workbench"),
+)
+
+
+def cmd_doctor(args: argparse.Namespace, *, repo_root: Path = DEFAULT_REPO_ROOT) -> int:
+    """Inspect import/package health for the CLI runtime path."""
+    ok = True
+    print(f"repo_root: {repo_root}")
+    for label, module_name in IMPORT_CHECKS:
+        try:
+            __import__(module_name)
+        except Exception as exc:
+            ok = False
+            print(f"FAIL {label:<14} {module_name}: {exc.__class__.__name__}: {exc}")
+        else:
+            print(f"OK   {label:<14} {module_name}")
+
+    rust_importable, rust_detail = cli_rust.probe_core_rs()
+    print(
+        "INFO native core_rs "
+        f"{'importable' if rust_importable else 'not importable'}: {rust_detail}"
+    )
+    print("INFO native policy  optional; run `core doctor --rust --require-rust` to gate it")
+
+    if args.packs:
+        try:
+            from language_packs import list_packs
+
+            packs = list_packs()
+        except Exception as exc:
+            ok = False
+            print(f"FAIL packs          language_packs.list_packs: {exc.__class__.__name__}: {exc}")
+        else:
+            print("packs:")
+            if packs:
+                for pack_id in packs:
+                    print(f"  {pack_id}")
+            else:
+                print("  none found")
+
+    if args.rust:
+        rust_active = cli_rust.print_rust_status(repo_root=repo_root)
+        if args.require_rust and not rust_active:
+            ok = False
+    return 0 if ok else 1

core/cli_eval.py

@@ -0,0 +1,258 @@
+"""Extracted commands."""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from core.cli import _validate_output_path, _DEFAULT_AUDIT_PATH
+from core.cli import _die, _REPO_ROOT
+
+def cmd_eval(args: argparse.Namespace) -> int:
+    """Run an eval lane by name, or list available lanes."""
+    if getattr(args, "lane", None) == "sensorium":
+        return cmd_eval_sensorium(args)
+    if getattr(args, "lane", None) == "environment-falsification":
+        return cmd_eval_environment_falsification(args)
+    if getattr(args, "lane", None) == "math-contemplation":
+        return cmd_eval_math_contemplation(args)
+
+    from evals._parallel import normalize_workers
+    from evals.framework import (
+        discover_lanes,
+        get_lane,
+        load_cases,
+        run_lane,
+        write_result,
+    )
+
+    if args.list_lanes:
+        lanes = discover_lanes()
+        if not lanes:
+            print("no eval lanes found")
+        for lane in lanes:
+            versions = ", ".join(lane.versions) if lane.versions else "none"
+            print(f"  {lane.name:20s}  versions: {versions}")
+        return 0
+
+    lane_name = args.lane
+    if not lane_name:
+        _die("eval requires a lane name. Use `core eval --list` to see available lanes.")
+
+    try:
+        lane = get_lane(lane_name)
+    except FileNotFoundError as exc:
+        _die(str(exc))
+
+    version = args.version or (lane.versions[0] if lane.versions else "v1")
+    split = args.split
+
+    if not args.json and lane_name == "cognition":
+        if split == "dev":
+            cases_path = lane.dev_cases_path()
+        elif split == "public":
+            cases_path = lane.public_cases_path(version)
+        else:
+            cases_path = lane.holdout_cases_path(version)
+        cases = load_cases(cases_path)
+        effective_workers = normalize_workers(
+            args.workers if args.workers is not None else 4,
+            len(cases),
+        )
+        print(f"workers        : {effective_workers}")
+
+    try:
+        result = run_lane(
+            lane,
+            version=version,
+            split=split,
+            workers=args.workers,
+        )
+    except FileNotFoundError as exc:
+        _die(str(exc))
+
+    if args.json:
+        print(json.dumps(result.as_dict(), ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        print(f"lane           : {result.lane}")
+        print(f"version        : {result.version}")
+        print(f"split          : {result.split}")
+        print(f"cases          : {result.metrics.get('total', 0)}")
+        for key, value in result.metrics.items():
+            if key == "total":
+                continue
+            if isinstance(value, float):
+                print(f"{key:15s}: {value:.1%}")
+            else:
+                print(f"{key:15s}: {value}")
+        if lane_name == "cognition":
+            # The cognition lane case_details carry `intent_correct` and
+            # `versor_closure` booleans; other lanes do not, so the
+            # cognition-specific failure printer is gated on lane identity to
+            # avoid spurious "failures" output for lanes that pass cleanly.
+            failures = [
+                c for c in result.case_details
+                if not c.get("intent_correct") or not c.get("versor_closure")
+            ]
+            if failures:
+                print(f"\nfailures ({len(failures)}):")
+                for c in failures:
+                    issues = []
+                    if not c.get("intent_correct"):
+                        issues.append("intent")
+                    if not c.get("versor_closure"):
+                        vc = c.get("versor_condition", 0)
+                        issues.append(f"versor={vc:.2e}")
+                    cid = c.get("case_id") or c.get("id") or "<unknown>"
+                    print(f"  {cid}: {', '.join(issues)}")
+
+    if args.save:
+        result_path = write_result(lane, result)
+        print(f"\nresult written: {result_path}", file=sys.stderr)
+
+    if args.report:
+        report_path = Path(args.report)
+        report_path.parent.mkdir(parents=True, exist_ok=True)
+        report_path.write_text(
+            json.dumps(result.as_dict(), ensure_ascii=False, indent=2, sort_keys=True)
+        )
+        print(f"\nreport written: {report_path}", file=sys.stderr)
+
+    return 0
+
+
+def cmd_eval_sensorium(args: argparse.Namespace) -> int:
+    """Run deterministic sensorium modality evidence reports."""
+    from evals.sensorium import build_sensorium_report
+
+    modality = getattr(args, "modality", "vision") or "vision"
+    try:
+        report = build_sensorium_report(modality)
+    except ValueError as exc:
+        _die(str(exc), code=2)
+
+    if getattr(args, "json", False):
+        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        print(f"lane           : {report['lane']}")
+        print(f"modality       : {report['modality']}")
+        print(f"pack_id        : {report['pack_id']}")
+        print(f"gate_engaged   : {report['gate_engaged']}")
+        print(f"gate_closed    : {report['gate_closed']}")
+        print(f"cases          : {report['total']}")
+        print(f"passed         : {report['passed']}")
+        print(f"failed         : {report['failed']}")
+
+    if getattr(args, "report", None):
+        report_path = Path(args.report)
+        report_path.parent.mkdir(parents=True, exist_ok=True)
+        report_path.write_text(
+            json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True)
+        )
+        print(f"\nreport written: {report_path}", file=sys.stderr)
+
+    return 0 if report["failed"] == 0 and report["gate_closed"] else 1
+
+
+def cmd_eval_environment_falsification(args: argparse.Namespace) -> int:
+    """Run deterministic environmental falsification replay reports."""
+    from evals.environment_falsification import build_environment_falsification_report
+
+    report = build_environment_falsification_report()
+
+    if getattr(args, "json", False):
+        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        print(f"lane           : {report['lane']}")
+        print(f"version        : {report['version']}")
+        print(f"cases          : {report['total']}")
+        print(f"passed         : {report['passed']}")
+        print(f"failed         : {report['failed']}")
+        print(f"report_sha256  : {report['report_sha256']}")
+
+    if getattr(args, "report", None):
+        report_path = Path(args.report)
+        report_path.parent.mkdir(parents=True, exist_ok=True)
+        report_path.write_text(
+            json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True)
+        )
+        print(f"\nreport written: {report_path}", file=sys.stderr)
+
+    return 0 if report["failed"] == 0 and report["expected_report_hash_ok"] else 1
+
+
+def cmd_eval_math_contemplation(args: argparse.Namespace) -> int:
+    """ADR-0172 W3 — decompose an audit brief into refusal-shape proposals.
+
+    Reads ``--audit`` (default: ``evals/gsm8k_math/train_sample/v1/audit_brief_11.json``),
+    runs :func:`teaching.math_contemplation.decompose_audit`, and writes one
+    ``canonical_bytes()`` JSON line per proposal to ``--output``
+    (default: ``teaching/math_proposals/proposals.jsonl``).
+
+    Idempotency: re-running on the same audit overwrites byte-identical bytes.
+    Output is sorted by ``proposal_id`` (matches the decomposer sort contract).
+
+    Exit codes:
+      0  success
+      1  audit file not found
+      2  parse error or path-traversal rejection
+
+    Forbidden by design: no proposal is auto-applied, no file outside
+    ``teaching/math_proposals/`` is written, the audit file is not mutated.
+    """
+    from teaching.math_contemplation import decompose_audit
+    from teaching.math_contemplation_proposal import to_jsonl_record
+
+    audit_raw = getattr(args, "audit", None)
+    output_raw = getattr(args, "output", None)
+
+    audit_path = Path(audit_raw) if audit_raw else _DEFAULT_AUDIT_PATH
+    if not audit_path.is_absolute():
+        audit_path = (_REPO_ROOT / audit_path).resolve()
+
+    if not audit_path.exists():
+        _die(f"audit file not found: {audit_path}", code=1)
+
+    output_path = _validate_output_path(output_raw)
+
+    try:
+        proposals = decompose_audit(audit_path)
+    except json.JSONDecodeError as exc:
+        _die(f"parse error in audit file {audit_path}: {exc}", code=2)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Self-contained JSONL (ADR-0172 tightening follow-up #1): each line
+    # carries proposal_id, full evidence_pointers, and full
+    # reasoning_trace.steps so consumers can load without re-running the
+    # decomposer.
+    lines: list[bytes] = []
+    for proposal in proposals:
+        record = to_jsonl_record(proposal)
+        encoded = json.dumps(
+            record,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8")
+        lines.append(encoded + b"\n")
+    output_path.write_bytes(b"".join(lines))
+
+    if not getattr(args, "json", False):
+        print(f"proposals      : {len(proposals)}")
+        print(f"output         : {output_path}")
+    else:
+        print(
+            json.dumps(
+                {
+                    "proposals": len(proposals),
+                    "output": str(output_path),
+                },
+                ensure_ascii=False,
+                sort_keys=True,
+            )
+        )
+
+    return 0
+
+

core/cli_ingest.py

@@ -0,0 +1,227 @@
+"""Operator-facing CLI for the durable ``core_ingest`` boundary."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from core_ingest import IngestPipeline, IngestPipelineConfig, SegmentManifold
+from core_ingest.types import LearningArtifact, SourceSpan, ValidationReport
+
+
+_MODALITY_HINTS = ("prose", "scripture", "code", "math")
+_DEFAULT_MAX_BYTES = 1_048_576
+_TRUST_BOUNDARY = (
+    "read_only_durable_core_ingest_compile_no_gate_import_no_vault_or_pack_mutation"
+)
+
+
+def _source_from_args(args: argparse.Namespace) -> tuple[bytes, dict[str, Any]]:
+    if args.text is not None:
+        source = args.text.encode("utf-8")
+        return source, {
+            "kind": "text",
+            "bytes": len(source),
+            "sha256": hashlib.sha256(source).hexdigest(),
+        }
+
+    path = Path(args.file).expanduser()
+    try:
+        resolved = path.resolve(strict=True)
+    except FileNotFoundError as exc:
+        raise ValueError(f"source file does not exist: {path}") from exc
+
+    if not resolved.is_file():
+        raise ValueError(f"source path is not a regular file: {resolved}")
+
+    size = resolved.stat().st_size
+    if size > args.max_bytes:
+        raise ValueError(
+            f"source file is {size} bytes, above --max-bytes {args.max_bytes}"
+        )
+
+    source = resolved.read_bytes()
+    return source, {
+        "kind": "file",
+        "path": str(resolved),
+        "bytes": len(source),
+        "sha256": hashlib.sha256(source).hexdigest(),
+    }
+
+
+def _span_payload(span: SourceSpan) -> dict[str, Any]:
+    return {
+        "byte_start": span.byte_start,
+        "byte_end": span.byte_end,
+        "source_sha256": span.source_sha256,
+        "page": span.page,
+        "region": span.region,
+    }
+
+
+def _report_payload(
+    *,
+    source_info: dict[str, Any],
+    modality_hint: str,
+    report: ValidationReport,
+    artifacts: list[LearningArtifact],
+    manifold: SegmentManifold,
+    register_all: bool,
+) -> dict[str, Any]:
+    return {
+        "command": "ingest compile",
+        "path": "durable",
+        "boundary_owner": "core_ingest",
+        "runtime_gate": "ingest/gate.py is not imported or called",
+        "trust_boundary": _TRUST_BOUNDARY,
+        "mutates": False,
+        "modality_hint": modality_hint,
+        "source": source_info,
+        "summary": {
+            "results": len(report.results),
+            "accepted": len(report.accepted_ids),
+            "rejected": len(report.rejected_ids),
+            "review_required": len(report.review_ids),
+            "acceptance_rate": report.acceptance_rate,
+            "manifold_keys": len(manifold),
+            "register_all": register_all,
+        },
+        "results": [
+            {
+                "pressure_id": result.pressure_id,
+                "semantic_key": result.semantic_key,
+                "disposition": result.disposition.value,
+                "gate_failed": result.gate_failed,
+                "failure_reason": result.failure_reason,
+                "warnings": list(result.warnings),
+            }
+            for result in report.results
+        ],
+        "artifacts": [
+            {
+                "pressure_id": artifact.packet.pressure_id,
+                "semantic_key": artifact.packet.semantic_key,
+                "kind": artifact.packet.kind,
+                "modality": artifact.packet.modality.value,
+                "review_level": artifact.packet.review_level.value,
+                "instrument_id": artifact.packet.frontend.instrument_id,
+                "lemma": artifact.packet.lemma,
+                "spans": [_span_payload(span) for span in artifact.packet.provenance],
+            }
+            for artifact in artifacts
+        ],
+    }
+
+
+def _print_text(payload: dict[str, Any]) -> None:
+    summary = payload["summary"]
+    source = payload["source"]
+    source_label = (
+        source["path"] if source["kind"] == "file" else f"inline:{source['sha256'][:12]}"
+    )
+    print("core_ingest durable compile")
+    print(f"source         : {source_label}")
+    print(f"source_bytes   : {source['bytes']}")
+    print(f"modality_hint  : {payload['modality_hint']}")
+    print(f"trust_boundary : {payload['trust_boundary']}")
+    print(f"runtime_gate   : {payload['runtime_gate']}")
+    print(f"mutates        : {payload['mutates']}")
+    print(f"results        : {summary['results']}")
+    print(f"accepted       : {summary['accepted']}")
+    print(f"rejected       : {summary['rejected']}")
+    print(f"review_required: {summary['review_required']}")
+    print(f"acceptance_rate: {summary['acceptance_rate']:.3f}")
+    for result in payload["results"][:10]:
+        reason = f" {result['failure_reason']}" if result["failure_reason"] else ""
+        print(
+            f"  {result['disposition']:<20} "
+            f"{result['pressure_id'][:12]} semantic={result['semantic_key'][:12]}"
+            f"{reason}"
+        )
+    if len(payload["results"]) > 10:
+        print(f"  ... {len(payload['results']) - 10} more result(s)")
+
+
+def cmd_ingest_compile(args: argparse.Namespace) -> int:
+    """Run the durable core_ingest pipeline and print a validation report."""
+    try:
+        source, source_info = _source_from_args(args)
+        if not source:
+            raise ValueError("ingest source is empty")
+        manifold = SegmentManifold()
+        pipeline = IngestPipeline(
+            manifold=manifold,
+            config=IngestPipelineConfig(register_all=args.register_all),
+        )
+        report, artifacts = pipeline.run(source, modality_hint=args.modality)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    payload = _report_payload(
+        source_info=source_info,
+        modality_hint=args.modality,
+        report=report,
+        artifacts=artifacts,
+        manifold=manifold,
+        register_all=args.register_all,
+    )
+    if args.json:
+        print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        _print_text(payload)
+    return 0
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Attach the ``core ingest`` subcommand tree to a top-level parser."""
+    ingest = subparsers.add_parser(
+        "ingest",
+        help="inspect durable input-to-pressure compilation",
+        description=(
+            "Run the durable core_ingest compiler. This is read-only: it does "
+            "not import ingest/gate.py, write vault memory, mutate packs, or "
+            "ratify learning."
+        ),
+    )
+    sub = ingest.add_subparsers(
+        dest="ingest_command", metavar="ingest-command", required=True,
+    )
+
+    compile_cmd = sub.add_parser(
+        "compile",
+        help="compile source bytes into validated candidate pressure",
+        description=(
+            "Compile source bytes through StructuralSegmenter -> "
+            "IngestCompiler -> SegmentManifold and emit a validation report."
+        ),
+    )
+    source = compile_cmd.add_mutually_exclusive_group(required=True)
+    source.add_argument("--text", help="inline UTF-8 source text to compile")
+    source.add_argument(
+        "--file",
+        type=Path,
+        help="regular local file to read as source bytes",
+    )
+    compile_cmd.add_argument(
+        "--modality",
+        choices=_MODALITY_HINTS,
+        default="prose",
+        help="structural modality hint (default: prose)",
+    )
+    compile_cmd.add_argument(
+        "--max-bytes",
+        type=int,
+        default=_DEFAULT_MAX_BYTES,
+        help=f"maximum file size accepted by --file (default: {_DEFAULT_MAX_BYTES})",
+    )
+    compile_cmd.add_argument(
+        "--register-all",
+        action="store_true",
+        help="index rejected packets in the reconstruction manifold report",
+    )
+    compile_cmd.add_argument("--json", action="store_true", help="emit JSON")
+    compile_cmd.set_defaults(func=cmd_ingest_compile)

core/cli_pack.py

@@ -0,0 +1,75 @@
+"""Extracted commands."""
+from __future__ import annotations
+import argparse
+import json
+import sys
+
+from core.cli_teaching import _safe_pack_id
+from core.cli import _die, _REPO_ROOT, _run
+
+def cmd_pack_list(args: argparse.Namespace) -> int:
+    """List compiled language packs."""
+    from language_packs import list_packs
+
+    packs = list_packs()
+    if not packs:
+        print("no compiled packs found")
+        return 0
+    for pack_id in packs:
+        print(pack_id)
+    return 0
+
+
+def cmd_pack_verify(args: argparse.Namespace) -> int:
+    """Verify one language pack checksum."""
+    return _run(sys.executable, "-m", "language_packs", "verify", args.pack_id)
+
+
+def cmd_pack_validate(args: argparse.Namespace) -> int:
+    """Run executable source-pack validation gates."""
+    pack_id = _safe_pack_id(args.pack_id)
+    pack_dir = _REPO_ROOT / "packs" / pack_id
+    validator_path = pack_dir / "validators.py"
+
+    if not validator_path.exists():
+        _die(f"source-pack validator not found: {validator_path}", code=1)
+
+    if getattr(args, "dry_run", False):
+        if args.json:
+            print(json.dumps({
+                "pack_id": pack_id,
+                "validator_path": str(validator_path),
+                "would_execute": False,
+                "exists": True,
+            }, ensure_ascii=False, indent=2, sort_keys=True))
+        else:
+            print(f"dry-run: pack_id={pack_id}")
+            print(f"validator: {validator_path}")
+            print("status: validator exists, would not execute")
+        return 0
+
+    if not getattr(args, "allow_arbitrary_code", False):
+        _die(
+            "dynamic validator execution requires --allow-arbitrary-code",
+            code=2,
+        )
+
+    import importlib.util
+
+    spec = importlib.util.spec_from_file_location(f"{pack_id}_validators", validator_path)
+    if spec is None or spec.loader is None:
+        _die(f"cannot load source-pack validator: {validator_path}", code=1)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    report = module.validate_pack()
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        print(f"pack_id: {report['pack_id']}")
+        print(f"active : {report['active']}")
+        for name, result in report["gates"].items():
+            status = "PASS" if result["passed"] else "FAIL"
+            print(f"{status} {name:<12} {result['reason']}")
+    return 0 if report["active"] else 1
+
+

core/cli_rust.py

@@ -0,0 +1,144 @@
+"""Rust backend CLI command handlers.
+
+The top-level CLI owns argparse construction and subprocess policy. This module
+owns the Rust/native-substrate command behavior so ``core/cli.py`` does not keep
+absorbing every command family.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import NoReturn, Protocol
+
+
+DEFAULT_REPO_ROOT = Path(__file__).resolve().parent.parent
+CORE_RS_DIR = DEFAULT_REPO_ROOT / "core-rs"
+CORE_RS_MANIFEST = CORE_RS_DIR / "Cargo.toml"
+
+
+class CommandRunner(Protocol):
+    def __call__(
+        self,
+        *args: str,
+        check: bool = False,
+        cwd: Path | None = None,
+        env: dict[str, str] | None = None,
+    ) -> int: ...
+
+
+class DieHandler(Protocol):
+    def __call__(self, message: str, *, code: int = 2) -> NoReturn: ...
+
+
+def rust_paths(repo_root: Path = DEFAULT_REPO_ROOT) -> tuple[Path, Path]:
+    core_rs_dir = repo_root / "core-rs"
+    return core_rs_dir, core_rs_dir / "Cargo.toml"
+
+
+def run_command(
+    *args: str,
+    check: bool = False,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+) -> int:
+    completed = subprocess.run(args, check=check, text=True, cwd=cwd, env=env)
+    return int(completed.returncode)
+
+
+def die(message: str, *, code: int = 2) -> NoReturn:
+    print(f"error: {message}", file=sys.stderr)
+    raise SystemExit(code)
+
+
+def rust_build_env() -> dict[str, str]:
+    """Return the environment used for PyO3-backed Rust build/test commands."""
+    env = os.environ.copy()
+    # PyO3 0.21 supports Python through 3.12. Fresh uv environments may be
+    # 3.13+, so use PyO3's documented forward-compatibility escape hatch unless
+    # the operator has provided a more specific PYO3_* policy.
+    env.setdefault("PYO3_USE_ABI3_FORWARD_COMPATIBILITY", "1")
+    return env
+
+
+def probe_core_rs() -> tuple[bool, str]:
+    try:
+        import core_rs
+    except Exception as exc:
+        return False, f"{exc.__class__.__name__}: {exc}"
+    return True, str(getattr(core_rs, "__file__", "<built-in>"))
+
+
+def print_rust_status(*, repo_root: Path = DEFAULT_REPO_ROOT) -> bool:
+    from algebra.backend import using_rust
+
+    core_rs_dir, core_rs_manifest = rust_paths(repo_root)
+    active = using_rust()
+    importable, import_detail = probe_core_rs()
+    print(f"core_rs crate : {core_rs_dir}")
+    print(f"cargo manifest: {core_rs_manifest}")
+    print(f"CORE_BACKEND  : {os.environ.get('CORE_BACKEND', '') or '(default python)'}")
+    print(f"core_rs import: {'ok' if importable else 'missing'}")
+    print(f"core_rs detail: {import_detail}")
+    print(f"rust backend  : {'active' if active else 'inactive'}")
+    if not active:
+        print("activation    : run `core rust build`")
+    return active
+
+
+def cmd_rust_status(
+    args: argparse.Namespace,
+    *,
+    repo_root: Path = DEFAULT_REPO_ROOT,
+) -> int:
+    """Print Rust backend activation status."""
+    return 0 if print_rust_status(repo_root=repo_root) or not args.require_active else 1
+
+
+def cmd_rust_build(
+    args: argparse.Namespace,
+    *,
+    repo_root: Path = DEFAULT_REPO_ROOT,
+    run: CommandRunner = run_command,
+    fail: DieHandler = die,
+    python_executable: str = sys.executable,
+) -> int:
+    """Build/install core_rs into the active Python environment."""
+    _, core_rs_manifest = rust_paths(repo_root)
+    if not core_rs_manifest.exists():
+        fail(f"core-rs manifest not found: {core_rs_manifest}", code=1)
+    if shutil.which("uv") is not None:
+        rc = run("uv", "pip", "install", "maturin")
+        if rc != 0:
+            return rc
+    cmd = [
+        python_executable,
+        "-m",
+        "maturin",
+        "develop",
+        "--release",
+        "--manifest-path",
+        str(core_rs_manifest),
+    ]
+    if args.skip_auditwheel:
+        cmd.append("--skip-auditwheel")
+    return run(*cmd, env=rust_build_env())
+
+
+def cmd_rust_test(
+    args: argparse.Namespace,
+    *,
+    repo_root: Path = DEFAULT_REPO_ROOT,
+    run: CommandRunner = run_command,
+    fail: DieHandler = die,
+) -> int:
+    """Run Rust crate tests."""
+    del args
+    core_rs_dir, _ = rust_paths(repo_root)
+    if shutil.which("cargo") is None:
+        fail("cargo not found. Install a Rust toolchain first.", code=1)
+    return run("cargo", "test", "--release", cwd=core_rs_dir, env=rust_build_env())

core/cli_test.py

@@ -0,0 +1,278 @@
+"""Curated pytest and ruff CLI command handlers."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Protocol
+
+
+TEST_SUITES: dict[str, tuple[str, ...]] = {
+    "fast": (
+        "tests/test_cli_test_suites.py",
+        "tests/test_runtime_config.py",
+        "tests/test_core_semantic_seed_pack.py",
+        "tests/test_intent_proposition_graph.py",
+        "tests/test_articulation_realizer_v2.py",
+        "tests/test_reviewed_teaching_loop.py",
+        "tests/test_cognitive_eval_harness.py",
+    ),
+    "smoke": (
+        "tests/test_chat_runtime.py",
+        "tests/test_achat.py",
+        "tests/test_runtime_config.py",
+        "tests/test_cognitive_turn_pipeline.py",
+        "tests/test_architectural_invariants.py",
+        # ADR-0043 — identity falsifiability: ratified identity packs must
+        # produce distinct, directionally-correct articulations, with a
+        # pack-invariant grounding/refusal floor and zero fabrication. Lives
+        # only under ``full`` historically, so a divergence regression cleared
+        # the PR gate and surfaced only post-merge. Promoted into smoke so
+        # the falsifiability claim blocks-on-regression rather than
+        # detect-after-merge.
+        "tests/test_pack_measurements_phase2.py",
+    ),
+    "runtime": (
+        "tests/test_chat_runtime.py",
+        "tests/test_achat.py",
+        "tests/test_runtime_config.py",
+        "tests/test_session_coherence.py",
+    ),
+    "cognition": (
+        "tests/test_intent_proposition_graph.py",
+        "tests/test_cognitive_turn_pipeline.py",
+        "tests/test_articulation_realizer_v2.py",
+        "tests/test_semantic_realizer_integration.py",
+        "tests/test_cognitive_eval_harness.py",
+        "tests/test_deterministic_hash.py",
+        "tests/test_morphology_irregular.py",
+        "tests/test_realizer_quantifier_agreement.py",
+        "tests/test_benchmarks_profiler.py",
+        "tests/test_compose_relations.py",
+        "tests/test_replay_vs_llm_benchmark.py",
+    ),
+    "teaching": (
+        "tests/test_reviewed_teaching_loop.py",
+        "tests/test_pipeline_teaching_integration.py",
+        "tests/test_epistemic_invariants.py",
+        "tests/test_adr_0172_w2_decomposer.py",
+        "tests/test_adr_0172_w5_inference_proposal.py",
+        "tests/test_math_frame_ratification.py",
+        "tests/test_math_composition_ratification.py",
+        "tests/test_teaching_coverage_cli.py",
+    ),
+    "packs": (
+        "tests/test_core_semantic_seed_pack.py",
+        "tests/test_adr_0127_pack_ratification.py",
+        "tests/test_frame_registry_load.py",
+        "tests/test_composition_registry_load.py",
+        "tests/test_composition_consult_in_injector.py",
+        "tests/test_consumption_case_0050_hazard_pin.py",
+        "tests/test_consumption_empty_registry_no_op.py",
+        "tests/test_consumption_partition.py",
+        "tests/test_matcher_extension_currency_per_unit.py",
+        "tests/test_matcher_extension_case_0050_hazard_pin.py",
+        "tests/test_matcher_extension_end_to_end_admission.py",
+        "tests/test_me2_cross_sentence_subject.py",
+        "tests/test_me2_case_0019_admits.py",
+        "tests/test_me3_additive_composition.py",
+        "tests/test_me4_subtractive_composition.py",
+        "tests/test_me5_all_categories_integration.py",
+        "tests/test_rat1_end_to_end_admission.py",
+        "tests/test_wave_a_multiplicative_aggregation_injector.py",
+    ),
+    "algebra": (
+        "tests/test_versor_closure.py",
+        "tests/test_holonomy.py",
+        "tests/test_holonomy_resonance.py",
+        "tests/test_energy.py",
+        "tests/test_motor.py",
+        "tests/test_null_cone.py",
+        "tests/test_vault_recall.py",
+        "tests/test_vault_recall_vectorised.py",
+        "tests/test_vault_recall_rust_parity.py",
+        "tests/test_cga_inner_rust_parity.py",
+        "tests/test_geometric_product_rust_parity.py",
+        "tests/test_versor_condition_rust_parity.py",
+        "tests/test_versor_apply_rust_parity.py",
+    ),
+    "sensorium": (
+        "tests/test_sensorium_compiler_delta.py",
+        "tests/test_audio_compiler.py",
+        "tests/test_audio_crdt_merge.py",
+        "tests/test_audio_eval_gates.py",
+        "tests/test_audio_pack_manifest.py",
+        "tests/test_audio_sensorium_mount.py",
+        "tests/test_vision_compiler.py",
+        "tests/test_event_vision_compiler.py",
+        "tests/test_vision_crdt_merge.py",
+        "tests/test_vision_eval_gates.py",
+        "tests/test_vision_sensorium_mount.py",
+        "tests/test_sensorimotor_contract.py",
+        "tests/test_sensorimotor_pack_manifest.py",
+        "tests/test_observation_frame_contract.py",
+        "tests/test_observation_frame_harness.py",
+        "tests/test_environment_falsification.py",
+        "tests/test_environment_falsification_eval_cli.py",
+        "tests/test_witness_log_importer.py",
+        "tests/test_tabletop_lab_protocol.py",
+        "tests/test_sensorium_eval_cli.py",
+        "tests/test_efferent_gate.py",
+    ),
+    "pulse": (
+        "tests/test_pulse_integration.py",
+        "tests/test_graph_diffusion.py",
+    ),
+    "formation": (
+        "tests/formation",
+    ),
+    "proof": (
+        "tests/test_proof_properties.py",
+    ),
+    # ADR-0024 chain suites (Phases 2-6). Each phase has its own contract
+    # tests so reviewers can run them independently; ``adr-0024`` runs the full
+    # chain end-to-end.
+    "refusal": (
+        "tests/test_refusal_contract.py",
+    ),
+    "margin": (
+        "tests/test_margin_admissibility.py",
+    ),
+    "rotor": (
+        "tests/test_rotor_admissibility.py",
+    ),
+    "inner-loop": (
+        "tests/test_inner_loop_admissibility.py",
+        "tests/test_inner_loop_phase2.py",
+        "tests/test_inner_loop_phase3.py",
+        "tests/test_inner_loop_phase4.py",
+    ),
+    "phase5": (
+        "tests/test_phase5_corpus.py",
+    ),
+    "phase6": (
+        "tests/test_phase6_demo.py",
+    ),
+    "adr-0024": (
+        "tests/test_refusal_contract.py",
+        "tests/test_margin_admissibility.py",
+        "tests/test_rotor_admissibility.py",
+        "tests/test_inner_loop_admissibility.py",
+        "tests/test_inner_loop_phase2.py",
+        "tests/test_inner_loop_phase3.py",
+        "tests/test_inner_loop_phase4.py",
+        "tests/test_phase5_corpus.py",
+        "tests/test_phase6_demo.py",
+    ),
+    # ADR-0126 P6 — measurement harness for the GSM8K candidate-graph parser
+    # exit criterion. ``wrong == 0`` is a hard gate (Obligation #4: refuse
+    # rather than confabulate).
+    "math": (
+        "tests/test_adr_0126_train_sample_runner.py",
+    ),
+    "deductive": (
+        "tests/test_deductive_logic_entail.py",
+    ),
+    "full": ("tests/",),
+}
+
+
+class CommandRunner(Protocol):
+    def __call__(
+        self,
+        *args: str,
+        check: bool = False,
+        cwd: Path | None = None,
+        env: dict[str, str] | None = None,
+    ) -> int: ...
+
+
+def run_command(
+    *args: str,
+    check: bool = False,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+) -> int:
+    completed = subprocess.run(args, check=check, text=True, cwd=cwd, env=env)
+    return int(completed.returncode)
+
+
+def pytest_args_for_suite(suite: str, extra_args: Sequence[str]) -> list[str]:
+    paths = TEST_SUITES[suite]
+    forwarded = list(extra_args)
+    if forwarded and forwarded[0] == "--":
+        forwarded = forwarded[1:]
+    return [*paths, *forwarded]
+
+
+def xdist_available() -> bool:
+    """Return True iff ``pytest-xdist`` is importable."""
+    try:
+        import xdist  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+def maybe_inject_xdist(forwarded: list[str], suite: str | None) -> list[str]:
+    """Inject ``-n auto`` for suites large enough to benefit from parallelism."""
+    if not xdist_available():
+        return forwarded
+    # Honour explicit operator override.
+    if any(a.startswith("-n") or a == "--dist" for a in forwarded):
+        return forwarded
+    if suite == "full":
+        return ["-n", "auto", *forwarded]
+    return forwarded
+
+
+def cmd_test(
+    args: argparse.Namespace,
+    *,
+    run: CommandRunner = run_command,
+    python_executable: str = sys.executable,
+) -> int:
+    """Run pytest through curated suite aliases or direct passthrough args."""
+    default_args = ["-q", "--tb=short"]
+    if args.list_suites:
+        for name in sorted(TEST_SUITES):
+            print(name)
+        return 0
+    if args.suite:
+        forwarded = pytest_args_for_suite(args.suite, args.args or default_args)
+    else:
+        forwarded = list(args.args or default_args)
+        if forwarded and forwarded[0] == "--":
+            forwarded = forwarded[1:]
+    forwarded = maybe_inject_xdist(forwarded, args.suite)
+    return run(python_executable, "-m", "pytest", *forwarded)
+
+
+def cmd_check(
+    args: argparse.Namespace,
+    *,
+    run: CommandRunner = run_command,
+    python_executable: str = sys.executable,
+) -> int:
+    """Run ruff over selected project paths."""
+    targets = args.paths or [
+        "algebra",
+        "alignment",
+        "chat",
+        "core",
+        "field",
+        "generate",
+        "ingest",
+        "language_packs",
+        "morphology",
+        "persona",
+        "sensorium",
+        "session",
+        "vault",
+        "vocab",
+        "tests",
+    ]
+    return run(python_executable, "-m", "ruff", "check", *targets)

tests/test_cli.py

@@ -45,6 +45,8 @@ def test_rust_status_reports_backend_state(capsys: pytest.CaptureFixture[str]) -
     out = capsys.readouterr().out
     assert "core_rs crate" in out
     assert "cargo manifest" in out
+    assert "core_rs import" in out
+    assert "CORE_BACKEND" in out
     assert "rust backend" in out
 
 
@@ -67,13 +69,20 @@ def test_doctor_imports_runtime_support_modules(capsys: pytest.CaptureFixture[st
     assert main(["doctor"]) == 0
     out = capsys.readouterr().out
     assert "OK   alignment" in out
+    assert "OK   core_ingest" in out
+    assert "OK   engine_state" in out
+    assert "OK   packs" in out
+    assert "OK   teaching" in out
     assert "OK   morphology" in out
     assert "OK   sensorium" in out
+    assert "INFO native core_rs" in out
+    assert "INFO native policy" in out
 
 
 def test_doctor_rust_reports_backend_state(capsys: pytest.CaptureFixture[str]) -> None:
     assert main(["doctor", "--rust"]) == 0
     out = capsys.readouterr().out
+    assert "core_rs import" in out
     assert "rust backend" in out
 
 

tests/test_cli_ingest.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import builtins
+import hashlib
+import json
+from pathlib import Path
+
+import pytest
+
+from core.cli import build_parser, main
+
+
+def test_ingest_help_names_durable_read_only_boundary(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as excinfo:
+        build_parser().parse_args(["ingest", "-h"])
+
+    assert excinfo.value.code == 0
+    out = capsys.readouterr().out
+    assert "durable core_ingest compiler" in out
+    assert "read-only" in out
+    assert "ingest/gate.py" in out
+
+
+def test_ingest_compile_text_json_reports_durable_boundary(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    text = "The logos is the foundation.\n\nThe field remains coherent."
+
+    rc = main(["ingest", "compile", "--text", text, "--json"])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["command"] == "ingest compile"
+    assert payload["path"] == "durable"
+    assert payload["boundary_owner"] == "core_ingest"
+    assert payload["runtime_gate"] == "ingest/gate.py is not imported or called"
+    assert payload["mutates"] is False
+    assert payload["source"]["kind"] == "text"
+    assert payload["source"]["sha256"] == hashlib.sha256(text.encode()).hexdigest()
+    assert payload["summary"]["accepted"] == len(payload["artifacts"])
+    assert payload["summary"]["accepted"] >= 1
+
+
+def test_ingest_compile_file_json_reports_regular_file(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    source = tmp_path / "source.md"
+    source.write_text("First paragraph.\n\nSecond paragraph.", encoding="utf-8")
+
+    rc = main(["ingest", "compile", "--file", str(source), "--json"])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["source"]["kind"] == "file"
+    assert payload["source"]["path"] == str(source.resolve())
+    assert payload["summary"]["results"] >= 1
+
+
+def test_ingest_compile_file_rejects_directory(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    rc = main(["ingest", "compile", "--file", str(tmp_path)])
+
+    assert rc == 2
+    captured = capsys.readouterr()
+    assert "regular file" in captured.err
+
+
+def test_ingest_compile_file_respects_size_limit(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    source = tmp_path / "source.md"
+    source.write_text("too large for this test", encoding="utf-8")
+
+    rc = main(["ingest", "compile", "--file", str(source), "--max-bytes", "4"])
+
+    assert rc == 2
+    captured = capsys.readouterr()
+    assert "above --max-bytes 4" in captured.err
+
+
+def test_ingest_compile_does_not_import_runtime_gate(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    real_import = builtins.__import__
+
+    def guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
+        if name == "ingest.gate" or (name == "ingest" and "gate" in fromlist):
+            raise AssertionError("durable core_ingest CLI imported runtime gate")
+        return real_import(name, globals, locals, fromlist, level)
+
+    monkeypatch.setattr(builtins, "__import__", guarded_import)
+
+    rc = main(["ingest", "compile", "--text", "Boundary check.", "--json"])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["runtime_gate"] == "ingest/gate.py is not imported or called"

tests/test_cli_test_suites.py

@@ -2,11 +2,36 @@
 
 from __future__ import annotations
 
+import tomllib
+from pathlib import Path
+
 import pytest
 
+from core import cli_rust
 from core import cli
 
 
+def test_pyproject_installs_core_console_script_under_uv() -> None:
+    pyproject = Path(__file__).resolve().parents[1] / "pyproject.toml"
+    data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+
+    assert data["project"]["scripts"]["core"] == "core.cli:main"
+    assert data["tool"]["uv"]["package"] is True
+    package_includes = data["tool"]["setuptools"]["packages"]["find"]["include"]
+    expected_runtime_packages = {
+        "benchmarks*",
+        "calibration*",
+        "core_ingest*",
+        "demos*",
+        "engine_state*",
+        "evals*",
+        "packs*",
+        "scripts*",
+        "teaching*",
+    }
+    assert expected_runtime_packages.issubset(package_includes)
+
+
 def test_core_test_lists_curated_suites(capsys) -> None:
     rc = cli.main(["test", "--list-suites"])
 
@@ -129,6 +154,35 @@ def test_core_test_passthrough_still_accepts_arbitrary_pytest_args(monkeypatch)
     )
 
 
+def test_core_rust_test_sets_pyo3_forward_compat(monkeypatch) -> None:
+    calls: list[tuple[tuple[str, ...], object, dict[str, str] | None]] = []
+
+    def fake_which(name: str) -> str | None:
+        return "/usr/bin/cargo" if name == "cargo" else None
+
+    def fake_run(
+        *args: str,
+        check: bool = False,
+        cwd=None,
+        env: dict[str, str] | None = None,
+    ) -> int:
+        calls.append((args, cwd, env))
+        return 0
+
+    monkeypatch.setattr(cli_rust.shutil, "which", fake_which)
+    monkeypatch.setattr(cli, "_run", fake_run)
+
+    rc = cli.main(["rust", "test"])
+
+    assert rc == 0
+    assert len(calls) == 1
+    args, cwd, env = calls[0]
+    assert args == ("cargo", "test", "--release")
+    assert cwd == cli_rust.CORE_RS_DIR
+    assert env is not None
+    assert env["PYO3_USE_ABI3_FORWARD_COMPATIBILITY"] == "1"
+
+
 def test_non_test_commands_still_reject_unknown_args() -> None:
     with pytest.raises(SystemExit):
         cli.main(["pack", "list", "-q"])

tests/test_repository_hygiene.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import conftest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_top_level_contemplation_is_artifact_namespace_only() -> None:
+    artifact_root = ROOT / "contemplation"
+    code_root = ROOT / "core" / "contemplation"
+
+    assert (artifact_root / "README.md").is_file()
+    assert (artifact_root / "runs").is_dir()
+    assert not (artifact_root / "__init__.py").exists()
+    assert not list(artifact_root.rglob("*.py"))
+    assert (code_root / "__init__.py").is_file()
+
+
+def test_quarantine_doc_matches_registry_count() -> None:
+    doc = (ROOT / "docs" / "test-debt-quarantine.md").read_text(encoding="utf-8")
+    match = re.search(r"^Current quarantined tests: (\d+)\.$", doc, re.MULTILINE)
+
+    assert match is not None
+    assert int(match.group(1)) == len(conftest.QUARANTINE)
+
+
+def test_provider_files_delegate_to_agents() -> None:
+    for name in ("CLAUDE.md", "GEMINI.md"):
+        text = (ROOT / name).read_text(encoding="utf-8")
+
+        assert len(text.encode("utf-8")) <= 600
+        assert "`AGENTS.md` is the canonical governance file" in text
+        assert "Do not place architecture, invariants, memory rules" in text
+
+
+def test_notes_are_non_executable_artifacts() -> None:
+    notes_root = ROOT / "notes"
+
+    assert (notes_root / "README.md").is_file()
+    assert not list(notes_root.rglob("*.py"))
+
+
+def test_intentional_topology_splits_have_local_readmes() -> None:
+    required = (
+        "calibration",
+        "contemplation",
+        "core/demos",
+        "core_ingest",
+        "demos",
+        "ingest",
+        "language_packs",
+        "notes",
+        "packs",
+        "workbench",
+        "workbench-ui",
+        "workbench_data",
+    )
+
+    missing = [path for path in required if not (ROOT / path / "README.md").is_file()]
+    assert missing == []