meta.reviews.fragment_freshness

Recording and checking resolve every fragment’s selector against current source and compare the selected text with the saved text using exact string equality. A missing or ambiguous selection, invalid selector, or changed selected text makes the validation stale or invalid. No selector kind or input origin bypasses these checks.

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

Implementation

Implemented crates/sage-meta/src/review.rs:383–388

sage_meta::review · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.fragment_freshness`
pub fn input_errors(workspace: &Path, saved: &ReviewInput, current: &ReviewInput) -> Vec<String> {
    let mut errors = Vec::new();
    if saved.prompt != current.prompt {
        errors.push("verification prompt changed".into());
    }

}

See more source ↗

Tests and review

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

Implemented sage_meta::ambiguous_initial_test_selector_cannot_be_recorded_as_complete_context

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.selector_test)]
#[sage::test(meta.reviews.fragment_freshness)]
fn ambiguous_initial_test_selector_cannot_be_recorded_as_complete_context() {
    let fixture = Fixture::new();
    fixture.write(
        "src/tests.rs",
        &format!(
            "#[cfg(unix)]\n{TEST}\n#[cfg(windows)]\n{}",
            TEST.replace("2 + 2", "1 + 3")
        ),
    );
    // One target/path identity resolves to two distinct annotated function spans.
    // Initial context must reject the ambiguity just as an explicit read does.
    match review::start(&fixture.0, "demo.rule", vec![]) {
        Err(_) => {}
        Ok(input) => {
            assert_eq!(input.tests.len(), 2);
            assert!(
                review::record(&fixture.0, "demo.rule", &Fixture::report()).is_err(),
                "recording must reject an ambiguous initial selector, not silently keep one function body"
            );
        }
    }
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::ambiguous_test_identity_across_anchors_is_rejected

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.selector_test)]
#[sage::test(meta.reviews.fragment_freshness)]
fn ambiguous_test_identity_across_anchors_is_rejected() {
    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`\nfn result() {}\n// {anchor}`demo.other`\nfn other() {}\n",
    );
    fixture.write(
        "src/tests.rs",
        &format!(
            "#[cfg(unix)]\n{TEST}\n#[cfg(windows)]\n{}",
            TEST.replace("demo.rule", "demo.other")
        ),
    );
    assert!(
        review::start(&fixture.0, "demo.rule", vec![]).is_err(),
        "a selector is ambiguous even when its conflicting function is associated with a different anchor"
    );
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::another_anchors_test_read_tracks_body_and_identity

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.fragment_freshness)]
#[sage::test(meta.reviews.selector_test)]
#[sage::test(meta.reviews.recorded_reads)]
fn another_anchors_test_read_tracks_body_and_identity() {
    for change in ["body", "missing", "ambiguous"] {
        let fixture = Fixture::new();
        fixture.write(
            "md/design/README.md",
            &format!("{CLAIM}\n{{anchor}}`demo.other`\nOther scenario.\n"),
        );
        fixture.write("src/behavior.rs", "// {anchor}`demo.rule`\npub fn result() -> u32 { 4 }\n// {anchor}`demo.other`\npub fn other() -> u32 { 5 }\n");
        let other = "#[test] #[sage::test(demo.other)] fn other() { assert_eq!(2 + 3, 5); }";
        fixture.write("src/tests.rs", &format!("{TEST}\n{other}"));
        let initial = fixture.start();
        let selector = Selector::Test {
            crate_name: "demo".into(),
            target: "lib:demo".into(),
            rust_path: "demo::tests::other".into(),
        };
        assert_eq!(
            review::capture_read(&fixture.0, "demo.rule", "src/tests.rs", selector).unwrap(),
            other
        );
        let changed = match change {
            "body" => other.replace("2 + 3", "1 + 4"),
            "missing" => other.replace("fn other()", "fn renamed()"),
            _ => format!("#[cfg(unix)] {other}\n#[cfg(windows)] {other}"),
        };
        fixture.write(
            "src/tests.rs",
            &format!("// unrelated line\n{TEST}\n{changed}"),
        );
        if change != "ambiguous" {
            let spec = sage_meta::spec::SpecIndex::load_workspace(&fixture.0).unwrap();
            let rust = sage_meta::correspondence::CorrespondenceIndex::load(&fixture.0).unwrap();
            let current = review::inventory(&spec, &rust).unwrap();
            assert_eq!(initial.fragments, current["demo.rule"].fragments);
            assert_eq!(initial.tests, current["demo.rule"].tests);
        }
        assert!(
            review::record(&fixture.0, "demo.rule", &Fixture::report()).is_err(),
            "{change}"
        );
        assert!(!fixture.0.join("validations/demo.rule/output.json").exists());
    }
}
}

See more source ↗

Implemented sage_meta::declared_claim_read_tracks_selected_text_without_capturing_the_document

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.selector_claim)]
#[sage::test(meta.reviews.fragment_freshness)]
#[sage::test(meta.reviews.recorded_reads)]
fn declared_claim_read_tracks_selected_text_without_capturing_the_document() {
    let fixture = Fixture::new();
    fixture.start();
    let text = review::capture_read(
        &fixture.0,
        "demo.rule",
        "md/design/README.md",
        Selector::Claim {
            anchor_id: "demo.rule".into(),
        },
    )
    .unwrap();
    assert_eq!(text, "The result is four.");
    let input = fixture.input();
    assert_eq!(input.fragments.last().unwrap().contents.join("\n"), text);
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    fixture.write(
        "md/design/README.md",
        &format!("# An unrelated heading\n\n{CLAIM}"),
    );
    assert!(sage_meta::check(&fixture.0).is_valid());
    fixture.write("md/design/README.md", &CLAIM.replace("four", "five"));
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

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

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.test_source)]
#[sage::test(meta.reviews.selector_test)]
#[sage::test(meta.reviews.staleness)]
#[sage::test(meta.reviews.fragment_associations)]
#[sage::test(meta.reviews.input_format)]
#[sage::test(meta.reviews.fragment_freshness)]
fn test_selector_preserves_metadata_and_ignores_unrelated_line_movement() {
    let fixture = Fixture::new();
    fixture.write(
        "src/tests.rs",
        &format!("#[cfg(unix)]\nmod nested {{\n{TEST}\n}}\n"),
    );
    let input = fixture.start();
    let test = &input.tests[0];
    assert_eq!(test.crate_name, "demo");
    assert_eq!(test.target, "lib:demo");
    assert_eq!(test.rust_path, "demo::tests::nested::verifies_result");
    assert_eq!(test.file, "src/tests.rs");
    assert!(test.cfg.iter().any(|cfg| cfg.contains("unix")));
    assert!(test.cfg.iter().any(|cfg| cfg.contains("test")));
    assert_eq!(test.status, TestStatus::Ordinary);
    let selector = Selector::Test {
        crate_name: test.crate_name.clone(),
        target: test.target.clone(),
        rust_path: test.rust_path.clone(),
    };
    assert_eq!(
        review::capture_read(&fixture.0, "demo.rule", "src/tests.rs", selector).unwrap(),
        TEST
    );
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    fixture.write(
        "src/tests.rs",
        &format!("// Unrelated\n\n#[cfg(unix)]\nmod nested {{\n{TEST}\n}}\n"),
    );
    assert!(sage_meta::check(&fixture.0).is_valid());
    fixture.write(
        "src/tests.rs",
        &format!("#[cfg(windows)]\nmod nested {{\n{TEST}\n}}\n"),
    );
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Implemented sage_meta::whole_files_and_ranges_preserve_exact_line_endings_and_detect_selected_edits

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.selector_whole_file)]
#[sage::test(meta.reviews.selector_line_range)]
#[sage::test(meta.reviews.recorded_reads)]
#[sage::test(meta.reviews.fragment_freshness)]
#[sage::test(meta.reviews.input_format)]
#[sage::test(meta.reviews.input_fragments)]
#[sage::test(meta.reviews.source_representation)]
#[sage::test(meta.reviews.staleness)]
fn whole_files_and_ranges_preserve_exact_line_endings_and_detect_selected_edits() {
    let fixture = Fixture::new();
    fixture.start();
    fixture.write("helper.txt", "first\r\n\r\nthird\nlast");
    assert_eq!(
        review::capture_read(
            &fixture.0,
            "demo.rule",
            "helper.txt",
            Selector::LineRange { start: 1, end: 2 }
        )
        .unwrap(),
        "first\r\n\r\n"
    );
    assert_eq!(
        review::capture_read(
            &fixture.0,
            "demo.rule",
            "helper.txt",
            Selector::LineRange { start: 4, end: 4 }
        )
        .unwrap(),
        "last"
    );
    for (start, end) in [(0, 1), (3, 2), (1, 5), (5, 5)] {
        assert!(
            review::capture_read(
                &fixture.0,
                "demo.rule",
                "helper.txt",
                Selector::LineRange { start, end }
            )
            .is_err()
        );
    }
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    fixture.write("helper.txt", "first\r\n\r\nUNSELECTED\nlast");
    assert!(sage_meta::check(&fixture.0).is_valid());
    fixture.write("helper.txt", "changed\r\n\r\nthird\nlast");
    assert!(!sage_meta::check(&fixture.0).is_valid());
    fixture.start();
    for _ in 0..2 {
        assert_eq!(
            review::capture_read(&fixture.0, "demo.rule", "helper.txt", Selector::WholeFile)
                .unwrap(),
            "changed\r\n\r\nthird\nlast"
        );
    }
    let input = fixture.input();
    let tail = &input.fragments[input.fragments.len() - 2..];
    assert_eq!(tail[0], tail[1]);
    assert_eq!(tail[0].contents.join("\n"), "changed\r\n\r\nthird\nlast");
    review::record(&fixture.0, "demo.rule", &Fixture::report()).unwrap();
    fixture.write("helper.txt", "changed\r\n\r\nthird\nlast\n");
    assert!(!sage_meta::check(&fixture.0).is_valid());
}
}

See more source ↗

Review: Accepted · Codex /root/anchor_094.

Fresh final followup review of fragment_freshness. Saved/read previous complete report and inputs, started fresh and compared all initial fragments: claim, whole review.rs and all eight tests are unchanged. Recaptured fixture and check-stage helper unchanged. Located the prior intended finish_anchor helper after the preceding association-comment insertion and recaptured it at 418-434 instead of 417-433; exact contents are unchanged. No freshness behavior changed.

The full claim requires record and check to resolve every current selector and compare exact selected text, rejecting missing/ambiguous/invalid selections or changed text regardless of selector kind or input origin. The sole ordinary input_errors association compares fresh current inventory's initial fragment prefix and association metadata, then reselects every additional fragment and compares exact contents.join(newline). Current inventory reconstructs whole implementation files and complete claim/test selections and checks test identity ambiguity globally, including across anchors. WholeFile reads exact UTF-8 source; LineRange enforces inclusive one-based bounds and preserves CRLF/last-line distinctions; Claim resolves canonical ID/source and returns normalized claim text; Test requires exactly one distinct matching source span for its semantic identity. Missing/escaping paths and invalid inventory fail. record checks before completion; validate and acceptable use the same freshness path at checking time. No normalization beyond a selector's specified claim text substitutes for exact equality.

All eight unchanged ordinary tests remain substantive: ambiguous_initial_test_selector_cannot_be_recorded_as_complete_context rejects cfg-separated duplicate identities at start/record and gate; ambiguous_test_identity_across_anchors_is_rejected covers the global case; another_anchors_test_read_tracks_body_and_identity changes, renames or duplicates a separately read test and requires record failure without output even when initial inputs remain unchanged. declared_claim_read_tracks_selected_text_without_capturing_the_document asserts exact claim text, tolerates unrelated preceding heading and rejects changed selected prose. disappeared_or_invalidated_additional_fragments_reject_recording removes a WholeFile or invalidates a LineRange, requiring named errors, absent output, preserved input and failed check. invalid_reports_and_stale_inputs_never_complete_an_active_review rejects changed initial implementation content without rewriting captures. test_selector_preserves_metadata_and_ignores_unrelated_line_movement asserts exact function and metadata, survives unrelated line movement and rejects cfg changes. whole_files_and_ranges_preserve_exact_line_endings_and_detect_selected_edits checks CRLF/blank/unterminated lines, invalid bounds, outside-versus-selected edits, repeated exact reads and final-newline staleness.

Together the visible assertions cover record/check enforcement, all four selector kinds, initial/additional inputs and identity ambiguity. Captured fixture creates actual isolated source/model files and invokes production APIs; check helper confirms integration and finish_anchor defines selected claim normalization. No TODO/N/A associations or deferrals exist. The only actual delta is helper position after the marker, with exact intended contents verified; the full prior assessment remains justified. No source edits, builds or tests occurred; fresh review commands and source inspection only. 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