meta.reviews.gate

The shared cargo meta check fails when any current specification anchor lacks an up-to-date validation satisfying meta.reviews.staleness, with an output satisfying meta.reviews.output_format and no requested edits under meta.reviews.decisions. It loads all validation directories, checks the layout and summary metadata, and compares the saved inputs with current source. At least one test and implementation entry are required.

A validation for an anchor ID absent from the current specification also fails the gate, even when every current anchor has a passing validation. Diagnostics name that directory and direct the reviewer to remove obsolete records or reconcile renamed anchors and start fresh validation. Checking and recording do not silently delete stale anchor IDs. Invalid record formats, unsupported schema/policy versions, and incomplete records fail the gate. CI and workspace Cargo tests use this same gate; checking never creates approvals.

Read in specification context · design/meta/reviews.md

Implementation

Implemented crates/sage-meta/src/check.rs:435–440

sage_meta::check · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.gate`
// {anchor}`meta.reviews.record_required`
// {anchor}`meta.reviews.decisions`
// {anchor}`meta.reviews.review_diagnostics`
fn check_reviews(
    report: &mut CheckReport,

}

See more source ↗

Implemented crates/sage-meta/src/review.rs:674–679

sage_meta::review · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.gate`
// {anchor}`meta.reviews.record_required`
// {anchor}`meta.reviews.review_diagnostics`
pub fn validate(
    workspace: &Path,
    current: &BTreeMap<String, ReviewInput>,

}

See more source ↗

Implemented crates/sage-meta/src/main.rs:138–143

sage_meta · bin:sage-meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.gate`
// {anchor}`meta.reviews.record_required`
// {anchor}`meta.reviews.review_diagnostics`
fn check(args: &[std::ffi::OsString]) -> Result<(), Box<dyn std::error::Error>> {
    let mut json = false;
    let mut root = None;

}

See more source ↗

Implemented xtask/src/main.rs:86–91

xtask · bin:xtask

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.gate`
fn ci_test() -> Result<()> {
    let sh = Shell::new()?;
    let root = project_root();
    let _dir = sh.push_dir(&root);
    cmd!(sh, "cargo run -p sage-meta -- check").run()?;

}

See more source ↗

Tests and review

Indexed tests and the implementation-completeness and test-adequacy review; no test run is implied.

Implemented sage_meta::accepted_report_cannot_replace_missing_test_or_implementation_evidence

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
fn accepted_report_cannot_replace_missing_test_or_implementation_evidence() {
    for missing in ["test", "implementation"] {
        let fixture = Fixture::new();
        fixture.approve();
        if missing == "test" {
            fixture.write("src/tests.rs", "");
        } else {
            fixture.write("src/behavior.rs", "pub fn result() -> u32 { 4 }\n");
        }
        assert!(!sage_meta::check(&fixture.0).is_valid(), "{missing}");
        let cli = fixture.run(&["check"]);
        assert!(!cli.status.success());
        assert!(String::from_utf8_lossy(&cli.stderr).contains("demo.rule"));
    }
}
}

See more source ↗

Implemented sage_meta::checking_is_read_only_and_recording_preserves_obsolete_records

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.review_diagnostics)]
fn checking_is_read_only_and_recording_preserves_obsolete_records() {
    let fixture = Fixture::new();
    assert!(!fixture.run(&["check"]).status.success());
    assert!(!fixture.0.join("validations").exists());
    fixture.approve();
    let snapshot = |name: &str| {
        ["input.json", "output.json", "summary.json"]
            .map(|file| std::fs::read(fixture.0.join("validations").join(name).join(file)).unwrap())
    };
    let original = snapshot("demo.rule");
    assert!(fixture.run(&["check"]).status.success());
    assert!(sage_meta::check(&fixture.0).is_valid());
    assert_eq!(snapshot("demo.rule"), original);
    let obsolete = fixture.0.join("validations/demo.retired");
    std::fs::create_dir(&obsolete).unwrap();
    for (index, file) in ["input.json", "output.json", "summary.json"]
        .iter()
        .enumerate()
    {
        std::fs::write(obsolete.join(file), &original[index]).unwrap();
    }
    let mut summary = fixture.summary();
    summary["anchor"] = "demo.retired".into();
    std::fs::write(
        obsolete.join("summary.json"),
        serde_json::to_vec(&summary).unwrap(),
    )
    .unwrap();
    let retired = snapshot("demo.retired");
    assert!(!sage_meta::check(&fixture.0).is_valid());
    assert_eq!(snapshot("demo.rule"), original);
    assert_eq!(snapshot("demo.retired"), retired);
    fixture.start();
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    assert_eq!(snapshot("demo.retired"), retired);
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::completed_corrupt_records_and_invalid_layout_cannot_pass

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.validation_layout)]
#[sage::test(meta.reviews.output_format)]
#[sage::test(meta.reviews.review_diagnostics)]
fn completed_corrupt_records_and_invalid_layout_cannot_pass() {
    for fault in [
        "malformed",
        "blank reviewer",
        "blank report",
        "blank edit",
        "extra field",
        "missing summary",
        "missing input",
        "missing output",
        "non-directory",
    ] {
        let fixture = Fixture::new();
        fixture.approve();
        let directory = fixture.0.join("validations/demo.rule");
        match fault {
            "malformed" => fixture.write("validations/demo.rule/output.json", "{"),
            "missing summary" => std::fs::remove_file(directory.join("summary.json")).unwrap(),
            "missing input" => std::fs::remove_file(directory.join("input.json")).unwrap(),
            "missing output" => std::fs::remove_file(directory.join("output.json")).unwrap(),
            "non-directory" => {
                fixture.write("validations/unexpected", "not a validation directory")
            }
            _ => {
                let mut output = serde_json::to_value(Fixture::report()).unwrap();
                match fault {
                    "blank reviewer" => output["reviewer"] = " ".into(),
                    "blank report" => output["report"] = "\n".into(),
                    "blank edit" => output["requested_edits"] = serde_json::json!([""]),
                    _ => output["outcome"] = true.into(),
                }
                fixture.write(
                    "validations/demo.rule/output.json",
                    &serde_json::to_string(&output).unwrap(),
                );
            }
        }
        assert!(!sage_meta::check(&fixture.0).is_valid(), "{fault}");
        let output = fixture.run(&["check"]);
        assert!(!output.status.success(), "{fault}");
        let error = String::from_utf8_lossy(&output.stderr);
        let anchor = if fault == "non-directory" {
            "unexpected"
        } else {
            "demo.rule"
        };
        assert!(error.contains(anchor), "{error}");
        assert!(error.contains("invalid validation"), "{error}");
        assert!(error.contains("sage-review-checklist/SKILL.md"), "{error}");
        let reason = match fault {
            "malformed" => "EOF",
            "blank reviewer" | "blank report" => "nonblank reviewer and report",
            "blank edit" => "nonblank strings",
            "extra field" => "unknown field",
            "missing summary" | "missing input" | "missing output" => "No such file",
            "non-directory" => "not a real directory",
            _ => unreachable!(),
        };
        assert!(error.contains(reason), "{fault}: {error}");
    }
}
}

See more source ↗

Implemented sage_meta::diagnostics_identify_missing_unfinished_stale_and_requested_edit_reviews

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.review_diagnostics)]
#[sage::test(meta.reviews.record_required)]
fn diagnostics_identify_missing_unfinished_stale_and_requested_edit_reviews() {
    let fixture = Fixture::new();
    for state in ["missing", "unfinished", "stale", "requested edits"] {
        match state {
            "unfinished" => {
                fixture.start();
            }
            "stale" => {
                fixture.approve();
                fixture.write(
                    "src/behavior.rs",
                    "// {anchor}`demo.rule`\npub fn result() -> u32 { 5 }\n",
                );
            }
            "requested edits" => {
                fixture.start();
                let mut output = Fixture::report();
                output
                    .requested_edits
                    .push("Fix the implementation.".into());
                review::record(&fixture.0, "demo.rule", &output).unwrap();
            }
            _ => {}
        }
        let output = fixture.run(&["check"]);
        assert!(!output.status.success(), "{state}");
        let stderr = String::from_utf8_lossy(&output.stderr);
        assert!(stderr.contains("demo.rule"), "{stderr}");
        assert!(
            stderr.contains("sage-review-checklist/SKILL.md"),
            "{stderr}"
        );
        if matches!(state, "missing" | "unfinished") {
            assert!(stderr.contains(state), "{stderr}");
        }
        if state == "stale" {
            assert!(stderr.contains("src/behavior.rs"), "{stderr}");
        }
        if state == "requested edits" {
            assert!(stderr.contains("edit"), "{stderr}");
        }
    }
}
}

See more source ↗

Implemented sage_meta::incomplete_output_publication_never_satisfies_the_gate

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.record_required)]
#[sage::test(meta.reviews.gate)]
fn incomplete_output_publication_never_satisfies_the_gate() {
    let fixture = Fixture::new();
    fixture.start();
    // An output written before the summary records completion is incomplete.
    fixture.write(
        "validations/demo.rule/output.json",
        &serde_json::to_string(&Fixture::report()).unwrap(),
    );
    assert!(!sage_meta::check(&fixture.0).is_valid());
    fixture.approve();
    std::fs::remove_file(fixture.0.join("validations/demo.rule/output.json")).unwrap();
    assert!(!sage_meta::check(&fixture.0).is_valid());
    fixture.start();
    fixture.write("validations/demo.rule/output.json", "{bad json");
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::invalid_ids_and_paths_are_rejected_without_destroying_existing_reports

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.preparation)]
#[sage::test(meta.reviews.recorded_reads)]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.validation_layout)]
fn invalid_ids_and_paths_are_rejected_without_destroying_existing_reports() {
    let fixture = Fixture::new();
    fixture.approve();
    let output = std::fs::read(fixture.0.join("validations/demo.rule/output.json")).unwrap();
    for anchor in [
        "../escape",
        "/absolute",
        "demo/rule",
        "demo..rule",
        "demo.missing",
    ] {
        assert!(review::start(&fixture.0, anchor, vec![]).is_err());
        assert_eq!(
            output,
            std::fs::read(fixture.0.join("validations/demo.rule/output.json")).unwrap()
        );
    }
    assert!(
        review::capture_read(
            &fixture.0,
            "demo.missing",
            "src/tests.rs",
            Selector::WholeFile
        )
        .is_err()
    );
    fixture.start();
    let before = fixture.input();
    for path in ["../outside", "/etc/passwd", "missing.txt"] {
        assert!(review::capture_read(&fixture.0, "demo.rule", path, Selector::WholeFile).is_err());
        assert_eq!(fixture.input(), before);
    }
    assert!(
        review::capture_read(
            &fixture.0,
            "demo.rule",
            "src/tests.rs",
            Selector::Claim {
                anchor_id: "demo.rule".into()
            }
        )
        .is_err()
    );
    assert!(
        review::capture_read(
            &fixture.0,
            "demo.rule",
            "src/tests.rs",
            Selector::Test {
                crate_name: "demo".into(),
                target: "test:missing".into(),
                rust_path: "demo::tests::verifies_result".into()
            }
        )
        .is_err()
    );
    assert_eq!(fixture.input(), before);
}
}

See more source ↗

Implemented sage_meta::retired_records_fail_even_when_every_remaining_anchor_passes

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.review_diagnostics)]
fn retired_records_fail_even_when_every_remaining_anchor_passes() {
    let fixture = Fixture::new();
    fixture.approve();
    fixture.write("md/design/README.md", "# Retired\n");
    fixture.write("src/behavior.rs", "pub fn result() -> u32 { 4 }\n");
    fixture.write("src/tests.rs", "");
    let output = fixture.run(&["check"]);
    assert!(!output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("demo.rule"), "{stderr}");
    assert!(stderr.contains("remove"), "{stderr}");
    assert!(fixture.0.join("validations/demo.rule/output.json").exists());
    std::fs::remove_dir_all(fixture.0.join("validations/demo.rule")).unwrap();
    assert!(sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::unsupported_versions_and_mismatched_identity_cannot_pass

crates/sage-meta/tests/review.rs · test:review

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
#[sage::test(meta.reviews.summary_format)]
#[sage::test(meta.reviews.review_diagnostics)]
#[sage::test(meta.reviews.staleness)]
#[sage::test(meta.reviews.validation_layout)]
fn unsupported_versions_and_mismatched_identity_cannot_pass() {
    for field in ["schema_version", "policy_version", "anchor"] {
        let fixture = Fixture::new();
        fixture.approve();
        let mut summary = fixture.summary();
        summary[field] = if field == "anchor" {
            "demo.other".into()
        } else {
            999.into()
        };
        fixture.write(
            "validations/demo.rule/summary.json",
            &serde_json::to_string(&summary).unwrap(),
        );
        let report = sage_meta::check(&fixture.0);
        let error = report.ensure_valid().unwrap_err().to_string();
        assert!(error.contains("demo.rule"), "{error}");
        assert!(error.contains("sage-review-checklist/SKILL.md"), "{error}");
        let reason = if field == "anchor" {
            "does not match"
        } else {
            "unsupported schema/policy"
        };
        assert!(error.contains(reason), "{error}");
    }
}
}

See more source ↗

Implemented sage_meta::repository_docs_model_and_rust_correspond

crates/sage-meta/tests/workspace.rs · test:workspace

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.gate)]
fn repository_docs_model_and_rust_correspond() -> Result<(), sage_meta::check::CheckError> {
    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
    sage_meta::check(&root).ensure_valid()
}
}

See more source ↗

Review: Accepted · anchor_094 fresh final review.

Reviewed the complete gate claim, all four ordinary associated implementation files (review.rs, check.rs, main.rs and xtask/src/main.rs), and all nine ordinary associated tests. No TODO/N/A entries exist. Captured fixture helpers, Cargo aliases, CI workflow and the three explicitly referenced staleness/output_format/decisions claims.

The shared gate composes model, correspondence, specification and review validity. main::check calls the shared library check/check_model and ensure_valid; the Cargo meta alias invokes that binary. check_reviews constructs current inventory, loads saved records and runs review::validate. load_saved enumerates every validation directory rather than only current anchor IDs, checks real directory/summary/input layout, summary identity and schema/policy, and reads valid completed output only when completion metadata exists. Invalid entries become issues, not skipped approvals. review::validate rejects each current anchor's missing/unfinished/invalid/requested-edit output, current-input mismatches and absent test or implementation entries. acceptable uses the same current-version/input/completed-empty-edits conditions. Output deserialization rejects unexpected fields; blank reviewer/report/edit strings are invalid. Semantic report completeness remains the reviewer's responsibility under the referenced output claim, not a property the parser can prove from nonblank text.

Freshness includes the full initial claim/implementation/test inventory and metadata plus reread additional selectors, with exact content comparison. Structural specification coverage is checked before review success can contribute, and the review validator independently requires both association sets. Obsolete IDs from either loaded records or invalid-record issues are compared against the current anchor map and produce an explicit diagnostic naming validations/<id>/ and directing removal for retired rules or reconciliation and fresh review for renames. Neither validate nor record deletes those directories. Missing current records or obsolete-only inventories therefore fail even if all remaining anchors are accepted.

CI/workspace integration is concrete: the captured workflow invokes cargo xtask ci test, whose associated ci_test runs the same sage-meta check before cargo test --all --workspace. The associated repository_docs_model_and_rust_correspond Cargo test calls sage_meta::check(root).ensure_valid(), sharing the exact gate rather than reproducing its rules. Reading/checking loads records and computes diagnostics; only explicit review start/record writes lifecycle/approval state. This review does not assert a fresh CI execution occurred.

Tests: accepted_report_cannot_replace_missing_test_or_implementation_evidence removes each association independently after acceptance and asserts library and CLI failure naming the anchor. checking_is_read_only_and_recording_preserves_obsolete_records asserts checking a missing review creates no validations directory, accepted check leaves all record bytes unchanged, an obsolete record makes the gate fail while both directories remain byte-identical, and rerecording a current anchor leaves obsolete bytes untouched. retired_records_fail_even_when_every_remaining_anchor_passes removes the current claim/evidence, verifies CLI failure with its retired ID/removal guidance and preserved output, then verifies success only after explicit directory removal.

completed_corrupt_records_and_invalid_layout_cannot_pass exercises malformed output, blank fields/edits, extra fields, missing summary/input/output and a nondirectory entry. It asserts both library and CLI failure and identifies the relevant record, invalid-validation category, underlying reason and review skill. unsupported_versions_and_mismatched_identity_cannot_pass independently changes schema, policy and summary anchor and asserts targeted errors. incomplete_output_publication_never_satisfies_the_gate checks output-before-completion metadata, deleted completed output and malformed output cannot pass.

diagnostics_identify_missing_unfinished_stale_and_requested_edit_reviews verifies CLI failure for all four conditions, anchor/skill diagnostics and state-specific reason or stale source path. invalid_ids_and_paths_are_rejected_without_destroying_existing_reports checks invalid/traversing/unknown anchor starts preserve accepted output, and invalid source paths or wrong semantic selectors cannot mutate active saved inputs. The repository Cargo test directly uses the production ensure_valid gate as described above. Fixture helpers create real isolated source/model/claim packages and invoke production APIs/binary; the failure and preservation assertions are explicit in the test bodies.

These tests and source paths account for current and obsolete records, format/version/layout incompleteness, evidence requirements, freshness, decision outcomes, read-only checking and shared integration. No additional source edits or unresolved defect were found. This pass ran review start/read/record and source inspection only, not the behavioral suites or CI. Central suite results are coordinator context rather than independently executed evidence. Dependency capture is complete for this assessment. No requested edits.

Browse meta anchors

116 anchors

Specification anchors and declared coverage
AnchorImplementationTests
meta (116)102 Implemented24 TODO103 Implemented36 TODO
meta.anchors (22)22 Implemented21 Implemented12 TODO
anchor_pagesImplementedImplementedTODO
book_explorerImplementedImplementedTODO
canonical_sourcesImplementedImplementedTODO
meta.anchors.content (7)7 Implemented7 Implemented
blocksImplementedImplemented
explicit_endImplementedImplemented
headingImplementedImplemented
literal_syntaxImplementedImplemented
next_anchorImplementedImplemented
source_endImplementedImplemented
unmatched_endImplementedImplemented
context_navigationImplementedImplementedTODO
evidence_statusImplementedImplementedTODO
explorer_navigationImplementedTODO
implementation_coverageImplementedImplementedTODO
implementation_referencesImplementedImplementedTODO
placeholder_statusImplementedImplementedTODO
point_excerptsImplementedImplementedTODO
region_balanceImplementedImplemented
region_excerptsImplementedImplementedTODO
test_coverageImplementedImplemented
test_referencesImplementedImplemented
unique_namesImplementedImplementedTODO
meta.book (21)10 Implemented18 TODO12 Implemented18 TODO
anchor_movesImplementedTODOImplementedTODO
authorityImplementedTODOImplementedTODO
browser_deliveryTODOImplementedTODO
browser_dependenciesTODOTODO
browser_rust_sourceTODOTODO
browser_searchTODOTODO
browser_serveTODOTODO
browser_structureTODOTODO
chapter_namesImplementedTODOImplementedTODO
crate_ownershipImplementedImplemented
crates_landingImplementedImplemented
entity_linksTODOTODO
index_groupsImplementedTODOImplementedTODO
index_namespace_pagesImplementedImplemented
index_rowsImplementedTODOImplementedTODO
index_statusImplementedTODOImplementedTODO
rfd_changesTODOTODO
sage_chaptersTODOImplementedTODO
self_descriptionTODOTODO
shared_modelImplementedTODOImplementedTODO
source_rolesTODOTODO
meta.contracts (4)4 Implemented3 TODO4 Implemented3 TODO
cache_invocationsImplementedTODOImplementedTODO
correspondenceImplementedImplemented
observation_coverageImplementedTODOImplementedTODO
validated_sessionImplementedTODOImplementedTODO
meta.language (39)39 Implemented39 Implemented
meta.language.calls (2)2 Implemented2 Implemented
declaredImplementedImplemented
forbiddenImplementedImplemented
meta.language.classes (3)3 Implemented3 Implemented
abstract_completeImplementedImplemented
override_signatureImplementedImplemented
single_inheritanceImplementedImplemented
meta.language.contexts (1)1 Implemented1 Implemented
inheritanceImplementedImplemented
meta.language.envelopes (7)7 Implemented7 Implemented
class_callsImplementedImplemented
createsImplementedImplemented
direct_callsImplementedImplemented
leafImplementedImplemented
permissionsImplementedImplemented
readsImplementedImplemented
receiver_callsImplementedImplemented
meta.language.fields (2)2 Implemented2 Implemented
context_stateImplementedImplemented
kindsImplementedImplemented
meta.language.methods (2)2 Implemented2 Implemented
kindsImplementedImplemented
proseImplementedImplemented
meta.language.model (3)3 Implemented3 Implemented
forbidden_pathsImplementedImplemented
inherited_prohibitionsImplementedImplemented
virtual_dispatchImplementedImplemented
meta.language.types (19)19 Implemented19 Implemented
argument_arityImplementedImplemented
declaration_proseImplementedImplemented
enum_variantsImplementedImplemented
field_proseImplementedImplemented
generic_parametersImplementedImplemented
member_commasImplementedImplemented
name_resolutionImplementedImplemented
opaque_representationImplementedImplemented
preludeImplementedImplemented
qualified_namesImplementedImplemented
recursive_valuesImplementedImplemented
struct_fieldsImplementedImplemented
tuplesImplementedImplemented
type_expressionsImplementedImplemented
unique_fieldsImplementedImplemented
unique_parametersImplementedImplemented
unique_variantsImplementedImplemented
unknown_namesImplementedImplemented
variant_proseImplementedImplemented
meta.reviews (27)27 Implemented27 Implemented
claim_textImplementedImplemented
complete_test_setImplementedImplemented
decisionsImplementedImplemented
fragment_associationsImplementedImplemented
fragment_formatImplementedImplemented
fragment_freshnessImplementedImplemented
gateImplementedImplemented
input_formatImplementedImplemented
input_fragmentsImplementedImplemented
output_formatImplementedImplemented
preparationImplementedImplemented
record_requiredImplementedImplemented
recorded_readsImplementedImplemented
recordingImplementedImplemented
review_delegationImplementedImplemented
review_diagnosticsImplementedImplemented
review_instructionsImplementedImplemented
review_scopeImplementedImplemented
selector_claimImplementedImplemented
selector_line_rangeImplementedImplemented
selector_testImplementedImplemented
selector_whole_fileImplementedImplemented
source_representationImplementedImplemented
stalenessImplementedImplemented
summary_formatImplementedImplemented
test_sourceImplementedImplemented
validation_layoutImplementedImplemented
meta.validation (3)3 TODO3 TODO
claim_specific_evidenceTODOTODO
independent_inspectionTODOTODO
review_packetsTODOTODO