Struct RecoverOrphansInput 

pub struct RecoverOrphansInput {
    pub older_than_seconds: u64,
    pub check: bool,
}

The input of recover.orphans: how old a stray must be, and whether to act.

use majordomus_cli::capability::builtin::recover::RecoverOrphansInput;

// The wire form the shell tool, an MCP client or an HTTP POST sends.
let act: RecoverOrphansInput =
    serde_json::from_str(r#"{"older_than_seconds":43200,"check":false}"#).unwrap();
assert_eq!(act.older_than_seconds, 43_200);
assert!(!act.check);

// `check` defaults to true, and that direction is deliberate: this capability deletes
// files, and a caller that forgets the field gets a plan rather than a sweep.
let forgot: RecoverOrphansInput =
    serde_json::from_str(r#"{"older_than_seconds":43200}"#).unwrap();
assert!(forgot.check, "the safe value is the default one");

// The threshold has no default at all. `session.stranded_after` is a policy value, and
// a reader that carried its own copy would be a second place the number lives.
assert!(serde_json::from_str::<RecoverOrphansInput>(r#"{"check":true}"#).is_err());

// Unknown fields are refused rather than ignored: a caller that misspells `check` is
// told so instead of having a sweep silently run.
assert!(serde_json::from_str::<RecoverOrphansInput>(
    r#"{"older_than_seconds":1,"chek":true}"#).is_err());

Fields

older_than_seconds: u64

How long a stray file must have been untouched before it is a candidate at all, in seconds. Required, and refused at zero: the shell tool resolves it from session.stranded_after with mj_pol_req, which fails closed, and nothing here invents one.

check: bool

Classify and report, and write nothing. The default, because the alternative deletes files.

Trait Implementations

impl BenchmarkCases for RecoverOrphansInput

The benchmark cases of the capability that sweeps.

Every case is a check, and that is deliberate rather than a gap. A case is executed — by majordomus bench against this repository, and by the HTTP and MCP suites against a fixture — so a case that swept would delete this repository’s stray files every time the suite ran, and a measurement whose cost is a changed store is not a measurement. The check path is also the honest thing to time: it walks every store, stats every candidate and reads every publish temp, which is everything the sweep does except the unlink at the end.

Two cases rather than one because case 92 refuses a declared parameter that no case ever sets, and because the two thresholds measure different work: the generous one classifies every stray, the tight one classifies none of them as Live and so reads every file.

fn benchmark_cases(_: &CaseContext<'_>) -> Vec<NamedCase<Self>>

The cases, in a stable order. An empty list means “nothing to benchmark in this repository”, which the coverage check reports as missing.

fn benchmark_cases_json(ctx: &CaseContext<'_>) -> Vec<NamedCase<Value>>

The cases as JSON, the shape every runner serialises from.

impl Clone for RecoverOrphansInput

fn clone(&self) -> RecoverOrphansInput

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RecoverOrphansInput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RecoverOrphansInput

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RecoverOrphansInput

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for RecoverOrphansInput

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.