meta.reviews.decisions

An empty requested_edits list in a completed report means all aspects of the anchor are accounted for and no edits are required. A nonempty list means work remains and the validation cannot satisfy the gate. The reviewer must request edits for missing implementation or test coverage unless explicit TODO/N/A evidence adequately explains the gap.

Ordinary, todo, and not_applicable statuses are derived from the associated implementation and test entries. The report assesses all entries and their explanations. Accepting a justified deferral or inapplicability does not relabel it as implemented behavior; TODO/N/A remains visible in the evidence. An unfinished review has no completed output and cannot satisfy the gate, even if a draft edit list is empty.

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

Implementation

Implemented crates/sage-meta/src/check.rs:437–442

sage_meta::check · lib:sage_meta

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

}

See more source ↗

Implemented crates/sage-meta/src/evidence.rs:28–33

sage_meta::evidence · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.decisions`
// {anchor}`meta.book.index_status`
pub fn placeholder_status(module: &str) -> Result<EvidenceStatus, String> {
    let mut todo = false;
    let mut not_applicable = false;
    for component in module.split("::").skip(1) {

}

See more source ↗

Implemented crates/sage-meta/src/review.rs:652–657

sage_meta::review · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.reviews.decisions`
// {anchor}`meta.reviews.staleness`
pub fn acceptable<'a>(
    workspace: &Path,
    anchor: &str,
    input: &ReviewInput,

}

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_placeholder_reports_preserve_todo_and_na_evidence

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

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.reviews.decisions)]
#[sage::test(meta.reviews.review_scope)]
#[sage::test(meta.reviews.input_format)]
#[sage::test(meta.reviews.test_source)]
fn accepted_placeholder_reports_preserve_todo_and_na_evidence() {
    for (module, expected) in [
        ("todo", TestStatus::Todo),
        ("not_applicable", TestStatus::NotApplicable),
    ] {
        let fixture = Fixture::new();
        fixture.write("src/behavior.rs", &format!("mod {module} {{\n// {{anchor}}`demo.rule`\n// Deferred until the concrete backend exists; editorial for N/A.\nfn placeholder() {{}}\n}}"));
        fixture.write("src/tests.rs", &format!("mod {module} {{\n// Deferred until the concrete backend exists; editorial for N/A.\n#[test] #[sage::test(demo.rule)] fn placeholder() {{}}\n}}"));
        let input = fixture.start();
        assert_eq!(input.tests[0].status, expected);
        assert_eq!(input.implementations[0].status, expected);
        assert!(
            input.implementations[0]
                .explanation
                .as_ref()
                .unwrap()
                .contains("backend")
        );
        let mut output = Fixture::report();
        output.report = "The explicit placeholder explains why concrete evidence is unavailable and names its prerequisite. This accepts the stated gap, not implemented behavior.".into();
        review::record(&fixture.0, "demo.rule", &output).unwrap();
        let check = sage_meta::check(&fixture.0);
        assert!(check.is_valid());
        let stage = check.review.unwrap();
        assert_eq!(stage.approved, 0);
        assert_eq!(
            (stage.todo, stage.not_applicable),
            if module == "todo" { (1, 0) } else { (0, 1) }
        );
    }
}
}

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::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 · Codex /root/anchor_094.

Fresh final followup review of decisions. Saved/read the prior report and inputs, started fresh and recaptured all three dependencies. Every initial fragment (claim, three implementation files and three tests) is unchanged, as are fixture and reviewer checklist. The structural coverage dependency range now ends at 190 instead of 189 solely to include the added implementation_references association comment; comparison confirms no other difference. No decision behavior changed.

The full claim distinguishes completed acceptance (no requested edits), completed reports requiring work (nonempty edits), explicit justified TODO/N/A gaps, source-derived statuses without relabeling, all-entry reviewer assessment, and unfinished reviews which cannot pass. All three ordinary implementation entries remain sufficient. review::acceptable requires matching current inputs/versions, implementation and test associations, present valid nonblank output and an empty edit list. output_error rejects blank reviewer/report/edit strings. start removes prior completion, and record requires an active current snapshot before writing completed output. validate reports unfinished and requested-edit cases. Structural coverage independently checks both implementation and test inventories. The captured prompt/checklist require substantive all-aspect assessment and edits for unexplained gaps; semantic adequacy of prose remains reviewer judgment rather than a machine claim of proof.

Status is derived from associated source entries: evidence::placeholder_status maps enclosing TODO/N/A modules, excludes crate names and rejects conflicting ancestry. Inventory preserves status and explanation/source context; report acceptance cannot rewrite them. check_reviews keeps accepted TODO/N/A distinct from ordinary approval (TODO if any, N/A for all-N/A, otherwise ordinary), while individual evidence remains visible. The report schema has no separate decision/status override. The new dependency marker changes none of this.

All three ordinary tests were reassessed. accepted_placeholder_reports_preserve_todo_and_na_evidence exercises both modules, asserts test/implementation statuses and retained prerequisite explanation, records an honest deferral report, and requires a passing gate with zero ordinary approvals and the correct deferred/N/A count. invalid_reports_and_stale_inputs_never_complete_an_active_review rejects no-start and blank reports without output, rejects source mutation without rewriting inputs, then records concrete requested edits and verifies exact persisted output with failing gate and only the three allowed fields. start_invalidates_previous_success_and_record_is_required covers missing review, accepted review, restart clearing output/time, continued failure during reads, success only after record, preserved input bytes and refusal of duplicate record/postcompletion reads. The captured fixture invokes real review/check APIs, with direct assertions in tests. Fixture placeholders are test data; no TODO/N/A evidence or deferral exists for decisions itself.

All full-claim requirements remain supported after comparing the actual one-comment dependency delta against the prior complete assessment. No source edits, build or tests were performed; fresh review commands and source inspection only. No requested edits.

Browse meta anchors

116 anchors

Anchor Implementation Tests

meta (116) 102 Implemented24 TODO 103 Implemented36 TODO

meta.anchors (22) 22 Implemented 21 Implemented12 TODO

anchor_pages Implemented ImplementedTODO

Every specification anchor has a stable page identifying the rule and showing its definition, context, implementation entries, and tests/evidence. The page includes Rust excerpts and access to surrounding source, and exposes each entry’s placeholder status and explanation. Multiple sites remain individually inspectable rather than being reduced to a single coverage badge.

Symposiun AGentic Environment (SAGE)

meta.reviews.decisions

Implementation

Tests and review