meta.reviews.recording

Recording takes a completed report in the format defined by meta.reviews.output_format and an anchor with an active unfinished review. It checks the inputs already stored in that anchor’s directory against current source using meta.reviews.fragment_freshness and meta.reviews.fragment_associations, and verifies the anchor and version metadata. Missing or stale inputs, an unknown anchor, an invalid report, or an absent active review rejects recording. A changed input requires a new review starting with cargo meta review start; recording never substitutes new source text for the inputs the agent actually reviewed.

On success, recording writes output.json and updates the summary’s recording time, preserving input.json exactly. Other anchors’ records are unchanged. A completed report requesting edits is saved but cannot satisfy the gate under meta.reviews.decisions. Incomplete publication cannot satisfy the gate; readers must not accept a mixture of files from different review attempts.

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

Implementation

Implemented crates/sage-meta/src/review.rs:581–586

sage_meta::review · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.recording`
pub fn record(
    workspace: &Path,
    anchor: &str,
    output: &ValidationOutput,
) -> Result<(), Box<dyn Error>> {

}

See more source ↗

Implemented crates/sage-meta/src/main.rs:102–107

sage_meta · bin:sage-meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.recording`
// {anchor}`meta.reviews.review_instructions`
fn review(args: &[std::ffi::OsString]) -> Result<(), Box<dyn std::error::Error>> {
    use sage_meta::review::{self, Selector, ValidationOutput};
    let args = args
        .iter()

}

See more source ↗

Tests and review

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

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::cli_start_and_record_roundtrip_exact_saved_input

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.preparation)]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.review_instructions)]
fn cli_start_and_record_roundtrip_exact_saved_input() {
    let fixture = Fixture::new();
    fixture.write(
        "instructions.txt",
        "Inspect the edge cases.\nPreserve these instructions.",
    );
    let output = fixture.run(&[
        "review",
        "start",
        "demo.rule",
        "--instructions",
        "instructions.txt",
    ]);
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let input: ReviewInput = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(input, fixture.input());
    assert_eq!(
        input.coordinator_instructions,
        ["Inspect the edge cases.\nPreserve these instructions."]
    );
    fixture.write(
        "report.json",
        &serde_json::to_string(&Fixture::report()).unwrap(),
    );
    let output = fixture.run(&["review", "record", "demo.rule", "report.json"]);
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(fixture.run(&["check"]).status.success());
    assert!(
        !fixture
            .run(&["review", "record", "demo.rule"])
            .status
            .success()
    );
}
}

See more source ↗

Implemented sage_meta::disappeared_or_invalidated_additional_fragments_reject_recording

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.fragment_freshness)]
#[sage::test(meta.reviews.recording)]
fn disappeared_or_invalidated_additional_fragments_reject_recording() {
    for range in [false, true] {
        let fixture = Fixture::new();
        fixture.start();
        fixture.write("dependency.txt", "first\nsecond\n");
        let selector = if range {
            Selector::LineRange { start: 2, end: 2 }
        } else {
            Selector::WholeFile
        };
        review::capture_read(&fixture.0, "demo.rule", "dependency.txt", selector).unwrap();
        let saved = std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap();
        if range {
            fixture.write("dependency.txt", "first\n");
        } else {
            std::fs::remove_file(fixture.0.join("dependency.txt")).unwrap();
        }
        let error = review::record(&fixture.0, "demo.rule", &Fixture::report())
            .unwrap_err()
            .to_string();
        assert!(error.contains("dependency.txt"), "{error}");
        assert!(!fixture.0.join("validations/demo.rule/output.json").exists());
        assert_eq!(
            saved,
            std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap()
        );
        assert!(!sage_meta::check(&fixture.0).is_valid());
    }
}
}

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_reports_and_stale_inputs_never_complete_an_active_review

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.output_format)]
#[sage::test(meta.reviews.decisions)]
#[sage::test(meta.reviews.input_fragments)]
#[sage::test(meta.reviews.fragment_freshness)]
#[sage::test(meta.reviews.record_required)]
#[sage::test(meta.reviews.staleness)]
fn invalid_reports_and_stale_inputs_never_complete_an_active_review() {
    let fixture = Fixture::new();
    assert!(review::record(&fixture.0, "demo.rule", &Fixture::report()).is_err());
    fixture.start();
    for field in ["reviewer", "report", "edit"] {
        let mut output = Fixture::report();
        match field {
            "reviewer" => output.reviewer = "  ".into(),
            "report" => output.report.clear(),
            _ => output.requested_edits = vec!["\n".into()],
        }
        assert!(review::record(&fixture.0, "demo.rule", &output).is_err());
        assert!(!fixture.0.join("validations/demo.rule/output.json").exists());
    }
    let before = std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap();
    fixture.write(
        "src/behavior.rs",
        "// {anchor}`demo.rule`\npub fn result() -> u32 { 5 }\n",
    );
    assert!(review::record(&fixture.0, "demo.rule", &Fixture::report()).is_err());
    assert_eq!(
        before,
        std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap()
    );
    assert!(!sage_meta::check(&fixture.0).is_valid());
    fixture.start();
    let mut output = Fixture::report();
    output.requested_edits =
        vec!["Return four and add an assertion against the implementation.".into()];
    review::record(&fixture.0, "demo.rule", &output).unwrap();
    assert_eq!(
        review::load_saved(&fixture.0.join("validations"))
            .unwrap()
            .reviews[0]
            .output
            .as_ref(),
        Some(&output)
    );
    assert!(!sage_meta::check(&fixture.0).is_valid());
    let json: serde_json::Value = serde_json::from_slice(
        &std::fs::read(fixture.0.join("validations/demo.rule/output.json")).unwrap(),
    )
    .unwrap();
    assert_eq!(json.as_object().unwrap().len(), 3);
    assert!(json.get("decision").is_none());
    assert!(json.get("outcome").is_none());
}
}

See more source ↗

Implemented sage_meta::record_rejects_invalid_active_identity_and_changed_associations

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.recording)]
fn record_rejects_invalid_active_identity_and_changed_associations() {
    for fault in [
        "unknown anchor",
        "missing input",
        "anchor",
        "schema_version",
        "policy_version",
        "test cfg",
    ] {
        let fixture = Fixture::new();
        let initial = fixture.start();
        let directory = fixture.0.join("validations/demo.rule");
        let anchor = match fault {
            "unknown anchor" => "demo.unknown",
            "missing input" => {
                std::fs::remove_file(directory.join("input.json")).unwrap();
                "demo.rule"
            }
            "test cfg" => {
                fixture.write(
                    "src/lib.rs",
                    "#[sage::item(crate)] mod model {}\nmod behavior;\n#[cfg(unix)] mod tests;\n",
                );
                // The test text stays identical; only its enclosing cfg changes.
                let spec = sage_meta::check(&fixture.0);
                assert!(!spec.is_valid());
                assert_eq!(fixture.input(), initial);
                "demo.rule"
            }
            field => {
                let mut summary = fixture.summary();
                summary[field] = if field == "anchor" {
                    "demo.other".into()
                } else {
                    0.into()
                };
                std::fs::write(
                    directory.join("summary.json"),
                    serde_json::to_vec(&summary).unwrap(),
                )
                .unwrap();
                "demo.rule"
            }
        };
        assert!(
            review::record(&fixture.0, anchor, &Fixture::report()).is_err(),
            "{fault}"
        );
        assert!(!directory.join("output.json").exists(), "{fault}");
        assert!(
            fixture.summary()["recorded_at_unix_seconds"].is_null(),
            "{fault}"
        );
        assert!(!sage_meta::check(&fixture.0).is_valid(), "{fault}");
    }
}
}

See more source ↗

Implemented sage_meta::restarting_one_anchor_leaves_other_anchor_record_unchanged

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.preparation)]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.record_required)]
fn restarting_one_anchor_leaves_other_anchor_record_unchanged() {
    let fixture = Fixture::new();
    fixture.write(
        "md/design/README.md",
        &format!("{CLAIM}\n{{anchor}}`demo.other`\nAnother claim.\n"),
    );
    fixture.write("src/behavior.rs", "// {anchor}`demo.rule`\npub fn result() -> u32 { 4 }\n// {anchor}`demo.other`\npub fn other() -> u32 { 4 }\n");
    fixture.write(
        "src/tests.rs",
        &format!("{TEST}\n#[test] #[sage::test(demo.other)] fn other() {{ assert_eq!(4, 4); }}"),
    );
    fixture.approve();
    review::start(&fixture.0, "demo.other", vec![]).unwrap();
    review::record(&fixture.0, "demo.other", &Fixture::report()).unwrap();
    assert!(sage_meta::check(&fixture.0).is_valid());
    let before: Vec<_> = ["summary.json", "input.json", "output.json"]
        .map(|file| std::fs::read(fixture.0.join("validations/demo.other").join(file)).unwrap())
        .into();
    fixture.start();
    assert!(!sage_meta::check(&fixture.0).is_valid());
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    for (file, bytes) in ["summary.json", "input.json", "output.json"]
        .into_iter()
        .zip(before)
    {
        assert_eq!(
            bytes,
            std::fs::read(fixture.0.join("validations/demo.other").join(file)).unwrap()
        );
    }
    assert!(sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::start_invalidates_previous_success_and_record_is_required

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.validation_layout)]
#[sage::test(meta.reviews.summary_format)]
#[sage::test(meta.reviews.preparation)]
#[sage::test(meta.reviews.record_required)]
#[sage::test(meta.reviews.recorded_reads)]
#[sage::test(meta.reviews.recording)]
#[sage::test(meta.reviews.decisions)]
fn start_invalidates_previous_success_and_record_is_required() {
    let fixture = Fixture::new();
    assert!(!sage_meta::check(&fixture.0).is_valid());
    fixture.approve();
    assert!(sage_meta::check(&fixture.0).is_valid());
    let input = fixture.start();
    assert_eq!(fixture.input(), input);
    let summary = fixture.summary();
    assert_eq!(summary["anchor"], "demo.rule");
    assert!(summary["started_at_unix_seconds"].as_u64().unwrap() > 0);
    assert!(summary["recorded_at_unix_seconds"].is_null());
    assert_eq!(summary["schema_version"], review::SCHEMA_VERSION);
    assert_eq!(summary["policy_version"], review::POLICY_VERSION);
    assert!(summary.get("input_sha256").is_none());
    assert!(!fixture.0.join("validations/demo.rule/output.json").exists());
    assert!(!sage_meta::check(&fixture.0).is_valid());
    let saved = review::load_saved(&fixture.0.join("validations")).unwrap();
    assert_eq!(saved.reviews.len(), 1);
    assert!(saved.reviews[0].output.is_none());
    fixture.write("helper.txt", "context\n");
    review::capture_read(&fixture.0, "demo.rule", "helper.txt", Selector::WholeFile).unwrap();
    assert!(!sage_meta::check(&fixture.0).is_valid());
    let bytes = std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap();
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    assert_eq!(
        bytes,
        std::fs::read(fixture.0.join("validations/demo.rule/input.json")).unwrap()
    );
    assert!(
        fixture.summary()["recorded_at_unix_seconds"]
            .as_u64()
            .unwrap()
            >= summary["started_at_unix_seconds"].as_u64().unwrap()
    );
    assert!(sage_meta::check(&fixture.0).is_valid());
    assert!(review::record(&fixture.0, "demo.rule", &Fixture::report()).is_err());
    assert!(
        review::capture_read(&fixture.0, "demo.rule", "helper.txt", Selector::WholeFile).is_err()
    );
}
}

See more source ↗

Review: Accepted · anchor_094 fresh final review.

Reviewed the complete recording claim, both ordinary implementation files (main.rs and review.rs) and all eight ordinary associated tests. No TODO/N/A evidence exists. Captured fixture helpers and all four explicitly referenced format/freshness/association/decision claims.

The CLI record branch requires anchor and report-file arguments, deserializes the strict ValidationOutput and calls the shared record API. record rejects invalid output before publication, rebuilds the current valid inventory, requires the requested anchor to exist, locates its safe validation directory and locks the validations directory. read_summary checks a real directory, matching anchor ID and supported schema/policy. Recording requires an unfinished review: a recorded timestamp or existing output rejects it. Missing input or summary is an error. It compares stored input against the freshly built inventory through input_errors, including association metadata and initial fragments plus selector-resolved additional reads. Changed context produces an error requiring a fresh start, never replacement of reviewed text.

On success only output.json and summary.json are written; input.json is read but never rewritten. output_error enforces valid nonblank supplied fields, while semantic report completeness is the reviewer's responsibility under the linked output claim. Concrete requested edits are allowed to be saved, but acceptable/validate reject them for gate success. A successful record therefore means completed reporting, not necessarily acceptance.

Publication uses an exclusive OS lock on the existing validations-directory inode for start/capture/record and load_saved readers. start removes the old anchor directory before publishing fresh input/summary. write_json uses a unique temporary sibling and rename for each file; record writes output first and only then sets completion time. load_saved treats an output as complete only when summary completion metadata exists, so a process interrupted before the final summary write cannot approve a partial result. Locking prevents cooperative readers from observing an interleaving of review file operations, and start's removal prevents files from an older attempt standing in for the new one. The claim does not establish a transaction over arbitrary concurrent edits to external source files; later source changes are handled by freshness validation.

Tests: cli_start_and_record_roundtrip_exact_saved_input invokes real CLI start with multiline instructions, verifies printed/saved inputs match, records a report file, checks successful gate and rejects an incomplete record command. start_invalidates_previous_success_and_record_is_required checks active/restarted status, absence of old output, captured-read noncompletion, byte-identical input across record, populated recording time and refusal to record/read after completion. invalid_reports_and_stale_inputs_never_complete_an_active_review rejects absent active review, blank output fields and changed initial implementation source, preserves saved input bytes, then verifies exact storage of an edit-requesting report while the gate stays failing.

record_rejects_invalid_active_identity_and_changed_associations exercises unknown anchor, missing input, summary identity, schema and policy mismatches, and a cfg metadata change with identical test text. Every case must reject without output or recording time and remain invalid. disappeared_or_invalidated_additional_fragments_reject_recording removes an additional WholeFile dependency or makes a captured range out of bounds, checking named errors, absent output and unchanged input. incomplete_output_publication_never_satisfies_the_gate covers output before completion metadata, missing completed output and malformed partial output; each is rejected by the gate.

restarting_one_anchor_leaves_other_anchor_record_unchanged uses two accepted anchors and checks all three files of the untouched anchor byte-for-byte across restart/record of the other. checking_is_read_only_and_recording_preserves_obsolete_records additionally proves recording a current anchor does not prune or modify an obsolete directory, which continues to fail validation until separately reconciled. These are direct assertions over record lifecycle and bytes, not helper names. Fixture helpers create real isolated Cargo/model/claim inputs and invoke production APIs/binary.

All specified failure classes, stored-input preservation, completion semantics, other-anchor isolation and incomplete-publication rejection are accounted for by source and tests. No source changes or unresolved defect were found. This pass ran review start/read/record and source inspection only; centrally run behavioral suites were not repeated or claimed as independent execution. Dependency capture is complete. 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