Struct Args 

pub struct Args {
    pub mem_name: String,
    pub observations: Option<PathBuf>,
}

Verify every anchor in a mem against its declared source. Per anchor: resolves (source present, hash matches), drifted (present, hash differs, stability says drifted), recheck (hash differs under unstable, or a hash is missing on either side), unresolvable (the source artifact is GONE: a measured failure), or unobserved (the pass could not observe the anchor at all, so nothing about it was measured) — honestly, never fabricating a state. The last two shared one bucket until consistency-sweep 03/05, which is why this surface, the one you reach without a binding, could not tell a measured failure from an absent measurement. Works on a hand-authored mem with no binding at all; on a binding-backed mem it reports the same states the binding verify sees (one shared resolution mechanism). No entity changes; findings are recorded for the measured conditions only, since a finding asserts something that was measured.

A row whose ENTITY the mem no longer holds is reported as dangling, its own class beside the states above: those describe the artifact end, and a vanished entity says nothing about the source. Nothing repairs it. Where the entity end could not be reconciled at all, the output says so rather than showing clean counts over state it never examined.

The counts never travel alone: every rendering states the population they were computed over and whether the axis was fully_adjudicated, because a resolution figure read on its own is read as health. A sidecar the engine cannot read is a typed refusal (ANCHORS_SIDECAR_UNREADABLE, the mem and the parse reason named, fully_adjudicated: false in its details), never zero rows: nothing is recorded for a pass that measured nothing.

Fields

mem_name: String

Which mem to verify (by name).

observations: Option<PathBuf>

JSON file of observer-supplied observations for the anchors the engine cannot observe itself (url grain; the engine never fetches). Either a bare array or {"observations": [...]}; each row is {"artifact": "<url>", "hash": "<prepared-content hash>" | "content": "<retrieved text>" | "absent": true, "observed_at": "<ISO-8601>"?} — exactly one of hash / content / absent, observed_at defaulting to now. content is hashed under the same rule the write path applies to an anchor’s content. A url row with a supplied observation adjudicates like a file anchor (equal hash resolves, differing hash drifted under stable and recheck under unstable, absent → recheck); a url row without one stays unobserved. Matched observations are recorded on the sidecar rows as last_observed, so later runs and every anchor surface show how long each row has gone unobserved. Rows naming no url anchor of the mem are reported as unmatched and change nothing. A malformed row refuses the whole run with INVALID_OBSERVATION before any state changes.

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl CommandFactory for Args

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Args

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Args

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.