Struct AxiomMemoryAdmissionRequest 

pub struct AxiomMemoryAdmissionRequest {
    pub candidate_state: CandidateState,
    pub evidence_class: EvidenceClass,
    pub phase_context: PhaseContext,
    pub tool_provenance: ToolProvenance,
    pub source_anchors: Vec<SourceAnchor>,
    pub redaction_status: RedactionStatus,
    pub proof_state: ProofState,
    pub contradiction_scan: ContradictionScan,
    pub explicit_non_promotion: bool,
}

Request to admit AXIOM output as a Cortex memory candidate.

Fields

candidate_state: CandidateState

Admission is permitted only for candidate state.

evidence_class: EvidenceClass

What kind of evidence AXIOM is submitting.

phase_context: PhaseContext

AXIOM phase/context that produced the submitted content.

tool_provenance: ToolProvenance

Tool/runtime provenance for the submitted content.

source_anchors: Vec<SourceAnchor>

Concrete source anchors backing the proposed memory.

redaction_status: RedactionStatus

Explicit redaction posture before durable memory admission.

proof_state: ProofState

Current proof closure state for the candidate lineage.

contradiction_scan: ContradictionScan

Contradiction scan result for the claim or belief slot.

explicit_non_promotion: bool

Must be true: admission never promotes to Active, Principle, or Doctrine.

Implementations

impl AxiomMemoryAdmissionRequest

pub fn from_json_envelope(input: &str) -> AdmissionEnvelopeResult<Self>

Parse a generic ADR 0038 AXIOM memory admission envelope.

This helper is intentionally parse-only: callers must still inspect Self::admission_decision before any persistence. Malformed JSON, missing required fields, or unsupported enum values never produce an admission request.

pub fn validate(&self) -> AdmissionValidationResult<()>

Validate every admission invariant and collect all observed failures.

pub fn admission_decision(&self) -> AdmissionDecision

Produce the deterministic admission decision for this request.

pub fn policy_decision(&self) -> PolicyDecision

Produce the ADR 0026 policy decision corresponding to this admission decision.

pub fn proof_closure_report(&self) -> ProofClosureReport

Map the envelope’s declared ProofState to a typed core ProofClosureReport.

ADR 0036 carries the proof-closure axis as a typed report rather than a free-form enum. The admission envelope reports a caller-declared ProofState; this helper lifts it into the typed report so downstream durable-write surfaces (lifecycle, reflect) compose the same shape they would compose for a store-derived report.

The mapping is:

• ProofState::FullChainVerified -> empty failing edges, cortex_core::ProofState::FullChainVerified
• ProofState::Partial -> one missing-edge failure (lineage axis), maps to cortex_core::ProofState::Partial
• ProofState::Broken -> one broken hash-chain edge, maps to cortex_core::ProofState::Broken
• ProofState::Unknown -> one unresolved lineage edge, maps to cortex_core::ProofState::Partial (Unknown is not a clean FullChainVerified; the durable gate refuses it the same way it refuses Partial)

pub fn proof_closure_contribution(&self) -> PolicyContribution

ADR 0036 contributor for AXIOM admission proof closure.

The contributor mirrors ProofClosureReport::policy_decision:

• CoreProofState::FullChainVerified -> PolicyOutcome::Allow
• CoreProofState::Partial -> PolicyOutcome::Quarantine
• CoreProofState::Broken -> PolicyOutcome::Reject

pub fn require_durable_admission_allowed( &self, ) -> Result<(), DurableAdmissionRefusal>

Refuse durable promotion if the envelope’s proof closure is not CoreProofState::FullChainVerified.

ADR 0036 forbids a durable candidate -> active mutation for AXIOM-origin envelopes when the proof closure is Partial, Broken, or Unknown. The clean admission decision (AdmissionDecision::AdmitCandidate) is necessary but not sufficient: the durable-write boundary is where ADR 0036 fires.

Callers should invoke this immediately before routing an admitted envelope to a durable-write surface (e.g. the lifecycle layer). The refusal carries the stable invariant AXIOM_ADMISSION_PROOF_CLOSURE_INVARIANT and the observed CoreProofState.

pub fn semantic_trust_report( &self, input: AdmissionSemanticTrustInput, ) -> AdmissionSemanticTrustReport

Evaluate ADR 0039 semantic trust for the admission request without changing candidate-only admission or explicit non-promotion gates.

pub fn semantic_provenance_class(&self) -> ProvenanceClass

Map this AXIOM admission request to the closest ADR 0039 provenance class using only fields already present at the memory-admission boundary.

Trait Implementations

impl Clone for AxiomMemoryAdmissionRequest

fn clone(&self) -> AxiomMemoryAdmissionRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AxiomMemoryAdmissionRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AxiomMemoryAdmissionRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<PaiAxiomExecutionReceiptV1> for AxiomMemoryAdmissionRequest

fn from(receipt: PaiAxiomExecutionReceiptV1) -> Self

Converts to this type from the input type.

impl PartialEq for AxiomMemoryAdmissionRequest

fn eq(&self, other: &AxiomMemoryAdmissionRequest) -> 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 AxiomMemoryAdmissionRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AxiomMemoryAdmissionRequest

impl StructuralPartialEq for AxiomMemoryAdmissionRequest