Struct ProcessSpec 

pub struct ProcessSpec {
    pub identity: IdentitySpec,
    pub classification: Classification,
    pub intent: Intent,
    pub boundary: Boundary,
    pub compliance: ComplianceSpec,
    pub depends_on: Vec<DependsOn>,
    pub signals: SignalPolicy,
    pub lifetime: Lifetime,
    pub routing: Option<RoutingSpec>,
    pub encapsulates: Option<EncapsulatesSpec>,
    pub suspended: bool,
}

Process — one element of the tatara convergence lattice, reconciled as a Unix process.

apiVersion: tatara.pleme.io/v1alpha1
kind: Process
metadata:
  name: observability-stack
  namespace: seph
spec:
  identity:
    parent: seph.1
  classification:
    pointType: Gate
    substrate: Observability
  intent:
    nix:
      flakeRef: github:pleme-io/k8s?dir=shared/infrastructure
      attribute: observability
  compliance:
    baseline: fedramp-moderate
    bindings:
      - framework: nist-800-53
        controlId: SC-7
        phase: AtBoundary
  dependsOn:
    - name: secret-injection

Fields

identity: IdentitySpec

Identity (parent, name override).

classification: Classification

Lattice position (6 dimensions).

intent: Intent

Where rendered artifacts come from. Exactly one variant must be set.

boundary: Boundary

Boundary predicates (preconditions / postconditions).

compliance: ComplianceSpec

Compliance bindings + baseline.

depends_on: Vec<DependsOn>

Lattice dependencies — must reach phase before we proceed.

signals: SignalPolicy

Signal policy (grace, SIGHUP strategy, start-suspended).

lifetime: Lifetime

Lifetime — Permanent (default, re-converging) or Ephemeral (auto-SIGTERM per teardown_policy + TTL clock).

routing: Option<RoutingSpec>

External edges — DNS + Ingress. When None, the Process is internal-only (matches today’s default). See crate::routing for the full shape.

encapsulates: Option<EncapsulatesSpec>

Pre-existing in-cluster state this Process wraps. When None, the Process is greenfield (Manage mode implicitly applied to nothing pre-existing). See crate::encapsulates for the three modes (Manage / Adopt / Observe).

suspended: bool

Soft-suspend marker — reconciler treats as SIGSTOP. Same effect as delivering SIGSTOP, but persistent across restarts.

Implementations

impl ProcessSpec

pub fn gate_compute_defaults() -> Self

Canonical minimum ProcessSpec — a Classification::gate_compute classification with every other field parked at its Default — the workspace-baseline spec every consumer that needed “a ProcessSpec that just exists, with no domain-specific claim on intent / boundary / lifetime / routing / encapsulates” hand-authored as a 12-line struct-literal at scattered sites across the workspace.

The composition is the two-primitive product of Classification::gate_compute (the two axes with no Default — a Gate point on the Compute substrate) with the Default impl on every other slot: IdentitySpec, Intent, Boundary, ComplianceSpec, Vec<DependsOn>, SignalPolicy, Lifetime, Option<RoutingSpec>, Option<EncapsulatesSpec>, bool. The 11 defaulted axes ride at the sibling closed-set + #[serde(default)] defaults the CRD already owns; the two _or_default / _or_placeholder corners on the metadata axis stay closed at the substrate (Process::coordinates_or_defaults, Process::name_or_placeholder) since this primitive builds the spec half, not the metadata half.

Pre-lift the 12-line ProcessSpec { identity: <Default>, classification: Classification::gate_compute(), intent: <Default>, boundary: Default::default(), compliance: Default::default(), depends_on: vec![], signals: Default::default(), lifetime: Default::default(), routing: None, encapsulates: None, suspended: false } struct-literal recurred at EIGHT hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold across four crates, each restating the SAME 12-slot verbatim:

• tatara-process::crd::tests::empty_spec — the substrate test fixture that pins every Process::*_or_* metadata-projection primitive on the (return-form × fallback-shape) axis;
• tatara-process::lib::tests::empty_process_spec (×2) — the sibling fixture inside the qualified_process_ref + DeletionTombstoned / Annotated trait pin modules;
• tatara-process::lib::tests (one inline site in the qualified_process_ref_composes_from_process_coordinates_or_defaults pin) — restated the SAME 12-line block inside the test body;
• tatara-reconciler::claim::tests::empty_process — the claim- arbiter row-builder pin fixture;
• tatara-pool-reconciler::controller_pool::tests (×3) — the empty_spec fixture + two inline process_to_member_state_* pin sites that hand-composed the same 12-slot spec inline.

Five more sites walked the SAME 12-slot shape but overrode ONE field (intent, lifetime, or routing) inline and are lifted onto the primitive via struct-update syntax (..ProcessSpec::gate_compute_defaults()): the three tatara-reconciler::render test-fixture helpers (render_through_top_level_intent_dispatch, process_with, demo_process) and the two tatara-process::lifetime_clock helpers (ephemeral_process, permanent_process).

Post-lift each callsite reads ProcessSpec::gate_compute_defaults() (or ProcessSpec { <slot>: <value>, ..ProcessSpec::gate_compute_defaults() } for the override sites); a future workspace-wide baseline shift (a new #[serde(default)] on a promoted Intent variant, a rename of a defaulted slot, a per-baseline compliance overlay stamping through the spec) lands at ONE substrate function here and every downstream consumer inherits the upgrade mechanically. The current pin ties the classification axis to the sibling Classification::gate_compute primitive so a future change to that baseline surfaces at this primitive’s tests rather than as silent drift across thirteen independent callsites.

Sibling to Classification::gate_compute on the composition- depth axis — that primitive owns the ONE-axis-slice construction (the 5-slot Classification value); this primitive owns the FULL-spec construction (the 11-slot ProcessSpec value that wraps the classification-slice plus every other slot at Default). A future peer ProcessSpec::observability_stack() or similar named variant lands as a sibling method here when a second unremarkable-baseline shape opens.

Theory anchor: THEORY.md §VI.1 (generation over composition — the 12-line struct-literal shape recurred at EIGHT hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger and is lifted onto ONE workspace-wide owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — a regression that drifted the baseline axis choice at only one consumer, or that broke the sibling-default correspondence with Classification::gate_compute, surfaces at this primitive’s tests rather than as silent operator- visible skew between the eight exact-match test-fixtures + the five override sites whose struct-update composition depends on the shape).

Trait Implementations

impl Clone for ProcessSpec

fn clone(&self) -> ProcessSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcessSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<EphemeralSpec> for ProcessSpec

fn from(e: EphemeralSpec) -> Self

Converts to this type from the input type.

impl JsonSchema for ProcessSpec

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 ProcessSpec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TataraDomain for ProcessSpec

const KEYWORD: &'static str = "defpoint"

The Lisp keyword (e.g., "defmonitor").

fn compile_from_args(args: &[Sexp]) -> Result<Self>

Parse the argument list (everything after the keyword) into Self.

fn compile_from_sexp(form: &Sexp) -> Result<Self, LispError>

Parse a complete form; validates the head symbol matches KEYWORD.