S400 · Whole-scheduler provider-authority constructor

#![allow(unexpected_cfgs)]

//! S400 whole-scheduler provider-authority constructor.
//!
//! S399 proved only that the exact pending S245 request and the reconciled
//! 113/113 direct-access surface are eligible for a provider. S400 adds the
//! first real constructor: CPU1 must pass S399, acquire the shared S247
//! exclusive state word, and only then take the exact S245 request. The
//! resulting non-copyable authority owns both the request and the exclusive
//! lease, so its exclusion claim is valid only while that value is live.
//!
//! The production constructor is deliberately exposed but not invoked by the
//! timer chain. S400 does not publish into S244, does not enter S243/S236, and
//! records no supported-profile runtime observation. End-to-end exclusion
//! admission therefore remains open after this constructor gate.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    G8lS245ExclusionAdmissionRequestError, G8lS245ExclusionAdmissionRequestReason,
    G8lS245WholeSchedulerExclusionAdmissionRequest,
    G8lS245WholeSchedulerExclusionAdmissionRequestState, S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::{
    G8lS247WholeSchedulerAccessError, G8lS247WholeSchedulerAccessGate,
    G8lS247WholeSchedulerExclusiveLease,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight::{
    preflight_s399_whole_scheduler_provider, G8lS399WholeSchedulerProviderPreflightError,
    G8lS399WholeSchedulerProviderPreflightOutcome,
    G8lS399WholeSchedulerProviderPreflightReceipt, S399_DIRECT_SCHEDULER_ACCESS_SITES,
    S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S399_PROVIDER_PREFLIGHT_COMPLETE,
    S399_PROVIDER_PREFLIGHT_READY_SITES, S399_SOURCE_AUDIT_UNITS,
    S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S399_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S400_SOURCE_AUDIT_UNITS: usize = S399_SOURCE_AUDIT_UNITS;
pub const S400_DIRECT_SCHEDULER_ACCESS_SITES: usize = S399_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S400_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S400_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S400_UNROUTED_DIRECT_ACCESS_SITES: usize = S399_UNROUTED_DIRECT_ACCESS_SITES;
pub const S400_PROVIDER_PREFLIGHT_READY_SITES: usize = S399_PROVIDER_PREFLIGHT_READY_SITES;
pub const S400_PRODUCTION_PROVIDER_AUTHORITY_SITES: usize = 1;
pub const S400_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES: usize = 1;
pub const S400_PRODUCTION_S245_REQUEST_TAKE_SITES: usize = 1;
pub const S400_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S400_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S400_PROVIDER_PREFLIGHT_COMPLETE: bool = S399_PROVIDER_PREFLIGHT_COMPLETE;
pub const S400_PROVIDER_AUTHORITY_CONSTRUCTOR_COMPLETE: bool = true;
pub const S400_WHOLE_SCHEDULER_EXCLUSION_PROOF_AVAILABLE_WHILE_AUTHORITY_LIVE: bool = true;
pub const S400_END_TO_END_EXCLUSION_ADMISSION_COMPLETE: bool = false;

/// Linear provider authority. It is neither `Copy` nor `Clone`; its private
/// fields bind the exact S399 receipt and S245 request to one live S247 lease.
#[derive(Debug)]
pub struct G8lS400WholeSchedulerProviderAuthority<'a> {
    preflight: G8lS399WholeSchedulerProviderPreflightReceipt,
    request: G8lS245WholeSchedulerExclusionAdmissionRequest,
    lease: G8lS247WholeSchedulerExclusiveLease<'a>,
}

impl G8lS400WholeSchedulerProviderAuthority<'_> {
    pub const fn request_id(&self) -> u64 {
        self.request.request_id()
    }

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

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

    pub const fn reason(&self) -> G8lS245ExclusionAdmissionRequestReason {
        self.request.reason()
    }

    pub const fn exclusive_token(&self) -> u64 {
        self.lease.token()
    }

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

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

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

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

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

    pub const fn request_consumed(&self) -> bool {
        true
    }

    pub const fn is_provider_authority(&self) -> bool {
        true
    }

    pub const fn whole_scheduler_exclusion_proven(&self) -> bool {
        true
    }

    pub const fn admission_published(&self) -> bool {
        false
    }

    pub fn release(
        self,
    ) -> Result<G8lS400ProviderAuthorityReleaseReceipt, G8lS247WholeSchedulerAccessError> {
        let request_id = self.request.request_id();
        let exclusive_token = self.lease.release()?;
        Ok(G8lS400ProviderAuthorityReleaseReceipt {
            request_id,
            exclusive_token,
        })
    }
}

/// Post-release audit data. It deliberately cannot retain authority after the
/// exclusive lease is gone.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS400ProviderAuthorityReleaseReceipt {
    request_id: u64,
    exclusive_token: u64,
}

impl G8lS400ProviderAuthorityReleaseReceipt {
    pub const fn request_id(&self) -> u64 {
        self.request_id
    }

    pub const fn exclusive_token(&self) -> u64 {
        self.exclusive_token
    }

    pub const fn is_provider_authority(&self) -> bool {
        false
    }

    pub const fn whole_scheduler_exclusion_proven(&self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS400ProviderAuthorityConstructorError {
    WrongCpu,
    S245(G8lS245ExclusionAdmissionRequestError),
    S399(G8lS399WholeSchedulerProviderPreflightError),
    Access(G8lS247WholeSchedulerAccessError),
    RequestDisappearedAfterPreflight {
        expected_request_id: u64,
    },
    RequestIdentityDrift {
        expected_request_id: u64,
        observed_request_id: u64,
        observed_source_cpu: usize,
        observed_target_cpu: usize,
        observed_reason: G8lS245ExclusionAdmissionRequestReason,
    },
}

fn request_matches_preflight(
    preflight: &G8lS399WholeSchedulerProviderPreflightReceipt,
    request: &G8lS245WholeSchedulerExclusionAdmissionRequest,
) -> bool {
    preflight.request_id() != 0
        && request.request_id() == preflight.request_id()
        && request.source_cpu() == S245_SOURCE_CPU0
        && request.target_cpu() == S245_TARGET_CPU1
        && request.reason()
            == G8lS245ExclusionAdmissionRequestReason::S242AuthoritiesAndS240ReceiptReady
        && !request.is_authority()
        && !request.whole_scheduler_exclusion_proven()
        && preflight.source_audit_units() == S400_SOURCE_AUDIT_UNITS
        && preflight.direct_scheduler_access_sites() == S400_DIRECT_SCHEDULER_ACCESS_SITES
        && preflight.source_model_covered_direct_access_sites()
            == S400_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
        && preflight.production_guarded_direct_access_sites()
            == S400_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
        && preflight.unrouted_direct_access_sites() == S400_UNROUTED_DIRECT_ACCESS_SITES
        && !preflight.request_taken()
        && !preflight.is_provider_authority()
        && !preflight.admission_published()
        && !preflight.whole_scheduler_exclusion_proven()
}

fn construct_s400_provider_authority_from_parts<'a>(
    preflight: G8lS399WholeSchedulerProviderPreflightReceipt,
    request: G8lS245WholeSchedulerExclusionAdmissionRequest,
    lease: G8lS247WholeSchedulerExclusiveLease<'a>,
) -> Result<G8lS400WholeSchedulerProviderAuthority<'a>, G8lS400ProviderAuthorityConstructorError> {
    if !request_matches_preflight(&preflight, &request) {
        return Err(
            G8lS400ProviderAuthorityConstructorError::RequestIdentityDrift {
                expected_request_id: preflight.request_id(),
                observed_request_id: request.request_id(),
                observed_source_cpu: request.source_cpu(),
                observed_target_cpu: request.target_cpu(),
                observed_reason: request.reason(),
            },
        );
    }
    Ok(G8lS400WholeSchedulerProviderAuthority {
        preflight,
        request,
        lease,
    })
}

/// Host/model constructor. The order is contractual: exact S399 preflight,
/// exclusive S247 acquisition, then one-shot S245 take. A busy gate therefore
/// leaves the request pending and retryable.
pub fn try_construct_s400_model_provider_authority<'a>(
    gate: &'a G8lS247WholeSchedulerAccessGate,
    request_state: &mut G8lS245WholeSchedulerExclusionAdmissionRequestState,
    caller_cpu: usize,
) -> Result<
    Option<G8lS400WholeSchedulerProviderAuthority<'a>>,
    G8lS400ProviderAuthorityConstructorError,
> {
    if caller_cpu != S245_TARGET_CPU1 {
        return Err(G8lS400ProviderAuthorityConstructorError::WrongCpu);
    }
    let request_view = request_state
        .pending_view(caller_cpu)
        .map_err(G8lS400ProviderAuthorityConstructorError::S245)?;
    let preflight = preflight_s399_whole_scheduler_provider(caller_cpu, request_view)
        .map_err(G8lS400ProviderAuthorityConstructorError::S399)?;
    let preflight = match preflight {
        G8lS399WholeSchedulerProviderPreflightOutcome::Idle => return Ok(None),
        G8lS399WholeSchedulerProviderPreflightOutcome::ProviderPreflightReadyAwaitingAuthorityConstructor(
            preflight,
        ) => preflight,
    };
    let lease = gate
        .try_acquire_exclusive(caller_cpu)
        .map_err(G8lS400ProviderAuthorityConstructorError::Access)?;
    let request = request_state
        .take(caller_cpu)
        .map_err(G8lS400ProviderAuthorityConstructorError::S245)?
        .ok_or(
            G8lS400ProviderAuthorityConstructorError::RequestDisappearedAfterPreflight {
                expected_request_id: preflight.request_id(),
            },
        )?;
    construct_s400_provider_authority_from_parts(preflight, request, lease).map(Some)
}

/// Production wrapper owns the IRQ mask after it owns the authority. Field
/// order guarantees the authority (and therefore the S247 lease) drops before
/// the previous DAIF state is restored.
#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub struct G8lS400ProductionWholeSchedulerProviderAuthority {
    authority: G8lS400WholeSchedulerProviderAuthority<'static>,
    _irq_guard: crate::arch::aarch64::IrqGuard,
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
impl G8lS400ProductionWholeSchedulerProviderAuthority {
    pub const fn request_id(&self) -> u64 {
        self.authority.request_id()
    }

    pub const fn exclusive_token(&self) -> u64 {
        self.authority.exclusive_token()
    }

    pub const fn is_provider_authority(&self) -> bool {
        self.authority.is_provider_authority()
    }

    pub const fn whole_scheduler_exclusion_proven(&self) -> bool {
        self.authority.whole_scheduler_exclusion_proven()
    }

    pub const fn admission_published(&self) -> bool {
        self.authority.admission_published()
    }

    pub fn release(
        self,
    ) -> Result<G8lS400ProviderAuthorityReleaseReceipt, G8lS247WholeSchedulerAccessError> {
        self.authority.release()
    }
}

/// Real CPU1 production constructor. It remains dormant at S400: no timer,
/// boot, or exception callsite invokes it, and no S244 publisher consumes its
/// result. If a later gate invokes it, local IRQ masking spans S399 inspection,
/// exclusive acquisition, request take, and the entire returned authority.
#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn try_construct_s400_production_provider_authority_on_cpu1() -> Result<
    Option<G8lS400ProductionWholeSchedulerProviderAuthority>,
    G8lS400ProviderAuthorityConstructorError,
> {
    use crate::g8l_runtime_contract::CPU1;

    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return Err(G8lS400ProviderAuthorityConstructorError::WrongCpu);
    }
    let irq_guard = crate::arch::aarch64::IrqGuard::new();
    let preflight = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight::service_s399_whole_scheduler_provider_preflight_on_cpu1()
        .map_err(G8lS400ProviderAuthorityConstructorError::S399)?;
    let preflight = match preflight {
        G8lS399WholeSchedulerProviderPreflightOutcome::Idle => return Ok(None),
        G8lS399WholeSchedulerProviderPreflightOutcome::ProviderPreflightReadyAwaitingAuthorityConstructor(
            preflight,
        ) => preflight,
    };
    let lease = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE
        .try_acquire_exclusive(CPU1)
        .map_err(G8lS400ProviderAuthorityConstructorError::Access)?;
    let request = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::take_s245_exclusion_admission_request_on_cpu1()
        .map_err(G8lS400ProviderAuthorityConstructorError::S245)?
        .ok_or(
            G8lS400ProviderAuthorityConstructorError::RequestDisappearedAfterPreflight {
                expected_request_id: preflight.request_id(),
            },
        )?;
    let authority = construct_s400_provider_authority_from_parts(preflight, request, lease)?;
    Ok(Some(G8lS400ProductionWholeSchedulerProviderAuthority {
        authority,
        _irq_guard: irq_guard,
    }))
}

#![recursion_limit = "256"]

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    service_s245_exclusion_admission_request, G8lS245ExclusionAdmissionRequestOutcome,
    G8lS245ExclusionAdmissionRequestReason,
    G8lS245WholeSchedulerExclusionAdmissionRequestState, S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::{
    G8lS247WholeSchedulerAccessError, G8lS247WholeSchedulerAccessGate,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight::{
    S399_DIRECT_SCHEDULER_ACCESS_SITES, S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S399_PROVIDER_PREFLIGHT_COMPLETE, S399_SOURCE_AUDIT_UNITS,
    S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S399_UNROUTED_DIRECT_ACCESS_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor::*;

fn pending(next_request_id: u64) -> G8lS245WholeSchedulerExclusionAdmissionRequestState {
    let mut state =
        G8lS245WholeSchedulerExclusionAdmissionRequestState::with_next_request_id(next_request_id);
    assert_eq!(
        service_s245_exclusion_admission_request(&mut state, S245_SOURCE_CPU0, true, true),
        Ok(G8lS245ExclusionAdmissionRequestOutcome::RequestPublished(
            next_request_id
        ))
    );
    state
}

fn module_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor.rs")
}

fn s399_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight.rs")
}

fn s399_test_source() -> &'static str {
    include_str!("g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight.rs")
}

fn kernel_main_source() -> &'static str {
    include_str!("../../kernel/src/main.rs")
}

fn exception_source() -> &'static str {
    include_str!("../../kernel/src/arch/aarch64/exceptions.rs")
}

fn simulation_lib_source() -> &'static str {
    include_str!("../src/lib.rs")
}

#[test]
fn constants_promote_only_the_provider_authority_constructor() {
    assert_eq!(S400_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S400_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S400_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S400_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S400_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert!(S400_PROVIDER_PREFLIGHT_COMPLETE);
    assert_eq!(S400_PROVIDER_PREFLIGHT_READY_SITES, 1);
    assert_eq!(S400_PRODUCTION_PROVIDER_AUTHORITY_SITES, 1);
    assert_eq!(S400_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES, 1);
    assert_eq!(S400_PRODUCTION_S245_REQUEST_TAKE_SITES, 1);
    assert_eq!(S400_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert_eq!(S400_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert!(S400_PROVIDER_AUTHORITY_CONSTRUCTOR_COMPLETE);
    assert!(S400_WHOLE_SCHEDULER_EXCLUSION_PROOF_AVAILABLE_WHILE_AUTHORITY_LIVE);
    assert!(!S400_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn s399_is_the_exact_non_authoritative_predecessor() {
    assert_eq!(S399_SOURCE_AUDIT_UNITS, S400_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S399_DIRECT_SCHEDULER_ACCESS_SITES,
        S400_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S400_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S400_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S399_UNROUTED_DIRECT_ACCESS_SITES,
        S400_UNROUTED_DIRECT_ACCESS_SITES
    );
    assert!(S399_PROVIDER_PREFLIGHT_COMPLETE);
}

#[test]
fn exact_request_constructs_a_live_exclusive_provider_authority() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(41);
    let authority =
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .unwrap();

    assert_eq!(authority.request_id(), 41);
    assert_eq!(authority.source_cpu(), S245_SOURCE_CPU0);
    assert_eq!(authority.target_cpu(), S245_TARGET_CPU1);
    assert_eq!(
        authority.reason(),
        G8lS245ExclusionAdmissionRequestReason::S242AuthoritiesAndS240ReceiptReady
    );
    assert_eq!(authority.exclusive_token(), 1);
    assert_eq!(authority.source_audit_units(), 7);
    assert_eq!(authority.direct_scheduler_access_sites(), 113);
    assert_eq!(authority.production_guarded_direct_access_sites(), 113);
    assert!(authority.request_consumed());
    assert!(authority.is_provider_authority());
    assert!(authority.whole_scheduler_exclusion_proven());
    assert!(!authority.admission_published());
    assert!(!state.pending());
    assert_eq!(gate.active_exclusive_token(), Some(1));
}

#[test]
fn wrong_cpu_fails_before_touching_request_or_gate() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(1);
    assert!(matches!(
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_SOURCE_CPU0),
        Err(G8lS400ProviderAuthorityConstructorError::WrongCpu)
    ));
    assert_eq!(state.pending_request_id(), Some(1));
    assert_eq!(gate.active_readers(), 0);
    assert_eq!(gate.active_exclusive_token(), None);
}

#[test]
fn no_request_is_idle_without_consuming_an_exclusive_token() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = G8lS245WholeSchedulerExclusionAdmissionRequestState::new();
    assert!(
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .is_none()
    );
    let lease = gate.try_acquire_exclusive(S245_TARGET_CPU1).unwrap();
    assert_eq!(lease.token(), 1);
}

#[test]
fn a_live_reader_blocks_construction_and_preserves_the_request() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let reader = gate.try_acquire_read(S245_SOURCE_CPU0).unwrap();
    let mut state = pending(1);
    assert!(matches!(
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1),
        Err(G8lS400ProviderAuthorityConstructorError::Access(
            G8lS247WholeSchedulerAccessError::ExclusiveBusy {
                active_readers: 1,
                active_token: None
            }
        ))
    ));
    assert_eq!(state.pending_request_id(), Some(1));
    drop(reader);
}

#[test]
fn a_live_writer_blocks_construction_and_preserves_the_request() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let writer = gate.try_acquire_exclusive(S245_TARGET_CPU1).unwrap();
    let mut state = pending(1);
    assert!(matches!(
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1),
        Err(G8lS400ProviderAuthorityConstructorError::Access(
            G8lS247WholeSchedulerAccessError::ExclusiveBusy {
                active_readers: 0,
                active_token: Some(1)
            }
        ))
    ));
    assert_eq!(state.pending_request_id(), Some(1));
    drop(writer);
}

#[test]
fn live_authority_blocks_every_other_scheduler_membership() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(1);
    let authority =
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .unwrap();
    assert!(matches!(
        gate.try_acquire_read(S245_SOURCE_CPU0),
        Err(G8lS247WholeSchedulerAccessError::ExclusiveBusy {
            active_readers: 0,
            active_token: Some(1)
        })
    ));
    assert!(matches!(
        gate.try_acquire_exclusive(S245_TARGET_CPU1),
        Err(G8lS247WholeSchedulerAccessError::ExclusiveBusy {
            active_readers: 0,
            active_token: Some(1)
        })
    ));
    drop(authority);
}

#[test]
fn dropping_authority_releases_the_exact_exclusive_lease() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(1);
    let authority =
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .unwrap();
    drop(authority);
    assert_eq!(gate.active_exclusive_token(), None);
    let reader = gate.try_acquire_read(S245_SOURCE_CPU0).unwrap();
    assert_eq!(gate.active_readers(), 1);
    drop(reader);
}

#[test]
fn explicit_release_returns_a_non_authoritative_audit_receipt() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(9);
    let authority =
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .unwrap();
    let receipt = authority.release().unwrap();
    assert_eq!(receipt.request_id(), 9);
    assert_eq!(receipt.exclusive_token(), 1);
    assert!(!receipt.is_provider_authority());
    assert!(!receipt.whole_scheduler_exclusion_proven());
    assert_eq!(gate.active_exclusive_token(), None);
}

#[test]
fn consumed_request_cannot_construct_a_second_authority() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut state = pending(1);
    let authority =
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .unwrap();
    authority.release().unwrap();
    assert!(
        try_construct_s400_model_provider_authority(&gate, &mut state, S245_TARGET_CPU1)
            .unwrap()
            .is_none()
    );
}

#[test]
fn provider_authority_is_private_non_copy_non_clone_and_needs_drop() {
    assert!(core::mem::needs_drop::<
        G8lS400WholeSchedulerProviderAuthority<'static>,
    >());
    let source = module_source();
    let start = source
        .find("pub struct G8lS400WholeSchedulerProviderAuthority")
        .unwrap();
    let derive_start = source[..start].rfind("#[derive").unwrap();
    assert_eq!(source[derive_start..start].trim(), "#[derive(Debug)]");
    let body = &source[start..source[start..].find("}\n\nimpl").unwrap() + start];
    assert!(!body.contains("pub request:"));
    assert!(!body.contains("pub preflight:"));
    assert!(!body.contains("pub lease:"));
}

#[test]
fn model_constructor_orders_preflight_before_exclusive_acquire_before_take() {
    let source = module_source();
    let start = source
        .find("pub fn try_construct_s400_model_provider_authority")
        .unwrap();
    let end = source[start..]
        .find("#[cfg(all(target_arch")
        .map(|offset| start + offset)
        .unwrap();
    let function = &source[start..end];
    let preflight = function
        .find("preflight_s399_whole_scheduler_provider")
        .unwrap();
    let acquire = function.find("try_acquire_exclusive(caller_cpu)").unwrap();
    let take = function.find(".take(caller_cpu)").unwrap();
    assert!(preflight < acquire && acquire < take);
}

#[test]
fn failed_acquire_precedes_and_therefore_cannot_consume_the_request() {
    let source = module_source();
    let start = source
        .find("pub fn try_construct_s400_model_provider_authority")
        .unwrap();
    let function = &source[start..];
    assert!(
        function.find("try_acquire_exclusive(caller_cpu)").unwrap()
            < function.find(".take(caller_cpu)").unwrap()
    );
}

#[test]
fn production_constructor_masks_irq_then_preflights_acquires_and_takes() {
    let source = module_source();
    let start = source
        .find("pub fn try_construct_s400_production_provider_authority_on_cpu1")
        .unwrap();
    let function = &source[start..];
    let irq = function.find("IrqGuard::new()").unwrap();
    let preflight = function
        .find("service_s399_whole_scheduler_provider_preflight_on_cpu1")
        .unwrap();
    let acquire = function.find("try_acquire_exclusive(CPU1)").unwrap();
    let take = function
        .find("take_s245_exclusion_admission_request_on_cpu1")
        .unwrap();
    assert!(irq < preflight && preflight < acquire && acquire < take);
}

#[test]
fn production_constructor_uses_exact_rpi5_cfg_and_real_cpu_identity() {
    let source = module_source();
    assert!(source.contains("target_arch = \"aarch64\""));
    assert!(source.contains("target_os = \"none\""));
    assert!(source.contains("feature = \"board-rpi5\""));
    assert!(source.contains("crate::percpu::try_current_cpu_id()"));
    assert!(source.contains("S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE"));
}

#[test]
fn lease_field_drops_before_the_production_irq_guard() {
    let source = module_source();
    let start = source
        .find("pub struct G8lS400ProductionWholeSchedulerProviderAuthority")
        .unwrap();
    let end = source[start..].find("}\n\n#[cfg").unwrap() + start;
    let body = &source[start..end];
    assert!(body.find("authority:").unwrap() < body.find("_irq_guard:").unwrap());
}

#[test]
fn constructor_module_has_no_direct_scheduler_pointer_surface() {
    let source = module_source();
    for forbidden in [
        "addr_of!(",
        "addr_of_mut!(",
        "crate::task::scheduler",
        "&mut Scheduler",
    ] {
        assert!(
            !source.contains(forbidden),
            "forbidden surface: {forbidden}"
        );
    }
}

#[test]
fn s400_does_not_publish_s244_admission_or_invoke_s243() {
    let source = module_source();
    for forbidden in [
        "S244_PRODUCTION_ADMISSION",
        "service_s244_exclusion_gated_deferred_join",
        "service_s243_deferred_authority_receipt_join",
        "publish_s244",
    ] {
        assert!(
            !source.contains(forbidden),
            "forbidden promotion: {forbidden}"
        );
    }
    assert_eq!(S400_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert!(!S400_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn production_constructor_is_exposed_but_not_invoked_by_the_timer_chain() {
    let source = module_source();
    assert!(source.contains("try_construct_s400_production_provider_authority_on_cpu1"));
    assert!(
        !exception_source().contains("try_construct_s400_production_provider_authority_on_cpu1")
    );
    assert!(!exception_source().contains("service_s400"));
    assert_eq!(S400_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
}

#[test]
fn s400_module_and_every_predecessor_are_registered_separately() {
    let kernel = kernel_main_source();
    let simulation = simulation_lib_source();
    for sequence in 328..=400 {
        let marker = format!("_s{sequence}_");
        assert!(kernel.contains(&marker), "kernel missing {marker}");
        assert!(simulation.contains(&marker), "simulation missing {marker}");
    }
    let name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor";
    assert!(kernel.contains(&format!("mod {name};")));
    assert!(simulation.contains(&format!("pub mod {name};")));
}

#[test]
fn s399_remains_non_authoritative_after_s400_is_added() {
    let source = s399_source();
    assert!(source.contains("pub const fn is_provider_authority(&self) -> bool"));
    assert!(source.contains("pub const fn request_taken(&self) -> bool"));
    assert!(source.matches("        false\n").count() >= 4);
    assert!(!source.contains("try_acquire_exclusive"));
    assert!(!source.contains("take_s245_exclusion_admission_request_on_cpu1"));
}

#[test]
fn s399_historical_test_registers_the_exact_s400_through_s402_chain() {
    let source = s399_test_source();
    assert!(source.contains("s399_registers_the_exact_s400_through_s402_successor_chain"));
    assert!(source.contains("g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication"));
}

#[test]
fn release_receipt_cannot_masquerade_as_live_authority() {
    let source = module_source();
    let start = source
        .find("pub struct G8lS400ProviderAuthorityReleaseReceipt")
        .unwrap();
    let section = &source[start
        ..source[start..]
            .find("#[derive")
            .unwrap_or(source.len() - start)
            + start];
    assert!(section.contains("pub const fn is_provider_authority(&self) -> bool"));
    assert!(section.contains("pub const fn whole_scheduler_exclusion_proven(&self) -> bool"));
}

  {
    id: "g8l-s400-whole-scheduler-provider-authority-constructor-partial",
    date: "2026-08-30",
    sequence: 400,
    status: "passed",
    umbrella_status: "partial",
    title: "S400 · Whole-scheduler provider-authority constructor",
    summary:
      "S400, exact S399 non-authoritative preflight receipt'ini ilk gerçek provider authority'ye dönüştürür. CPU1 önce S399 preflight'i doğrular, sonra reader ve writer'ların kullandığı aynı S247 state word üzerinde exclusive lease alır, yalnız bundan sonra exact pending S245 request'i one-shot take eder. Private, non-Copy/non-Clone G8lS400WholeSchedulerProviderAuthority S399 receipt + S245 request + live S247 lease'i birlikte sahiplenir; request_consumed=true, is_provider_authority=true ve whole_scheduler_exclusion_proven=true yalnız authority canlıyken geçerlidir. Explicit release veya Drop exact lease'i bırakır ve release receipt authority değildir. RPi5 production constructor gerçek per-CPU CPU1 kimliği ve IRQ maskesiyle exposed'dur fakat boot/timer/exception zincirinden çağrılmaz. S244 admission publisher=0, supported-profile runtime observation=0 ve end-to-end exclusion admission=false kalır; S401 runtime invocation/publication kapısı ayrı olmalıdır.",
    evidence: [
      "Canonical S400 focused target ayrı S400 module source ve simulation export yokken compile RED verdi.",
      "İlk focused koşu exit 101 ile missing S400 include source ve unresolved simulation import'u birlikte gösterdi.",
      "S399 provider-preflight sonucu S400 authority constructor yerine otomatik PASS sayılmadı.",
      "İlk implementation koşusu 21/24 PASS ve yalnız üç source-shape assertion RED verdi.",
      "Üç source-shape assertion complete cfg/function sınırları ve rustfmt line-wrap biçimine hizalandı.",
      "Authority, exclusion, request-order, coverage veya publication assertion'ı zayıflatılmadı.",
      "Final canonical CARGO_INCREMENTAL=0 focused koşu 24/24 PASS verdi.",
      "Focused final koşuda ignored veya filtered assertion yoktur.",
      "Bir incremental nightly koşu rustc Freeze query ICE üretti; bu ürün RED'i olarak sınıflandırılmadı.",
      "Incremental ICE sonrasında canonical non-incremental retry 24/24 PASS verdi.",
      "Compiler'ın ürettiği iki crash-report çalışma dosyası kaldırıldı; ürün kaynakları değiştirilmedi.",
      "S400 constructor module 14296 B / 150fab53b730966b5f90762b7ecbd723b14053266fdf759255afb8daa0028f32 SHA-256'dır.",
      "S400 focused test source 16733 B / d01a8794e8223de5add5da144fd25bab39b108bf02bf060b164eac9539617f06 SHA-256'dır.",
      "S400_SOURCE_AUDIT_UNITS=7 exact S399 predecessor'dan taşınır.",
      "S400_DIRECT_SCHEDULER_ACCESS_SITES=113'tür.",
      "S400_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES=113'tür.",
      "S400_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES=113'tür.",
      "S400_UNROUTED_DIRECT_ACCESS_SITES=0'dır.",
      "S400_PROVIDER_PREFLIGHT_READY_SITES=1'dir.",
      "S400_PRODUCTION_PROVIDER_AUTHORITY_SITES=1'dir.",
      "S400_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES=1'dir.",
      "S400_PRODUCTION_S245_REQUEST_TAKE_SITES=1'dir.",
      "S400_PRODUCTION_ADMISSION_PUBLISHER_SITES=0'dır.",
      "S400_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS=0'dır.",
      "S400_PROVIDER_PREFLIGHT_COMPLETE=true predecessor sonucudur.",
      "S400_PROVIDER_AUTHORITY_CONSTRUCTOR_COMPLETE=true bu kapının pozitif kapanışıdır.",
      "S400_WHOLE_SCHEDULER_EXCLUSION_PROOF_AVAILABLE_WHILE_AUTHORITY_LIVE=true'dur.",
      "S400_END_TO_END_EXCLUSION_ADMISSION_COMPLETE=false kalır.",
      "Authority private preflight, request ve lease alanlarını tek linear değerde taşır.",
      "Authority derive listesi yalnız Debug içerir; Copy veya Clone yoktur.",
      "Authority request_id accessor'ı exact S245 request kimliğini taşır.",
      "Authority source_cpu accessor'ı CPU0 üreticiyi korur.",
      "Authority target_cpu accessor'ı CPU1 provider'ı korur.",
      "Authority reason accessor'ı S242AuthoritiesAndS240ReceiptReady değerini korur.",
      "Authority exclusive_token accessor'ı live S247 lease token'ını taşır.",
      "Authority 7/113/113/113/0 coverage tuple'ını S399 receipt üzerinden read-only taşır.",
      "Authority request_consumed() exact true döndürür.",
      "Authority is_provider_authority() exact true döndürür.",
      "Authority whole_scheduler_exclusion_proven() exact true döndürür.",
      "Authority admission_published() exact false döndürür.",
      "Explicit release request id ve exclusive token içeren audit receipt döndürür.",
      "Release receipt Copy olabilir fakat is_provider_authority() false döndürür.",
      "Release receipt whole_scheduler_exclusion_proven() false döndürür.",
      "Authority Drop yolu explicit release olmadan exact exclusive lease'i bırakır.",
      "Live authority yeni reader acquisition'ını ExclusiveBusy ile engeller.",
      "Live authority ikinci writer acquisition'ını aynı active token ile engeller.",
      "Authority bırakıldıktan sonra yeni reader tekrar alınabilir.",
      "Consumed S245 request ikinci authority construction üretemez.",
      "Wrong CPU constructor'a girmeden request ve S247 gate'i değiştirmeden reddedilir.",
      "No-request yolu Idle/None döndürür ve exclusive token tüketmez.",
      "Live S247 reader constructor'ı request take edilmeden önce reddeder.",
      "Live S247 writer constructor'ı request take edilmeden önce reddeder.",
      "Busy gate sonrasında exact S245 request pending ve retryable kalır.",
      "Model constructor source order S399 preflight < S247 exclusive acquire < S245 take'dir.",
      "Preflight receipt request id ile taken request id tekrar karşılaştırılır.",
      "Request source CPU, target CPU ve reason constructor içinde yeniden doğrulanır.",
      "Incoming request'in authority ve exclusion bitlerinin false olması zorunludur.",
      "Incoming S399 receipt'in request_taken/authority/admission/exclusion bitleri false olmalıdır.",
      "Request disappeared after preflight ayrı typed error üretir.",
      "Request identity drift bütün observed metadata'yı typed error içinde taşır.",
      "Production constructor exact target_arch=aarch64 + target_os=none + board-rpi5 cfg'sindedir.",
      "Production constructor gerçek crate::percpu::try_current_cpu_id sonucunu kullanır.",
      "Production constructor yalnız CPU1'i kabul eder.",
      "Production constructor local IrqGuard'ı preflight'ten önce kurar.",
      "Production source order IRQ mask < S399 service < S247 acquire < S245 take'dir.",
      "Production constructor exact S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE'i kullanır.",
      "Production constructor exact take_s245_exclusion_admission_request_on_cpu1 çağrısını kullanır.",
      "Production wrapper authority alanını _irq_guard alanından önce tanımlar.",
      "Rust field-drop order S247 lease'i eski DAIF state restore edilmeden önce bırakır.",
      "S400 module addr_of!, addr_of_mut!, Scheduler referansı veya task::scheduler yüzeyi içermez.",
      "S400 constructor live exclusion üretir fakat doğrudan mutable scheduler pointer açmaz.",
      "S400 module publish_s244 veya S244_PRODUCTION_ADMISSION yüzeyi içermez.",
      "S400 module service_s243_deferred_authority_receipt_join çağırmaz.",
      "S400 module service_s244_exclusion_gated_deferred_join çağırmaz.",
      "Production constructor boot, timer ve exception source'larından çağrılmaz.",
      "exceptions.rs try_construct_s400 veya service_s400 çağrısı içermez.",
      "Kernel main ve simulation lib S400'ü predecessor'lardan ayrı module olarak kaydeder.",
      "S328–S400 aralığındaki her module marker kernel ve simulation registry'de ayrı bulunur.",
      "S399 source S400 eklendikten sonra non-authoritative kalır.",
      "S399 source try_acquire_exclusive veya S245 take yüzeyi kazanmaz.",
      "S399 historical test yalnız exact S400 successor'a izin verir ve S401'i reddeder.",
      "S398 historical test exact S399/S400 successor'lara izin verir ve S401'i reddeder.",
      "S397 historical test exact S398–S400 successor'lara izin verir ve S401'i reddeder.",
      "Selected regression final sonucu 6 grup / 118/118 PASS'tir.",
      "Selected gruplar S400 24/24, S399 23/23, S398 21/21 ve S397 23/23'tür.",
      "Selected predecessor grupları tarihsel S246 provider-preflight 13/13 ve S247 shared gate 14/14'tür.",
      "Selected log 808 B / cf791d536bae6933013a8746a157e1150a7d19004084372f686a5e1ee68d96f6 SHA-256'dır.",
      "Selected artifact root /tmp/aselsanos-s400-selected.CV1oCG'dir.",
      "İlk selected turda S399 22/23 yalnız historical successor assertion nedeniyle RED oldu.",
      "İlk selected turda S398 20/21 yalnız historical successor assertion nedeniyle RED oldu.",
      "İlk selected turda S397 22/23 yalnız historical successor assertion nedeniyle RED oldu.",
      "Üç predecessor assertion yalnız exact S400'e izin verecek ve S401'i yasaklayacak biçimde güncellendi.",
      "S399'un non-authority, no-acquire ve no-take ürün sözleşmeleri korunur.",
      "S398'in no-new-access ve no-provider ürün sözleşmeleri korunur.",
      "S397'nin exact writer reconciliation ve no-new-writer ürün sözleşmeleri korunur.",
      "S399'un exact 163-target dependency listesi korunup yalnız S400 sona eklendi.",
      "İki S238–S400 dependency koşusunun her biri 164 grup / 4241/4241 PASS verdi.",
      "Dependency timing-normalized özetleri 15907 B ve byte-eşittir.",
      "Dependency canonical SHA-256 6c37be597c3361f191951f0fd8c1efa42f9636b82707f2f028880d8bb39c38a6'dır.",
      "Dependency run1 raw 395564 B / f45fdff73a62a3b550d88b4f6a90c4aa7b68dbb2a5f901146593a15d1a94949b SHA-256'dır.",
      "Dependency run2 raw 378775 B / e83eddbe6804fdb05d6ca1a9573cedd876525736a460ebc3500cc752ff4272cb SHA-256'dır.",
      "Dependency artifact root /tmp/aselsanos-s400-dependency.Hsowcq'dir.",
      "Exact yedi tarihsel assertion filtered serial workspace audit 363 grup / 6129 PASS / 0 fail verdi.",
      "Filtered workspace raw 76619 B / 894e03feb059f2bb7f97acc467d69cb9647384f10e4917fcaacb39ed822a65e3 SHA-256'dır.",
      "Unfiltered workspace exit 101 ile 316 grup / 5874 PASS sonrasında tek frozen S96 assertion'da durdu.",
      "Unfiltered ilk hata wiring_does_not_mutate_timer_gic_boot_or_expand_runtime_scope'tur.",
      "Unfiltered raw 71841 B / 48fdff4921b53055ae95b92b287a7b81727884b502e1592266a793aa0c142efe SHA-256'dır.",
      "Workspace artifact root /tmp/aselsanos-s400-workspace.ZsPZDE'dir.",
      "Global unfiltered workspace GREEN iddiası yapılmaz.",
      "Dört fresh AArch64 profil 4/4 exit 0 verdi.",
      "QEMU profile warning/log/ELF 293 / 112253 B / 16814112 B'dir.",
      "QEMU ELF SHA-256 c4f0257bd1932a875a96e92c9860041d554d6afe98fa22c27f6145d6496e8242'dir.",
      "RPi4 profile warning/log/ELF 391 / 150883 B / 11925536 B'dir.",
      "RPi4 ELF SHA-256 7919f982c8547428517dc066cb14e955d52e208c521003b6a29e332e65476477'dir.",
      "RPi5 profile warning/log/ELF 1605 / 700312 B / 15544056 B'dir.",
      "RPi5 ELF SHA-256 1e7f0cf45e1a48af2433d76b8b79d67b32cefaeb804debbdc112e86a74b01115'tir.",
      "RPi5+SMP profile warning/log/ELF 1605 / 700098 B / 15575128 B'dir.",
      "RPi5+SMP ELF SHA-256 119ed38950639d70ddc04b4e0430e3fb3eb8cdecdd9dc34670a504ef23be7deb'dir.",
      "Zero-warning iddiası yoktur; warning headers ayrı envanterlenir.",
      "CARGO_INCREMENTAL=0 make verify-qemu exit 0 verdi.",
      "QEMU strict ELF W^X 31/31 PASS'tir.",
      "QEMU S130–S154 + S271 + S136 common scenarios PASS'tir.",
      "QEMU IPC reply 20/20 ve scheduler SEC5 PASS'tir.",
      "QEMU log 116354 B / eb7163b5b3fb45ec85eb43fd6cbfc773d2746ab8a6b9ce8d551d9e8163800d2f SHA-256'dır.",
      "QEMU artifact /tmp/aselsanos-s400-qemu.qOYzza'dir.",
      "Board-QEMU common regression S400 RPi5 CPU1 constructor runtime observation'ı değildir.",
      "Status manifest S400'ü ayrı verification object, physical-zero list ve gate marker ile kaydeder.",
      "S400 proof docs/M8.1-RPi5-G8l-S400-Whole-Scheduler-Provider-Authority-Constructor-Proof.md altındadır.",
      "Code publication hedefi S1–S400 400/400 unique karttır.",
      "S328 öncesi S1–S327 aralığı 327/327 ayrı kart olarak korunmalıdır.",
      "S1, S327, S328, S399 ve S400 exact birer kart; missing=none, duplicate=0 ve S401=0 olmalıdır.",
      "S400 Code kartı complete constructor module, complete focused target, complete Operations record ve proof katmanlarını ayrı göstermelidir.",
      "S400 writer-guard veya yalnız preflight kartı olarak yanlış etiketlenmemelidir.",
      "S400 Code compatibility sourceBound=true, testBound=true ve implementationSequenceBound=true olmalıdır.",
      "İlk production publication öncesi generated Code registry S1–S400 aralığında 400/400 unique gate ve 1164 exact excerpt üretti.",
      "İlk registry S328 öncesi S1–S327 aralığını 327/327 ayrı kart olarak korudu; missing=none ve duplicate=0'dır.",
      "İlk registry mapping 69 writer-guard + 229 focused-test + 94 command-contract + 8 operation-record = 400'dür.",
      "İlk generated JSON 9304334 B / afc4e1884df16b2416eb032c696bd719355a905d4e5c6a2eeb2ba4fb6c3cef3c dosya SHA-256 taşıdı.",
      "İlk registry semantic SHA-256 e8326faf63a5bfdf0c1bcc413991b140fc793c2f4b03b7e6b18572c8a39617ac'dır.",
      "İlk website kabulü 736/736 PASS, lint PASS, boş çıktılı TypeScript exit 0 ve 24/24 static page verdi.",
      "İlk export 200 dosyadır; Timeline ve yol-haritasi ayrı ayrı 239 data-gate-policy kartı taşır.",
      "İlk yayın öncesi S400 core policy 12578 karakter / 12984 UTF-8 byte, 138 evidence, 4 terminal session ve 10 limitation taşır.",
      "İlk production/main deployment 96bfe05b-cd32-4a23-b189-22c31caaa0de ile https://96bfe05b.aselsan-microkernel.pages.dev adresine 115 upload + 84 existing = 199 asset ve _headers yayımladı.",
      "Wrangler production deployment-list kaydı 29554 B / 82af202c9e4de8aa64b0880b14c497fca3da0bf91b5c22d111a65fa945564fc1 SHA-256'dır.",
      "Cache-busted custom-domain /code/ 25910671 B / 80963bd00b32fe0ebf7888db586f84c3f2dd1e4d7293f9c2a9122a73b57b6d98 SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /operations/ 16366053 B / ff0d36a0badea916be000e258ed3ba9dc217754421a54dcc1f6d04293f8cbf1f SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /timeline/ 6948429 B / 706009e6ceb1017d61b2b8894213353a13fa06750374a4e408a7aef57c0656b3 SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /yol-haritasi/ 6948177 B / 57fda112a06d7c7c3e0be06e85178bd505291d4c2d80fb569495727972a0c126 SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Canlı Code literal gate labels total=400, unique=400, pre-S328=327; S1/S327/S328/S399/S400 exact birer ve S401=0'dır.",
      "Canlı /code/ Cache-Control no-transform ve X-Content-Type-Options nosniff taşır; Cloudflare email rewrite marker sayısı 0'dır.",
      "İlk custom-domain readback artifact root /tmp/aselsanos-s400-readback-initial.HVPGku'dir.",
      "İlk yayın kanıtını taşıyan Operations/Timeline/Code payload'ı ayrı evidence-sync deployment transaction'ında yayımlanır.",
      "S400 için güç, SD kart, Mac kart erişimi, UART capture, raw validation, archive veya promotion yapılmadı: physical/device operations=0.",
      "RUNBOOK_EXECUTED_IN_S400=NO; fiziksel RPi5 runtime veya device acceptance iddiası yoktur.",
      "Bağlayıcı olmayan S400 projeksiyonu R1 S400–S430, R2 S455–S505, R3 S584+, risk aralığı S560–S610 ve merkez yaklaşık S585'tir.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor -- --test-threads=1",
      "run S400, S399, S398, S397, historical-filename S246 provider-preflight and S247 shared-gate targets serially",
      "run S238-S400 dependency list twice and normalize timing fields",
      "run filtered and unfiltered serial workspace audits",
      "cargo fmt --all -- --check && git diff --check",
      "run four fresh AArch64 profile builds",
      "CARGO_INCREMENTAL=0 make verify-qemu",
      "python3 scripts/render-project-status.py --write && python3 scripts/render-project-status.py --check",
      "node scripts/generate-code-gates.mjs && node scripts/generate-code-gates.mjs --check",
      "npm test && npm run lint && npx tsc --noEmit && npm run build",
      "npm run deploy",
      "cache-busted curl + cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
    ],
    terminalSessions: [
      {
        id: "s400-focused-provider-authority-constructor",
        title: "S400 focused provider-authority construction",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor -- --test-threads=1",
        ],
        outputLines: [
          "initial test result: compile RED; S400 source and simulation export absent; exit 101",
          "first implementation result: 21/24; three source-shape assertions RED",
          "final canonical result: ok; S400 focused 1 group / 24 passed / 0 failed",
          "order: S399 preflight < S247 exclusive acquire < S245 take",
          "authority=true only while live lease; admission published=false; runtime observation=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s400-selected-regression",
        title: "S400 selected provider/exclusion regression",
        commandLines: [
          "run S400, S399, S398, S397, historical-filename S246 provider-preflight and S247 shared-gate targets serially",
        ],
        outputLines: [
          "initial predecessor-only assertions: S399 22/23, S398 20/21, S397 22/23 RED",
          "exact S400 successor allowed; S401 remains prohibited",
          "final result: 6 groups / 118 passed / 0 failed",
          "S400-owned authority/exclusion/order assertions weakened=false",
          "log=808 B · sha256=cf791d536bae6933013a8746a157e1150a7d19004084372f686a5e1ee68d96f6",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s400-full-acceptance",
        title: "S400 dependency, workspace, profiles and QEMU acceptance",
        commandLines: [
          "run S238-S400 dependency list twice and normalize timing fields",
          "run filtered and unfiltered serial workspace audits",
          "run four fresh AArch64 profile builds",
          "CARGO_INCREMENTAL=0 make verify-qemu",
        ],
        outputLines: [
          "dependency 164 groups / 4241/4241 twice; normalized 15907-byte summaries byte-identical",
          "filtered workspace 363 groups / 6129 PASS / 7 historical filtered",
          "unfiltered workspace frozen-S96 RED after 316 groups / 5874 PASS; global GREEN not claimed",
          "four profiles 4/4 exit 0; warning headers and ELF identities recorded separately",
          "QEMU W^X 31/31 + S130-S154 + S271/S136 + IPC 20/20 + SEC5 PASS; not an S400 runtime observation",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s400-production-publication",
        title: "S400 Operations/Timeline/Code production publication",
        commandLines: [
          "node scripts/generate-code-gates.mjs --check",
          "npm test && npm run lint && npx tsc --noEmit && npm run build",
          "npm run deploy",
          "cache-busted curl + cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
        ],
        outputLines: [
          "website tests 736/736 PASS; lint PASS; TypeScript exit 0 with empty output; static routes 24/24",
          "registry S1-S400: 400/400 gates; 1164 exact excerpts; S1-S327 327/327; missing=0; duplicate=0",
          "deployment 96bfe05b-cd32-4a23-b189-22c31caaa0de; 115 upload + 84 existing = 199 assets",
          "custom-domain code/operations/timeline/yol-haritasi HTTP 200 and byte-exact=true; email rewrite=0; code no-transform/nosniff",
          "live Code total=400, unique=400, pre-S328=327, S400=1 and S401=0",
          "physical/device operations=0 · RUNBOOK_EXECUTED_IN_S400=NO",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "Dört oturum S400 test-first constructor sınırını, predecessor regresyonunu, bütün yazılım kabul matrisini ve ayrı production yayın kapanışını gösterir. QEMU ortak regresyonu S400 constructor invocation kanıtı değildir; fiziksel runbook açılmamıştır.",
    limitations: [
      "Production constructor exposed olsa da boot, timer veya exception zincirinden çağrılmaz.",
      "Supported-profile S400 runtime observation=0'dır.",
      "S244 admission publication yapılmaz.",
      "S243/S236 downstream admission/consumer zinciri çağrılmaz.",
      "Whole-scheduler exclusion proof yalnız authority live S247 lease'i sahiplenirken geçerlidir.",
      "Release receipt provider authority değildir ve exclusion kanıtı taşımaz.",
      "End-to-end whole-scheduler exclusion admission complete değildir.",
      "Ortak QEMU regresyonu S400 RPi5 production constructor invocation kanıtı değildir.",
      "Unfiltered workspace frozen S96 exact-source assertion nedeniyle global GREEN değildir.",
      "Fiziksel güç, SD, Mac kart erişimi, UART, raw validation, archive veya promotion yapılmadı; RUNBOOK_EXECUTED_IN_S400=NO.",
    ],
  },