Struct Args 

pub struct Args {
    pub include: Vec<String>,
    pub target_schema: Option<String>,
    pub limit: usize,
    pub strict: bool,
}

Graph health summary.

Default: counts only. Pass --include to drill into details.

Fields

include: Vec<String>

Opt heavy content into the response: orphans, stubs, most_connected, missing_fields, stale, dangling_links, tags, missing_required_outgoing, constraints (standing violations of declared schema constraints), conformance, integrity, config, anchors (per-mem counts of the standalone anchor-verification states, with unresolvable meaning the artifact is GONE and unobserved meaning the pass could not measure it, plus the population those counts cover), ledger (a FOLDER mem’s change ledger set against the markdown files beside it: entities the ledger records with no file, and files the ledger never mentions — read-only, it never writes or tidies a ledger line; git-branch mems are absent rather than clean, because their change set is a real two-tree diff and the divergence cannot arise), friction (the workspace-local refusal ledger’s summary — counts per typed refusal code and per verb, with per-code reason breakdowns where the code carries a closed engine-owned discriminator, whole-ledger plus a recent 24h window; local-only, values drawn from closed engine-defined vocabularies only), open_questions (per-mem composed worklist of what the holding does not know: stubs, anchors that are recheck, unresolvable (artifact gone), unobserved (not measured) or dangling (entity gone), unsatisfied constraints, dangling links, and a paired process mem’s open entries — negative findings separated as already-searched; capped per kind with an explicit more count), stale_derivations (per-mem derivation edges whose target changed since the recorded baseline, plus unbaselined edges — re-assert via memstead relate to refresh), checks (per-mem counts of the four derived check states plus the author≠checker independence gate: self_checked / confirmed_independent / unconfirmable — transport is not identity, so until a caller-declared identity exists every ok-checked entity reports unconfirmable; the other two categories are explicit empties), signals (entities whose declared aggregate signals sit above none, each with value, level and contributing entity ids, plus per-level counts; warn-level signals participate in --strict, notice never does), labelling (grounded labels per declaring mem: accepted/defeated/undecided counts, the defeated and undecided lists with their attacker evidence, and the excluded cross-mem attack-edge count; an observation, never a strict violation). conformance lints every entity against the effective schema into a findings array (write-time typed codes); integrity adds the consistency axis (dangling links, stubs) to the same list. config renders the workspace-config projection (per-mem origin/storage/vcs detail, mutations, plugin) — the same block MCP’s include_config: true serves. Repeatable (--include K --include K) AND comma-string (--include K1,K2) forms both parse — uniform with memstead overview --include.

target_schema: Option<String>

Schema ref (name@x.y.z) the conformance/integrity includes lint against instead of each mem’s current pin.

limit: usize

Max rows for most_connected and tag_distribution (default: 10).

strict: bool

Exit non-zero (1) when any included Tier-2 warning kind has present violations, or when an always-on configuration axis reports findings. Always-on (no --include opt-in): the authoring-drift axis (SCHEMA_AUTHORING_SOURCE_MISSING / SCHEMA_AUTHORING_SOURCE_DIVERGED) and the configuration defects SCHEMA_PIN_MISMATCH, SCHEMA_UNSTAMPED_SOURCE_ROT and MOUNT_UNBACKED (a mount whose branch or folder does not exist, or holds no entity). Include-gated participation: missing_required_outgoing, constraints, signals (warn level), and with integrity the consistency findings ORPHAN_STUB, DANGLING_LINK_TARGET_MISSING, DANGLING_LINK_NOT_RELATED and DANGLING_RELATION_TARGET_MISSING and CROSS_MEM_EDGE_UNGRANTED. Stale entities, drifted anchors and SCHEMA_GENERATIONS_BEHIND stay advisory. The output is rendered first, then the non-zero exit fires; new Tier-2 codes opt in additively without breaking the flag’s semantics.

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.