S431 · Supported-profile runtime evidence transport · Acceptance contract registration

#![allow(unexpected_cfgs)]

//! S431 starts the S431-S535 acceptance-readiness ledger.
//!
//! Every sequence in the range has a separate module and production callsite.
//! The shared ledger only records that a bounded software evidence requirement
//! was registered in exact predecessor order.  A receipt never claims that a
//! supported profile ran, that hardware was observed, or that R2 acceptance
//! completed.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s430_final_software_boundary::{
    G8lS430FinalSoftwareBoundaryStatus,
    S430_COMPLETED_GATE_COUNT, S430_DIRECT_ACCESS_SITES,
    S430_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S430_SOURCE_AUDIT_UNITS,
    S430_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S430_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S431_FIRST_SEQUENCE: usize = 431;
pub const S535_LAST_SEQUENCE: usize = 535;
pub const S431_TO_S535_GATE_COUNT: usize = S535_LAST_SEQUENCE - S431_FIRST_SEQUENCE + 1;
pub const S431_TO_S535_BLOCK_COUNT: usize = 15;
pub const S431_TO_S535_STEPS_PER_BLOCK: usize = 7;
pub const S431_TARGET_CPU: usize = 1;
pub const S431_SOURCE_AUDIT_UNITS: usize = S430_SOURCE_AUDIT_UNITS;
pub const S431_DIRECT_ACCESS_SITES: usize = S430_DIRECT_ACCESS_SITES;
pub const S431_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S430_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S431_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S430_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S431_UNROUTED_DIRECT_ACCESS_SITES: usize = S430_UNROUTED_DIRECT_ACCESS_SITES;

pub const S431_ACCEPTANCE_DOMAINS: [&str; S431_TO_S535_BLOCK_COUNT] = [
    "runtime_evidence",
    "scheduler_exclusion",
    "supervised_recovery",
    "power_lifecycle",
    "modem_data",
    "voice_audio",
    "secure_update",
    "boot_rollback",
    "production_keys",
    "storage_integrity",
    "network_connectivity",
    "ui_application",
    "manufacturing",
    "field_diagnostics",
    "r2_acceptance",
];

pub const S431_PHYSICAL_EVIDENCE_REQUIRED_BY_BLOCK: [bool; S431_TO_S535_BLOCK_COUNT] = [
    false, false, false, true, true, true, true, true, false, true, true, true, true, true, true,
];

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS431ToS535AcceptanceStep {
    ContractRegistration,
    EvidenceRequestPublication,
    EvidenceProviderPreflight,
    BoundedProductionCallsite,
    MissingObservationJournal,
    FailClosedReconciliation,
    OpenBoundaryPublication,
}

impl G8lS431ToS535AcceptanceStep {
    pub const fn ordinal(self) -> usize {
        match self {
            Self::ContractRegistration => 1,
            Self::EvidenceRequestPublication => 2,
            Self::EvidenceProviderPreflight => 3,
            Self::BoundedProductionCallsite => 4,
            Self::MissingObservationJournal => 5,
            Self::FailClosedReconciliation => 6,
            Self::OpenBoundaryPublication => 7,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS431ToS535AcceptanceGateDescriptor {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub block_ordinal: usize,
    pub step_ordinal: usize,
    pub acceptance_domain: &'static str,
    pub step: G8lS431ToS535AcceptanceStep,
    pub runtime_evidence_required: bool,
    pub physical_evidence_required: bool,
}

pub const fn canonical_s431_to_s535_acceptance_descriptor(
    sequence: usize,
) -> Option<G8lS431ToS535AcceptanceGateDescriptor> {
    if sequence < S431_FIRST_SEQUENCE || sequence > S535_LAST_SEQUENCE {
        return None;
    }
    let offset = sequence - S431_FIRST_SEQUENCE;
    let block_index = offset / S431_TO_S535_STEPS_PER_BLOCK;
    let step_index = offset % S431_TO_S535_STEPS_PER_BLOCK;
    let step = match step_index {
        0 => G8lS431ToS535AcceptanceStep::ContractRegistration,
        1 => G8lS431ToS535AcceptanceStep::EvidenceRequestPublication,
        2 => G8lS431ToS535AcceptanceStep::EvidenceProviderPreflight,
        3 => G8lS431ToS535AcceptanceStep::BoundedProductionCallsite,
        4 => G8lS431ToS535AcceptanceStep::MissingObservationJournal,
        5 => G8lS431ToS535AcceptanceStep::FailClosedReconciliation,
        _ => G8lS431ToS535AcceptanceStep::OpenBoundaryPublication,
    };
    Some(G8lS431ToS535AcceptanceGateDescriptor {
        sequence,
        predecessor_sequence: sequence - 1,
        block_ordinal: block_index + 1,
        step_ordinal: step_index + 1,
        acceptance_domain: S431_ACCEPTANCE_DOMAINS[block_index],
        step,
        runtime_evidence_required: true,
        physical_evidence_required: S431_PHYSICAL_EVIDENCE_REQUIRED_BY_BLOCK[block_index],
    })
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS431ToS535AcceptanceReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub block_ordinal: usize,
    pub step_ordinal: usize,
    pub anchor_attempt_id: u64,
    pub provider_request_id: u64,
    pub exclusive_token: u64,
    pub completed_block_count: usize,
    pub source_gate_complete: bool,
    pub runtime_evidence_required: bool,
    pub physical_evidence_required: bool,
    pub supported_profile_runtime_observed: bool,
    pub physical_observed: bool,
    pub acceptance_complete: bool,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS431ToS535AcceptanceLedgerSnapshot {
    pub anchor_attempt_id: u64,
    pub last_completed_sequence: usize,
    pub completed_block_count: usize,
    pub supported_profile_runtime_observations: usize,
    pub physical_observations: usize,
    pub r2_product_acceptance_complete: bool,
}

#[derive(Debug)]
pub struct G8lS431ToS535AcceptanceLedger {
    anchor_attempt_id: u64,
    provider_request_id: u64,
    exclusive_token: u64,
    last_completed_sequence: usize,
    completed_block_count: usize,
    last_receipt: Option<G8lS431ToS535AcceptanceReceipt>,
}

impl G8lS431ToS535AcceptanceLedger {
    pub fn from_s430(
        caller_cpu: usize,
        status: G8lS430FinalSoftwareBoundaryStatus,
    ) -> Result<Self, G8lS431ToS535AcceptanceError> {
        if caller_cpu != S431_TARGET_CPU {
            return Err(G8lS431ToS535AcceptanceError::WrongCpu);
        }
        if status.attempt_id == 0
            || status.provider_request_id == 0
            || status.exclusive_token == 0
            || status.completed_gate_count != S430_COMPLETED_GATE_COUNT
            || !status.software_source_path_complete
            || !status.whole_scheduler_exclusion_source_handshake_complete
            || !status.main_migration_lifecycle_source_path_complete
            || status.supported_profile_runtime_acceptance_complete
            || status.physical_acceptance_complete
            || status.r2_product_acceptance_complete
            || status.runbook_executed
            || S431_SOURCE_AUDIT_UNITS != 7
            || S431_DIRECT_ACCESS_SITES != 113
            || S431_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES != S431_DIRECT_ACCESS_SITES
            || S431_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES != S431_DIRECT_ACCESS_SITES
            || S431_UNROUTED_DIRECT_ACCESS_SITES != 0
        {
            return Err(G8lS431ToS535AcceptanceError::S430AnchorDrift);
        }
        Ok(Self {
            anchor_attempt_id: status.attempt_id,
            provider_request_id: status.provider_request_id,
            exclusive_token: status.exclusive_token,
            last_completed_sequence: 430,
            completed_block_count: 0,
            last_receipt: None,
        })
    }

    pub const fn last_completed_sequence(&self) -> usize {
        self.last_completed_sequence
    }

    pub const fn completed_block_count(&self) -> usize {
        self.completed_block_count
    }

    pub const fn last_receipt(&self) -> Option<G8lS431ToS535AcceptanceReceipt> {
        self.last_receipt
    }

    pub const fn snapshot(&self) -> G8lS431ToS535AcceptanceLedgerSnapshot {
        G8lS431ToS535AcceptanceLedgerSnapshot {
            anchor_attempt_id: self.anchor_attempt_id,
            last_completed_sequence: self.last_completed_sequence,
            completed_block_count: self.completed_block_count,
            supported_profile_runtime_observations: 0,
            physical_observations: 0,
            r2_product_acceptance_complete: false,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS431ToS535AcceptanceError {
    WrongCpu,
    // Keep the post-S430 error surface flat.  Carrying S430's nested error
    // enum here recursively embeds the entire S401-S430 chain and can exceed
    // rustc's production-target query-depth limit merely while formatting a
    // fail-closed panic.
    S430Service,
    S430AnchorDrift,
    SequenceOutOfRange,
    DescriptorDrift,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS431ToS535AcceptanceOutcome {
    AwaitingS430,
    AwaitingPredecessor {
        sequence: usize,
        expected_predecessor: usize,
        observed_predecessor: usize,
    },
    Advanced(G8lS431ToS535AcceptanceReceipt),
    Retained(G8lS431ToS535AcceptanceReceipt),
    AlreadyCompleted {
        requested_sequence: usize,
        last_completed_sequence: usize,
    },
}

pub fn advance_s431_to_s535_model_acceptance_gate(
    ledger: &mut G8lS431ToS535AcceptanceLedger,
    caller_cpu: usize,
    descriptor: G8lS431ToS535AcceptanceGateDescriptor,
) -> Result<G8lS431ToS535AcceptanceOutcome, G8lS431ToS535AcceptanceError> {
    if caller_cpu != S431_TARGET_CPU {
        return Err(G8lS431ToS535AcceptanceError::WrongCpu);
    }
    let canonical = canonical_s431_to_s535_acceptance_descriptor(descriptor.sequence)
        .ok_or(G8lS431ToS535AcceptanceError::SequenceOutOfRange)?;
    if canonical != descriptor || descriptor.step.ordinal() != descriptor.step_ordinal {
        return Err(G8lS431ToS535AcceptanceError::DescriptorDrift);
    }
    if descriptor.sequence < ledger.last_completed_sequence {
        return Ok(G8lS431ToS535AcceptanceOutcome::AlreadyCompleted {
            requested_sequence: descriptor.sequence,
            last_completed_sequence: ledger.last_completed_sequence,
        });
    }
    if descriptor.sequence == ledger.last_completed_sequence {
        if let Some(receipt) = ledger.last_receipt {
            if receipt.sequence == descriptor.sequence {
                return Ok(G8lS431ToS535AcceptanceOutcome::Retained(receipt));
            }
        }
        return Ok(G8lS431ToS535AcceptanceOutcome::AlreadyCompleted {
            requested_sequence: descriptor.sequence,
            last_completed_sequence: ledger.last_completed_sequence,
        });
    }
    if ledger.last_completed_sequence != descriptor.predecessor_sequence {
        return Ok(G8lS431ToS535AcceptanceOutcome::AwaitingPredecessor {
            sequence: descriptor.sequence,
            expected_predecessor: descriptor.predecessor_sequence,
            observed_predecessor: ledger.last_completed_sequence,
        });
    }
    let completed_block_count =
        if descriptor.step == G8lS431ToS535AcceptanceStep::OpenBoundaryPublication {
            descriptor.block_ordinal
        } else {
            descriptor.block_ordinal - 1
        };
    let receipt = G8lS431ToS535AcceptanceReceipt {
        sequence: descriptor.sequence,
        predecessor_sequence: descriptor.predecessor_sequence,
        block_ordinal: descriptor.block_ordinal,
        step_ordinal: descriptor.step_ordinal,
        anchor_attempt_id: ledger.anchor_attempt_id,
        provider_request_id: ledger.provider_request_id,
        exclusive_token: ledger.exclusive_token,
        completed_block_count,
        source_gate_complete: true,
        runtime_evidence_required: descriptor.runtime_evidence_required,
        physical_evidence_required: descriptor.physical_evidence_required,
        supported_profile_runtime_observed: false,
        physical_observed: false,
        acceptance_complete: false,
        runbook_executed: false,
    };
    ledger.last_completed_sequence = descriptor.sequence;
    ledger.completed_block_count = completed_block_count;
    ledger.last_receipt = Some(receipt);
    Ok(G8lS431ToS535AcceptanceOutcome::Advanced(receipt))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
static S431_TO_S535_PRODUCTION_ACCEPTANCE_LEDGER: spin::Mutex<
    Option<G8lS431ToS535AcceptanceLedger>,
> = spin::Mutex::new(None);

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s431_to_s535_production_acceptance_gate_on_cpu1(
    descriptor: G8lS431ToS535AcceptanceGateDescriptor,
) -> Result<G8lS431ToS535AcceptanceOutcome, G8lS431ToS535AcceptanceError> {
    if crate::percpu::try_current_cpu_id() != Some(S431_TARGET_CPU) {
        return Err(G8lS431ToS535AcceptanceError::WrongCpu);
    }
    let mut state = S431_TO_S535_PRODUCTION_ACCEPTANCE_LEDGER.lock();
    if state.is_none() {
        let Some(anchor) = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s430_final_software_boundary::inspect_s430_final_software_boundary_for_post_s430_on_cpu1() else {
            return Ok(G8lS431ToS535AcceptanceOutcome::AwaitingS430);
        };
        *state = Some(G8lS431ToS535AcceptanceLedger::from_s430(
            S431_TARGET_CPU,
            anchor,
        )?);
    }
    advance_s431_to_s535_model_acceptance_gate(
        state.as_mut().expect("S431-S535 ledger initialized"),
        S431_TARGET_CPU,
        descriptor,
    )
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn inspect_s431_to_s535_production_acceptance_ledger_on_cpu1(
) -> Result<Option<G8lS431ToS535AcceptanceLedgerSnapshot>, G8lS431ToS535AcceptanceError> {
    if crate::percpu::try_current_cpu_id() != Some(S431_TARGET_CPU) {
        return Err(G8lS431ToS535AcceptanceError::WrongCpu);
    }
    Ok(S431_TO_S535_PRODUCTION_ACCEPTANCE_LEDGER
        .lock()
        .as_ref()
        .map(G8lS431ToS535AcceptanceLedger::snapshot))
}

pub const S431_SEQUENCE: usize = 431;
pub const S431_EXPECTED_PREDECESSOR: usize = 430;
pub const S431_BLOCK_ORDINAL: usize = 1;
pub const S431_STEP_ORDINAL: usize = 1;
pub const S431_ACCEPTANCE_DOMAIN: &str = "runtime_evidence";
pub const S431_DESCRIPTOR: G8lS431ToS535AcceptanceGateDescriptor =
    G8lS431ToS535AcceptanceGateDescriptor {
        sequence: S431_SEQUENCE,
        predecessor_sequence: S431_EXPECTED_PREDECESSOR,
        block_ordinal: S431_BLOCK_ORDINAL,
        step_ordinal: S431_STEP_ORDINAL,
        acceptance_domain: S431_ACCEPTANCE_DOMAIN,
        step: G8lS431ToS535AcceptanceStep::ContractRegistration,
        runtime_evidence_required: true,
        physical_evidence_required: false,
    };
pub const RUNBOOK_EXECUTED_IN_S431: bool = false;
pub const S431_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S431_PHYSICAL_OBSERVATIONS: usize = 0;
pub const S431_ACCEPTANCE_COMPLETE: bool = false;

pub type G8lS431AcceptanceGateOutcome = G8lS431ToS535AcceptanceOutcome;
pub type G8lS431AcceptanceGateError = G8lS431ToS535AcceptanceError;

pub fn service_s431_model_runtime_evidence_contract(
    ledger: &mut G8lS431ToS535AcceptanceLedger,
    caller_cpu: usize,
) -> Result<G8lS431AcceptanceGateOutcome, G8lS431AcceptanceGateError> {
    advance_s431_to_s535_model_acceptance_gate(ledger, caller_cpu, S431_DESCRIPTOR)
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s431_runtime_evidence_contract_on_cpu1(
) -> Result<G8lS431AcceptanceGateOutcome, G8lS431AcceptanceGateError> {
    service_s431_to_s535_production_acceptance_gate_on_cpu1(S431_DESCRIPTOR)
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s430_final_software_boundary::G8lS430FinalSoftwareBoundaryStatus;
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s431_runtime_evidence_contract::{
    advance_s431_to_s535_model_acceptance_gate,
    canonical_s431_to_s535_acceptance_descriptor, G8lS431ToS535AcceptanceError,
    G8lS431ToS535AcceptanceLedger, G8lS431ToS535AcceptanceOutcome,
    S431_FIRST_SEQUENCE, S535_LAST_SEQUENCE,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s431_runtime_evidence_contract as gate;

fn s430_anchor() -> G8lS430FinalSoftwareBoundaryStatus {
    G8lS430FinalSoftwareBoundaryStatus {
        attempt_id: 4301,
        provider_request_id: 4302,
        exclusive_token: 4303,
        completed_gate_count: 30,
        software_source_path_complete: true,
        whole_scheduler_exclusion_source_handshake_complete: true,
        main_migration_lifecycle_source_path_complete: true,
        supported_profile_runtime_acceptance_complete: false,
        physical_acceptance_complete: false,
        r2_product_acceptance_complete: false,
        runbook_executed: false,
    }
}

fn acceptance_ledger() -> G8lS431ToS535AcceptanceLedger {
    G8lS431ToS535AcceptanceLedger::from_s430(1, s430_anchor()).unwrap()
}

fn advance_before(ledger: &mut G8lS431ToS535AcceptanceLedger, sequence: usize) {
    for predecessor in S431_FIRST_SEQUENCE..sequence {
        let descriptor = canonical_s431_to_s535_acceptance_descriptor(predecessor).unwrap();
        assert!(matches!(
            advance_s431_to_s535_model_acceptance_gate(ledger, 1, descriptor),
            Ok(G8lS431ToS535AcceptanceOutcome::Advanced(_))
        ));
    }
}

#[test]
fn s431_descriptor_is_exact_and_canonical() {
    assert_eq!(gate::S431_SEQUENCE, 431);
    assert_eq!(gate::S431_EXPECTED_PREDECESSOR, 430);
    assert_eq!(gate::S431_BLOCK_ORDINAL, 1);
    assert_eq!(gate::S431_STEP_ORDINAL, 1);
    assert_eq!(gate::S431_ACCEPTANCE_DOMAIN, "runtime_evidence");
    assert_eq!(
        canonical_s431_to_s535_acceptance_descriptor(431),
        Some(gate::S431_DESCRIPTOR)
    );
}

#[test]
fn s431_is_cpu1_scoped_and_waits_for_exact_predecessor() {
    let mut ledger = acceptance_ledger();
    assert_eq!(
        gate::service_s431_model_runtime_evidence_contract(&mut ledger, 0),
        Err(G8lS431ToS535AcceptanceError::WrongCpu)
    );
    assert_eq!(ledger.last_completed_sequence(), 430);
    if 431 == S431_FIRST_SEQUENCE {
        let future = canonical_s431_to_s535_acceptance_descriptor(432).unwrap();
        assert!(matches!(
            advance_s431_to_s535_model_acceptance_gate(&mut ledger, 1, future),
            Ok(G8lS431ToS535AcceptanceOutcome::AwaitingPredecessor {
                expected_predecessor: 431,
                observed_predecessor: 430,
                ..
            })
        ));
    } else {
        assert!(matches!(
            gate::service_s431_model_runtime_evidence_contract(&mut ledger, 1),
            Ok(G8lS431ToS535AcceptanceOutcome::AwaitingPredecessor {
                sequence: 431,
                expected_predecessor: 430,
                observed_predecessor: 430,
            })
        ));
    }
}

#[test]
fn s431_advances_once_with_non_acceptance_receipt() {
    let mut ledger = acceptance_ledger();
    advance_before(&mut ledger, 431);
    let G8lS431ToS535AcceptanceOutcome::Advanced(receipt) =
        gate::service_s431_model_runtime_evidence_contract(&mut ledger, 1).unwrap()
    else {
        panic!("S431 must advance")
    };
    assert_eq!((receipt.sequence, receipt.predecessor_sequence), (431, 430));
    assert_eq!((receipt.block_ordinal, receipt.step_ordinal), (1, 1));
    assert_eq!(receipt.completed_block_count, 0);
    assert!(receipt.source_gate_complete);
    assert!(receipt.runtime_evidence_required);
    assert!(!receipt.supported_profile_runtime_observed);
    assert!(!receipt.physical_observed);
    assert!(!receipt.acceptance_complete);
    assert!(!receipt.runbook_executed);
}

#[test]
fn s431_replay_is_idempotent_and_historical_reentry_does_not_mutate() {
    let mut ledger = acceptance_ledger();
    advance_before(&mut ledger, 431);
    let first = gate::service_s431_model_runtime_evidence_contract(&mut ledger, 1).unwrap();
    let G8lS431ToS535AcceptanceOutcome::Advanced(receipt) = first else {
        panic!("advance")
    };
    assert_eq!(
        gate::service_s431_model_runtime_evidence_contract(&mut ledger, 1),
        Ok(G8lS431ToS535AcceptanceOutcome::Retained(receipt))
    );
    if 431 < S535_LAST_SEQUENCE {
        let next = canonical_s431_to_s535_acceptance_descriptor(431 + 1).unwrap();
        assert!(matches!(
            advance_s431_to_s535_model_acceptance_gate(&mut ledger, 1, next),
            Ok(G8lS431ToS535AcceptanceOutcome::Advanced(_))
        ));
        assert_eq!(
            gate::service_s431_model_runtime_evidence_contract(&mut ledger, 1),
            Ok(G8lS431ToS535AcceptanceOutcome::AlreadyCompleted {
                requested_sequence: 431,
                last_completed_sequence: 431 + 1,
            })
        );
    }
}

#[test]
fn s431_coverage_and_open_claim_boundary_are_preserved() {
    assert_eq!(gate::S431_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(gate::S431_DIRECT_ACCESS_SITES, 113);
    assert_eq!(gate::S431_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(gate::S431_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(gate::S431_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert_eq!(gate::S431_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert_eq!(gate::S431_PHYSICAL_OBSERVATIONS, 0);
    assert!(!gate::S431_ACCEPTANCE_COMPLETE);
    assert!(!gate::RUNBOOK_EXECUTED_IN_S431);
}

#[test]
fn s431_has_separate_kernel_simulation_and_production_wiring() {
    const TARGET: &str = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s431_runtime_evidence_contract";
    const SERVICE: &str = "service_s431_runtime_evidence_contract_on_cpu1";
    let source = include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s431_runtime_evidence_contract.rs");
    let kernel_registry = include_str!("../../kernel/src/main.rs");
    let simulation_registry = include_str!("../src/lib.rs");
    let exceptions = include_str!("../../kernel/src/arch/aarch64/exceptions.rs");
    assert!(source.contains("pub const S431_DESCRIPTOR"));
    assert_eq!(
        kernel_registry.matches(&format!("mod {TARGET};")).count(),
        1
    );
    assert_eq!(
        simulation_registry
            .matches(&format!("pub mod {TARGET};"))
            .count(),
        1
    );
    assert_eq!(exceptions.matches(SERVICE).count(), 1);
    let previous = exceptions
        .find("service_s430_final_software_boundary_on_cpu1")
        .unwrap();
    let current = exceptions.find(SERVICE).unwrap();
    assert!(previous < current);
    let successor_service = "service_s432_runtime_evidence_request_on_cpu1";
    if !successor_service.is_empty() {
        assert!(current < exceptions.find(successor_service).unwrap());
    }
}

#[test]
fn s431_descriptor_mutation_fails_before_ledger_advance() {
    let mut ledger = acceptance_ledger();
    advance_before(&mut ledger, 431);
    let before = ledger.last_completed_sequence();
    let mut drift = gate::S431_DESCRIPTOR;
    drift.block_ordinal += 1;
    assert_eq!(
        advance_s431_to_s535_model_acceptance_gate(&mut ledger, 1, drift),
        Err(G8lS431ToS535AcceptanceError::DescriptorDrift)
    );
    assert_eq!(ledger.last_completed_sequence(), before);
}

  {
    id: "g8l-s431-runtime-evidence-contract-partial",
    sequence: 431,
    slug: "runtime_evidence_contract",
    title: "Supported-profile runtime evidence transport · Acceptance contract registration",
    focusedTests: 7,
    sourceBytes: 15684,
    sourceSha256: "f24a0c08356ba6d2c54a9ff7ccff8e1ae34d6abf090f0ad08612ca291362c841",
    testBytes: 7821,
    testSha256: "cb1e6c1a2182a075a381463a236e4d30d8d5e4d473f2e41acd7677a61b9866d4",
    blockOrdinal: 1,
    blockTitle: "Supported-profile runtime evidence transport",
    stepOrdinal: 1,
    stepTitle: "Acceptance contract registration",
    acceptance: "S431, Supported-profile runtime evidence transport bloğının Acceptance contract registration adımını exact S430 predecessor sonrasında ayrı typed descriptor ve ayrı CPU1 production service callsite ile kaydeder.",
    retainedBoundary: "Bu yalnız fail-closed software readiness kaydıdır; supported-profile runtime observation=0, physical observation=0, acceptance_complete=false ve RUNBOOK_EXECUTED_IN_S431=NO kalır.",
  },