Struct ProcessStatus 

pub struct ProcessStatus {

    pub pid: Option<String>,
    pub parent: Option<String>,
    pub children: Vec<String>,
    pub identity: Option<Identity>,
    pub phase: ProcessPhase,
    pub phase_since: Option<DateTime<Utc>>,
    pub attestation: Option<ProcessAttestation>,
    pub flux_resources: Vec<FluxResourceRef>,
    pub boundary: BoundaryStatus,
    pub compliance: ComplianceStatus,
    pub signal_queue: Vec<ProcessSignal>,
    pub conditions: Vec<ProcessCondition>,
    pub message: Option<String>,
    pub exit_code: Option<i32>,
}

Process status — every field optional until the reconciler writes it.

Fields

pid: Option<String>

Hierarchical PID path — e.g., "seph.1.7".

parent: Option<String>

Parent PID path (mirror of spec.identity.parent, resolved at fork).

children: Vec<String>

Direct children’s PID paths.

identity: Option<Identity>

Resolved identity (name + content hash).

phase: ProcessPhase

Current phase.

phase_since: Option<DateTime<Utc>>

When the process entered the current phase.

attestation: Option<ProcessAttestation>

Three-pillar attestation (written at end of every successful cycle).

flux_resources: Vec<FluxResourceRef>

FluxCD resources currently owned by this Process.

boundary: BoundaryStatus

Boundary verification state.

compliance: ComplianceStatus

Compliance summary at the latest attestation.

signal_queue: Vec<ProcessSignal>

Pending signals (delivered, not yet handled).

conditions: Vec<ProcessCondition>

Standard K8s Conditions.

message: Option<String>

Human-readable last status message.

exit_code: Option<i32>

Exit code (only set on Failed / Reaped).

Implementations

impl ProcessStatus

pub fn at_phase(phase: ProcessPhase) -> Self

Canonical phase-slot-only ProcessStatus fixture — a ProcessPhase pinned at the caller-supplied variant with every other slot parked at its Default — the workspace-baseline status shape every pool-reconciler phase-decision fixture and every below-controller test that “just wants a Process whose status carries a specific phase, nothing else observed” hand- authored as a 3-line Some(ProcessStatus { phase, ..Default }) struct-literal at scattered pin sites.

Pre-lift the 3-line ProcessStatus { phase: <ProcessPhase::…>, ..Default::default() } shape recurred at TWO hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold, both inside tatara-pool-reconciler::controller_pool::tests:

• process_to_member_state_attested_permanent_is_free — the Free-arm pin that binds “a Process whose observed phase is Attested + whose declared lifetime is Permanent maps to MemberState::Free”.
• process_to_member_state_attested_ephemeral_is_allocated — the Allocated-arm pin that binds the peer transition on the Lifetime::Ephemeral corner.

Both pin sites walked the SAME 3-line shape stamping ProcessPhase::Attested; the composer serves both directly and stays parameterized on phase so a future pin on a peer variant (Running, Reconverging, Reaped) rides the same primitive without a new shape opening.

Post-lift each callsite reads p.status = Some(ProcessStatus::at_phase(ProcessPhase::Attested)); and the phase-slot-only status fixture lives at ONE substrate owner. Sibling to ProcessSpec::gate_compute_defaults on the (spec × status) construction-shape pair: that primitive owns the FULL-spec baseline builder for every downstream Process::new consumer; this primitive owns the phase-slot-observation status builder for every downstream p.status = Some(...) fixture.

A future normalization of the phase-only status shape (a call-time phase_since stamp mirroring the phase-transition writer’s discipline, a boundary slot default overlay pinning the phase to a matching BoundaryStatus corner, a wired-in identity fixture for the phase-decision fixtures that today leave the slot at None) lands at THIS ONE function and every downstream phase-decision pin inherits the upgrade mechanically. Directly benefits the P5 shigoto Dag refactor (any RecordingJob test fixture stamping “a Process whose observed phase is X” rides the same composer rather than restating the 3-line shape a third time) and the P3 kenshi-runner library lift (any test-Job controller that binds a phase-observation fixture on its owning Process rides through the same composer as the pool-reconciler’s two phase-decision pins).

Theory anchor: THEORY.md §VI.1 (generation over composition — the 3-line ProcessStatus { phase, ..Default::default() } struct-literal recurred at 2 hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger inside one workspace crate, and is lifted onto ONE substrate owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pin block binds the primitive at fail-before-pass-after granularity so a regression that drifted the phase slot pass-through, leaked a sibling slot away from Default, or hijacked the composer to stamp a static phase_since on the phase transition surfaces at THESE pins rather than as silent phase-decision skew across the two pool-reconciler callsites).

Trait Implementations

impl Clone for ProcessStatus

fn clone(&self) -> ProcessStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessStatus

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

Formats the value using the given formatter.

impl Default for ProcessStatus

fn default() -> ProcessStatus

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ProcessStatus

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ProcessStatus

fn schema_name() -> String

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 is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for ProcessStatus

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

where __S: Serializer,

Serialize this value into the given Serde serializer.