Enum StandardsCommand 

pub enum StandardsCommand {
    Metrics {
        json: bool,
    },
    Lint {
        dir: PathBuf,
        against: Option<String>,
    },
    Waive {
        rule: String,
        revision: Option<u64>,
        finding: Option<String>,
        reason: String,
        expires: String,
    },
    Attest {
        rule: String,
        reason: String,
    },
}

Subcommands under kranz standards — the Flight Rules surface (ticket .kranz/tickets/flight-rules-pack-contract.md, KRZ-341).

Variants

Metrics

Fold Flight Rules effectiveness across mission event logs and traced defect tickets. Raw denominators are always shown; interpretive smells remain suppressed below the documented minimum sample count.

Fields

json: bool

Emit the deterministic machine-readable report

Lint

Load a pack’s [standards] corpus and print the normalized manifest: every RFC and rule with its effective lifecycle status, checker binding, and scopes, plus the sha256 content digest and the trust posture (an external/untracked pack is advisory-only — enforced rules are refused at load naming the remedy).

With --against <ref>, the base pack is read from TRACKED BLOBS at that git ref (never the worktree) and lifecycle transition violations are refused: absent/draft → enforced, a semantic rule change without a revision increment, a disappeared known rule ID, tombstone reactivation. Exit 0 clean, 1 on load errors or refused transitions.

Fields

dir: PathBuf

The pack directory containing pack.toml

against: Option<String>

Base git ref (branch or sha) whose tracked pack bytes define the approved lifecycle state for the transition check

Waive

Record an authorized human waiver for ONE standards failure (ticket flight-rules-waiver-decisions, KRZ-344; design D-I) — the only approval surface. Displays the finding, the pinned rule, the affected paths, and the diff digest the waiver binds, then appends standards.waiver.approved to the mission log. Refuses: a rule with waivable: false, a rule absent from the approved pin (an expired/ retired rule or RFC is never pinned), a mismatched revision, an absent finding, an already-waived finding, or a past expiry. The approver is recorded honestly as local-operator plus this surface — a model may request a waiver but can never approve one.

Fields

rule: String

The pinned rule id to except (e.g. ENG-RUST-014)

revision: Option<u64>

The revision you believe you are waiving (defaults to the pinned revision; a mismatch refuses rather than silently rebinding)

finding: Option<String>

Waive only the latest finding with this subject (disambiguates when several findings cite the rule)

reason: String

Why the exception is granted (recorded verbatim)

expires: String

Expiry instant, RFC 3339 (e.g. 2026-09-01T00:00:00Z) — must be in the future; waivers are never permanent

Attest

Record the authorized human verdict for one approval-pinned manual-attestation rule. The attestation binds to the current affected paths and diff digest, so any relevant change invalidates it. The approver is always the local operator using this CLI surface.

Fields

rule: String

The pinned manual-attestation rule id

reason: String

Why the operator judges the current change compliant

Trait Implementations

impl Debug for StandardsCommand

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

Formats the value using the given formatter.

impl FromArgMatches for StandardsCommand

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<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for StandardsCommand

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

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

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

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

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand