Struct Stray 

pub struct Stray {
    pub path: String,
    pub kind: StrayKind,
    pub verdict: StrayVerdict,
    pub age_seconds: Option<u64>,
    pub session_id: String,
    pub published_at: String,
    pub target: String,
    pub removable: bool,
    pub removed: bool,
}

One stray file, its verdict, and the evidence that produced it.

Every field that decided something is carried, because the rule this command is shaped around requires the value that decided a verdict to be visible before the verdict acts: a surface that printed “orphan” without the age, the episode and the file that already holds it would be asking to be trusted rather than read.

use majordomus_cli::capability::builtin::recover::{Stray, StrayKind, StrayVerdict};
use serde_json::json;

let s: Stray = serde_json::from_value(json!({
    "path": ".ai/repo/sessions/.tmp.a1b2c3",
    "kind": "publish_temp",
    "verdict": "orphan",
    "age_seconds": 90_000,
    "session_id": "s-0007",
    "published_at": ".ai/repo/sessions/2026-09-11--s-0007.md",
    "removable": true,
    "removed": false,
})).unwrap();
assert_eq!(s.verdict, StrayVerdict::Orphan);
assert_eq!(s.kind, StrayKind::PublishTemp);
// removable and removed are different facts: a check run reports the first and never
// the second, which is what makes `--check` readable as a plan rather than a report.
assert!(s.removable && !s.removed);

// and an unmeasurable one carries no age at all, rather than a zero that would read as
// "brand new" to anything that compared it with a threshold
let u: Stray = serde_json::from_value(json!({
    "path": ".mj-stage.xyz", "kind": "staging_dir", "verdict": "unmeasurable",
    "removable": false, "removed": false,
})).unwrap();
assert!(u.age_seconds.is_none());

Fields

path: String

The path, repository-relative. Never the absolute one: a finding that names a disk is a finding nobody else can act on (project.no-machine-paths).

kind: StrayKind

Which of the three shapes this is.

verdict: StrayVerdict

What reading it decided.

age_seconds: Option<u64>

How old it is, in seconds. Absent when the platform could not say, which is the Unmeasurable verdict and never a zero.

session_id: String

The episode this publish temp carries, when it carries one.

published_at: String

The record that already holds that episode, when one does. Its presence is what turns an Incomplete publish temp into an Orphan.

target: String

The file a rename temp was going to become. Its presence is what turns an Incomplete rename temp into an Orphan.

removable: bool

Whether this call would remove it. Decided by the verdict and by remove_stray’s own pattern guard, never by the caller.

removed: bool

Whether this call did remove it. Always false on a check.

Trait Implementations

impl Clone for Stray

fn clone(&self) -> Stray

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stray

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stray

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Stray

impl JsonSchema for Stray

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 Ordered for Stray

Strays are shown in path order, which is the only order that is a property of the store rather than of the walk that found it: read_dir yields what the filesystem feels like yielding, and two runs over one store must answer identically.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for Stray

fn eq(&self, other: &Stray) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Stray

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Stray