S399 · Whole-scheduler provider preflight

#![allow(unexpected_cfgs)]

//! S399 whole-scheduler provider preflight.
//!
//! S398 reconciled the complete 113-site direct-access surface through two
//! independent 44-read plus 69-writer partitions. S399 turns that exact result
//! and the exact pending S245 request view into one typed, non-authoritative
//! provider-preflight receipt. The request stays queued, the shared access gate
//! stays untouched, and no admission or provider authority is produced. The
//! S400 authority constructor remains open, together with supported-profile
//! runtime observation and end-to-end whole-scheduler exclusion.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    G8lS245ExclusionAdmissionRequestError, G8lS245WholeSchedulerExclusionAdmissionRequestView,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation::{
    preflight_s398_whole_scheduler_direct_access_coverage_reconciliation,
    G8lS398DirectAccessCoverageReconciliationError,
    G8lS398DirectAccessCoverageReconciliationOutcome, S398_DIRECT_SCHEDULER_ACCESS_SITES,
    S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S398_SOURCE_AUDIT_UNITS,
    S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S398_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S399_SOURCE_AUDIT_UNITS: usize = S398_SOURCE_AUDIT_UNITS;
pub const S399_DIRECT_SCHEDULER_ACCESS_SITES: usize = S398_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S399_UNROUTED_DIRECT_ACCESS_SITES: usize = S398_UNROUTED_DIRECT_ACCESS_SITES;
pub const S399_PROVIDER_PREFLIGHT_READY_SITES: usize = 1;
pub const S399_PRODUCTION_PROVIDER_AUTHORITY_SITES: usize = 0;
pub const S399_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES: usize = 0;
pub const S399_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S399_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S399_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE: bool = true;
pub const S399_PROVIDER_PREFLIGHT_COMPLETE: bool = true;
pub const S399_WHOLE_SCHEDULER_EXCLUSION_COMPLETE: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS399ProviderEligibilityLedger {
    pub request_id: u64,
    pub source_audit_units: usize,
    pub direct_scheduler_access_sites: usize,
    pub source_model_covered_direct_access_sites: usize,
    pub production_guarded_direct_access_sites: usize,
    pub unrouted_direct_access_sites: usize,
}

impl G8lS399ProviderEligibilityLedger {
    pub const fn canonical(request_id: u64) -> Self {
        Self {
            request_id,
            source_audit_units: S399_SOURCE_AUDIT_UNITS,
            direct_scheduler_access_sites: S399_DIRECT_SCHEDULER_ACCESS_SITES,
            source_model_covered_direct_access_sites: S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
            production_guarded_direct_access_sites: S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
            unrouted_direct_access_sites: S399_UNROUTED_DIRECT_ACCESS_SITES,
        }
    }
}

/// An eligibility observation only. Its private fields and lack of `Copy` or
/// `Clone` prevent it from becoming a freely duplicated authority surrogate.
#[derive(Debug, PartialEq, Eq)]
pub struct G8lS399WholeSchedulerProviderPreflightReceipt {
    request_id: u64,
    source_audit_units: usize,
    direct_scheduler_access_sites: usize,
    source_model_covered_direct_access_sites: usize,
    production_guarded_direct_access_sites: usize,
    unrouted_direct_access_sites: usize,
}

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, PartialEq, Eq)]
pub enum G8lS399WholeSchedulerProviderPreflightOutcome {
    Idle,
    ProviderPreflightReadyAwaitingAuthorityConstructor(
        G8lS399WholeSchedulerProviderPreflightReceipt,
    ),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS399WholeSchedulerProviderPreflightError {
    S398(G8lS398DirectAccessCoverageReconciliationError),
    S245(G8lS245ExclusionAdmissionRequestError),
    MissingRequestId,
    PredecessorDrift {
        source_audit_units: usize,
        direct_scheduler_access_sites: usize,
        source_model_covered_direct_access_sites: usize,
        production_guarded_direct_access_sites: usize,
        unrouted_direct_access_sites: usize,
    },
    EligibilityDrift {
        observed: G8lS399ProviderEligibilityLedger,
        expected: G8lS399ProviderEligibilityLedger,
    },
}

pub fn qualify_s399_whole_scheduler_provider_preflight(
    ledger: G8lS399ProviderEligibilityLedger,
) -> Result<
    G8lS399WholeSchedulerProviderPreflightReceipt,
    G8lS399WholeSchedulerProviderPreflightError,
> {
    if ledger.request_id == 0 {
        return Err(G8lS399WholeSchedulerProviderPreflightError::MissingRequestId);
    }
    let expected = G8lS399ProviderEligibilityLedger::canonical(ledger.request_id);
    let coverage_is_exact = ledger == expected
        && ledger.source_model_covered_direct_access_sites == ledger.direct_scheduler_access_sites
        && ledger.production_guarded_direct_access_sites == ledger.direct_scheduler_access_sites
        && ledger.source_model_covered_direct_access_sites
            == ledger.production_guarded_direct_access_sites
        && ledger.unrouted_direct_access_sites == 0;
    if !coverage_is_exact {
        return Err(
            G8lS399WholeSchedulerProviderPreflightError::EligibilityDrift {
                observed: ledger,
                expected,
            },
        );
    }
    Ok(G8lS399WholeSchedulerProviderPreflightReceipt {
        request_id: ledger.request_id,
        source_audit_units: ledger.source_audit_units,
        direct_scheduler_access_sites: ledger.direct_scheduler_access_sites,
        source_model_covered_direct_access_sites: ledger.source_model_covered_direct_access_sites,
        production_guarded_direct_access_sites: ledger.production_guarded_direct_access_sites,
        unrouted_direct_access_sites: ledger.unrouted_direct_access_sites,
    })
}

pub fn preflight_s399_whole_scheduler_provider(
    caller_cpu: usize,
    request: Option<G8lS245WholeSchedulerExclusionAdmissionRequestView>,
) -> Result<
    G8lS399WholeSchedulerProviderPreflightOutcome,
    G8lS399WholeSchedulerProviderPreflightError,
> {
    match preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
        caller_cpu, request,
    )
    .map_err(G8lS399WholeSchedulerProviderPreflightError::S398)?
    {
        G8lS398DirectAccessCoverageReconciliationOutcome::Idle => {
            Ok(G8lS399WholeSchedulerProviderPreflightOutcome::Idle)
        }
        G8lS398DirectAccessCoverageReconciliationOutcome::DirectAccessCoverageReconciledAwaitingProviderPreflight {
            request_id,
            source_audit_units,
            direct_scheduler_access_sites,
            source_model_covered_direct_access_sites,
            production_guarded_direct_access_sites,
            unrouted_direct_access_sites,
        } => {
            if source_audit_units != S399_SOURCE_AUDIT_UNITS
                || direct_scheduler_access_sites != S399_DIRECT_SCHEDULER_ACCESS_SITES
                || source_model_covered_direct_access_sites
                    != S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
                || production_guarded_direct_access_sites
                    != S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
                || unrouted_direct_access_sites != S399_UNROUTED_DIRECT_ACCESS_SITES
            {
                return Err(
                    G8lS399WholeSchedulerProviderPreflightError::PredecessorDrift {
                        source_audit_units,
                        direct_scheduler_access_sites,
                        source_model_covered_direct_access_sites,
                        production_guarded_direct_access_sites,
                        unrouted_direct_access_sites,
                    },
                );
            }
            let receipt = qualify_s399_whole_scheduler_provider_preflight(
                G8lS399ProviderEligibilityLedger::canonical(request_id),
            )?;
            Ok(
                G8lS399WholeSchedulerProviderPreflightOutcome::ProviderPreflightReadyAwaitingAuthorityConstructor(
                    receipt,
                ),
            )
        }
    }
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s399_whole_scheduler_provider_preflight_on_cpu1() -> Result<
    G8lS399WholeSchedulerProviderPreflightOutcome,
    G8lS399WholeSchedulerProviderPreflightError,
> {
    use crate::g8l_runtime_contract::CPU1;

    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return preflight_s399_whole_scheduler_provider(CPU1 + 1, None);
    }
    let request = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::inspect_s245_exclusion_admission_request_on_cpu1()
        .map_err(G8lS399WholeSchedulerProviderPreflightError::S245)?;
    preflight_s399_whole_scheduler_provider(CPU1, request)
}

#![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,
    G8lS245WholeSchedulerExclusionAdmissionRequestState, S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation::{
    S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE,
    S398_DIRECT_SCHEDULER_ACCESS_SITES, S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S398_PROVIDER_PREFLIGHT_COMPLETE, S398_SOURCE_AUDIT_UNITS,
    S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S398_UNROUTED_DIRECT_ACCESS_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight::*;

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

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

fn predecessor_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation.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_provider_preflight_readiness() {
    assert_eq!(S399_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S399_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S399_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert!(S399_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE);
    assert!(S399_PROVIDER_PREFLIGHT_COMPLETE);
    assert_eq!(S399_PROVIDER_PREFLIGHT_READY_SITES, 1);
    assert_eq!(S399_PRODUCTION_PROVIDER_AUTHORITY_SITES, 0);
    assert_eq!(S399_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES, 0);
    assert_eq!(S399_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert_eq!(S399_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert!(!S399_WHOLE_SCHEDULER_EXCLUSION_COMPLETE);
}

#[test]
fn s398_is_the_exact_reconciled_predecessor() {
    assert_eq!(S398_SOURCE_AUDIT_UNITS, S399_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S398_DIRECT_SCHEDULER_ACCESS_SITES,
        S399_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S398_UNROUTED_DIRECT_ACCESS_SITES,
        S399_UNROUTED_DIRECT_ACCESS_SITES
    );
    assert!(S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE);
    assert!(!S398_PROVIDER_PREFLIGHT_COMPLETE);
}

#[test]
fn canonical_eligibility_ledger_returns_a_non_authoritative_receipt() {
    let receipt = qualify_s399_whole_scheduler_provider_preflight(
        G8lS399ProviderEligibilityLedger::canonical(41),
    )
    .unwrap();
    assert_eq!(receipt.request_id(), 41);
    assert_eq!(receipt.source_audit_units(), 7);
    assert_eq!(receipt.direct_scheduler_access_sites(), 113);
    assert_eq!(receipt.source_model_covered_direct_access_sites(), 113);
    assert_eq!(receipt.production_guarded_direct_access_sites(), 113);
    assert_eq!(receipt.unrouted_direct_access_sites(), 0);
    assert!(!receipt.request_taken());
    assert!(!receipt.is_provider_authority());
    assert!(!receipt.admission_published());
    assert!(!receipt.whole_scheduler_exclusion_proven());
}

#[test]
fn zero_request_id_fails_closed_before_preflight_readiness() {
    assert_eq!(
        qualify_s399_whole_scheduler_provider_preflight(
            G8lS399ProviderEligibilityLedger::canonical(0)
        ),
        Err(G8lS399WholeSchedulerProviderPreflightError::MissingRequestId)
    );
}

#[test]
fn every_coverage_dimension_fails_closed_on_drift() {
    let canonical = G8lS399ProviderEligibilityLedger::canonical(1);
    let drifts = [
        G8lS399ProviderEligibilityLedger {
            source_audit_units: 6,
            ..canonical
        },
        G8lS399ProviderEligibilityLedger {
            direct_scheduler_access_sites: 112,
            ..canonical
        },
        G8lS399ProviderEligibilityLedger {
            source_model_covered_direct_access_sites: 112,
            ..canonical
        },
        G8lS399ProviderEligibilityLedger {
            production_guarded_direct_access_sites: 112,
            ..canonical
        },
        G8lS399ProviderEligibilityLedger {
            unrouted_direct_access_sites: 1,
            ..canonical
        },
    ];
    for ledger in drifts {
        assert!(matches!(
            qualify_s399_whole_scheduler_provider_preflight(ledger),
            Err(G8lS399WholeSchedulerProviderPreflightError::EligibilityDrift { .. })
        ));
    }
}

#[test]
fn idle_without_an_s245_request() {
    assert_eq!(
        preflight_s399_whole_scheduler_provider(S245_TARGET_CPU1, None),
        Ok(G8lS399WholeSchedulerProviderPreflightOutcome::Idle)
    );
}

#[test]
fn pending_request_becomes_provider_eligible_but_not_authoritative() {
    let state = pending();
    let view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    let outcome = preflight_s399_whole_scheduler_provider(S245_TARGET_CPU1, Some(view)).unwrap();
    let G8lS399WholeSchedulerProviderPreflightOutcome::ProviderPreflightReadyAwaitingAuthorityConstructor(
        receipt,
    ) = outcome
    else {
        panic!("S399 must produce the non-authoritative provider-preflight receipt");
    };
    assert_eq!(receipt.request_id(), 1);
    assert!(!receipt.request_taken());
    assert!(!receipt.is_provider_authority());
    assert!(!receipt.whole_scheduler_exclusion_proven());
}

#[test]
fn preflight_preserves_the_exact_pending_request() {
    let state = pending();
    let before = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    preflight_s399_whole_scheduler_provider(S245_TARGET_CPU1, Some(before)).unwrap();
    let after = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    assert_eq!(before, after);
    assert_eq!(state.pending_request_id(), Some(1));
}

#[test]
fn wrong_cpu_fails_closed_through_the_typed_s398_predecessor() {
    let state = pending();
    let view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    assert!(matches!(
        preflight_s399_whole_scheduler_provider(S245_SOURCE_CPU0, Some(view)),
        Err(G8lS399WholeSchedulerProviderPreflightError::S398(_))
    ));
}

#[test]
fn malformed_request_metadata_fails_closed_through_s398() {
    let state = pending();
    let mut view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    view.request_id = 0;
    assert!(matches!(
        preflight_s399_whole_scheduler_provider(S245_TARGET_CPU1, Some(view)),
        Err(G8lS399WholeSchedulerProviderPreflightError::S398(_))
    ));
}

#[test]
fn receipt_type_is_deliberately_not_copy_or_clone() {
    let source = module_source();
    let start = source
        .find("pub struct G8lS399WholeSchedulerProviderPreflightReceipt")
        .unwrap();
    let derive_start = source[..start].rfind("#[derive").unwrap();
    let derive = &source[derive_start..start];
    assert_eq!(derive.trim(), "#[derive(Debug, PartialEq, Eq)]");
}

#[test]
fn provider_preflight_does_not_acquire_the_shared_gate() {
    let source = module_source();
    for forbidden in [
        "S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE",
        "try_acquire_exclusive",
        "try_acquire_read",
        "G8lS247WholeSchedulerExclusiveLease",
    ] {
        assert!(
            !source.contains(forbidden),
            "forbidden acquisition: {forbidden}"
        );
    }
}

#[test]
fn provider_preflight_does_not_take_or_publish_authority() {
    let source = module_source();
    for forbidden in [
        "take_s245_exclusion_admission_request_on_cpu1",
        "request_state.take(",
        "publish_s244",
        "try_construct_s400",
        "G8lS400WholeSchedulerProviderAuthority",
    ] {
        assert!(
            !source.contains(forbidden),
            "forbidden authority: {forbidden}"
        );
    }
}

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

#[test]
fn production_service_inspects_the_request_only() {
    let source = module_source();
    assert!(source.contains("inspect_s245_exclusion_admission_request_on_cpu1"));
    assert_eq!(
        source
            .matches("inspect_s245_exclusion_admission_request_on_cpu1")
            .count(),
        1
    );
    assert!(!source.contains("take_s245_exclusion_admission_request_on_cpu1"));
}

#[test]
fn production_service_uses_the_exact_rpi5_aarch64_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()"));
}

#[test]
fn source_depends_directly_on_s398_and_not_on_the_old_s246_inventory() {
    let source = module_source();
    assert!(source.contains("s398_whole_scheduler_direct_access_coverage_reconciliation"));
    assert!(!source.contains("s245_whole_scheduler_exclusion_provider_preflight"));
    assert!(!source.contains("S246_DIRECT_SCHEDULER_ACCESS_SITES"));
    assert!(!source.contains("111"));
}

#[test]
fn source_names_s399_preflight_and_s400_constructor_as_separate_boundaries() {
    let normalized = module_source()
        .replace("//!", " ")
        .split_whitespace()
        .collect::<Vec<_>>()
        .join(" ");
    assert!(normalized.contains("S399 whole-scheduler provider preflight"));
    assert!(normalized.contains("S400 authority constructor remains open"));
}

#[test]
fn s399_module_and_all_predecessors_are_registered_separately() {
    let kernel = kernel_main_source();
    let simulation = simulation_lib_source();
    for sequence in 328..=399 {
        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_s399_whole_scheduler_provider_preflight";
    assert!(kernel.contains(&format!("mod {name};")));
    assert!(simulation.contains(&format!("pub mod {name};")));
}

#[test]
fn cpu1_service_is_ordered_after_s398_and_before_s242() {
    let source = exception_source();
    let s398 = source
        .find("service_s398_whole_scheduler_direct_access_coverage_reconciliation_on_cpu1")
        .unwrap();
    let s399 = source
        .find("service_s399_whole_scheduler_provider_preflight_on_cpu1")
        .unwrap();
    let s242 = source[s399..]
        .find("service_s242_sender_runtime_callsite_request_on_cpu1")
        .map(|offset| offset + s399)
        .unwrap();
    assert!(s398 < s399 && s399 < s242);
}

#[test]
fn s399_registers_the_exact_s400_through_s402_successor_chain() {
    let s400 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor";
    let s401 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s401_provider_authority_timer_callsite";
    let s402 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication";
    let kernel = kernel_main_source();
    let simulation = simulation_lib_source();
    assert!(kernel.contains(&format!("mod {s400};")));
    assert!(simulation.contains(&format!("pub mod {s400};")));
    assert!(kernel.contains(&format!("mod {s401};")));
    assert!(simulation.contains(&format!("pub mod {s401};")));
    assert!(kernel.contains(&format!("mod {s402};")));
    assert!(simulation.contains(&format!("pub mod {s402};")));
}

#[test]
fn predecessor_source_authorizes_only_the_exact_s399_successor() {
    let source = predecessor_source();
    assert!(source.contains("S399 provider preflight"));
    assert!(!source.contains("s399_whole_scheduler_provider_preflight"));
    assert!(!source.contains("s400_whole_scheduler"));
}

#[test]
fn source_keeps_request_authority_admission_runtime_and_exclusion_claims_false() {
    let source = module_source();
    for marker in [
        "S399_PROVIDER_PREFLIGHT_COMPLETE: bool = true",
        "S399_PRODUCTION_PROVIDER_AUTHORITY_SITES: usize = 0",
        "S399_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES: usize = 0",
        "S399_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0",
        "S399_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0",
        "S399_WHOLE_SCHEDULER_EXCLUSION_COMPLETE: bool = false",
    ] {
        assert!(source.contains(marker), "missing boundary marker: {marker}");
    }
}

  {
    id: "g8l-s399-whole-scheduler-provider-preflight-partial",
    date: "2026-08-30",
    sequence: 399,
    status: "passed",
    umbrella_status: "partial",
    title: "S399 · Whole-scheduler provider preflight",
    summary:
      "S399, S398'in uzlaştırdığı exact 7 audit unit / 113 direct scheduler access / 113 source-model covered / 113 production guarded / 0 unrouted sonucunu ve pending S245 request kimliğini ayrı G8lS399ProviderEligibilityLedger ile fail-closed doğrular. Pozitif sonuç private alanlı, non-Copy/non-Clone G8lS399WholeSchedulerProviderPreflightReceipt'tir; request_taken=false, is_provider_authority=false, admission_published=false ve whole_scheduler_exclusion_proven=false kalır. CPU1 production service S398'den sonra ve S242'den önce request'i yalnız inspect eder. S399 S247 lease almaz, scheduler'a erişmez, S245 request'i take etmez, S244 admission yayımlamaz ve provider constructor kurmaz. Provider preflight ready sites=1 ve provider preflight complete=true olur; provider authority=0, provider constructor=0, supported-profile runtime observation=0 ve whole-scheduler exclusion=false kalır. S400 ayrı authority-constructor kapısıdır.",
    evidence: [
      "Canonical S399 focused target ayrı S399 module source ve simulation export yokken compile RED verdi.",
      "İlk focused koşu exit 101 ile missing S399 include_str source ve unresolved simulation import'u birlikte gösterdi.",
      "S398'in 113/113 direct-access reconciliation sonucu S399 provider preflight yerine otomatik PASS sayılmadı.",
      "Ayrı S399 kernel source unit, simulation export ve CPU1 inspection service eklendikten sonra aynı focused target 23/23 PASS oldu.",
      "Focused final koşuda ignored veya filtered assertion yoktur.",
      "Focused constants_promote_only_provider_preflight_readiness testi preflight-ready=1 ile authority/constructor/publisher/runtime=0 ayrımını aynı assertion grubunda kilitler.",
      "Focused s398_is_the_exact_reconciled_predecessor testi S398'in beş coverage alanını S399 sabitleriyle tek tek eşler ve S398 provider-preflight bayrağının false kaldığını doğrular.",
      "Focused canonical_eligibility_ledger_returns_a_non_authoritative_receipt testi canonical request 41 üzerinde altı read-only ölçüyü ve dört negatif authority accessor'ını exact doğrular.",
      "Focused every_coverage_dimension_fails_closed_on_drift testi 7/113/113/113/0 ledger'ının beş bağımsız alanını birer kez bozup her sapmada EligibilityDrift bekler.",
      "Focused preflight_preserves_the_exact_pending_request testi S245 pending view ve pending_request_id değerlerini preflight öncesi/sonrası karşılaştırır.",
      "Focused production_service_inspects_the_request_only testi inspect çağrısını exact bir kez sayar ve take sembolünü kaynakta yasaklar.",
      "Focused s399_module_and_all_predecessors_are_registered_separately testi kernel ve simulation kayıtlarında S328–S399 aralığının tamamını sequence marker bazında doğrular.",
      "Focused s399_does_not_publish_the_s400_module_early testi hem kernel main hem simulation lib üzerinde _s400_ marker'ını reddeder.",
      "S399 provider-preflight module 10325 B / 3c62669680482840132ee550f4c71f0716fafb9061c6078c98d67a0d402b4cfc SHA-256'dır.",
      "S399 focused test source 13283 B / 8743f70c4aa4195c4f28b638def6481e29bece9913abbf88c762fa0b23bc9500 SHA-256'dır.",
      "G8lS399ProviderEligibilityLedger request id ve beş coverage boyutunu typed alanlarda taşır.",
      "Canonical ledger source audit units=7 değerini exact S398 predecessor'dan taşır.",
      "Canonical ledger direct scheduler access sites=113 değerini taşır.",
      "Canonical ledger source/model covered direct access sites=113 değerini taşır.",
      "Canonical ledger production guarded direct access sites=113 değerini taşır.",
      "Canonical ledger unrouted direct access sites=0 değerini taşır.",
      "request_id=0 MissingRequestId ile fail-closed reddedilir.",
      "Source audit unit drift 7→6 EligibilityDrift verir.",
      "Direct scheduler access drift 113→112 EligibilityDrift verir.",
      "Source/model covered direct-access drift 113→112 EligibilityDrift verir.",
      "Production guarded direct-access drift 113→112 EligibilityDrift verir.",
      "Unrouted direct-access drift 0→1 EligibilityDrift verir.",
      "Source/model covered total ile direct total exact eşitliği ayrıca doğrulanır.",
      "Production guarded total ile direct total exact eşitliği ayrıca doğrulanır.",
      "Source/model total ile production guarded total exact eşitliği ayrıca doğrulanır.",
      "G8lS399WholeSchedulerProviderPreflightReceipt private alanlıdır.",
      "Receipt derive listesi yalnız Debug, PartialEq ve Eq içerir; Copy veya Clone yoktur.",
      "Receipt request_id, 7/113/113/113/0 değerlerini read-only accessor'larla taşır.",
      "Receipt request_taken() exact false döndürür.",
      "Receipt is_provider_authority() exact false döndürür.",
      "Receipt admission_published() exact false döndürür.",
      "Receipt whole_scheduler_exclusion_proven() exact false döndürür.",
      "No-request yolu Idle döndürür ve receipt uydurmaz.",
      "Pending request ProviderPreflightReadyAwaitingAuthorityConstructor outcome'una dönüşür.",
      "Pending request view preflight öncesi ve sonrası exact aynı request id ile state içinde kalır.",
      "Wrong CPU çağrısı typed S398 predecessor zinciri üzerinden fail-closed reddedilir.",
      "Malformed request metadata typed S398 error zinciri üzerinden fail-closed reddedilir.",
      "S399_SOURCE_AUDIT_UNITS=7'dir.",
      "S399_DIRECT_SCHEDULER_ACCESS_SITES=113'tür.",
      "S399_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES=113'tür.",
      "S399_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES=113'tür.",
      "S399_UNROUTED_DIRECT_ACCESS_SITES=0'dır.",
      "S399_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE=true predecessor sonucudur.",
      "S399_PROVIDER_PREFLIGHT_READY_SITES=1'dir.",
      "S399_PROVIDER_PREFLIGHT_COMPLETE=true bu kapının tek pozitif kapanışıdır.",
      "S399_PRODUCTION_PROVIDER_AUTHORITY_SITES=0'dır.",
      "S399_PRODUCTION_PROVIDER_CONSTRUCTOR_SITES=0'dır.",
      "S399_PRODUCTION_ADMISSION_PUBLISHER_SITES=0'dır.",
      "S399_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS=0'dır.",
      "S399_WHOLE_SCHEDULER_EXCLUSION_COMPLETE=false'dur.",
      "S399 source S398 direct-access reconciliation module'üne doğrudan bağlıdır.",
      "S399 source tarihsel S246 inventory sabitlerinden provider readiness türetmez.",
      "S399 source S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE içermez.",
      "S399 source try_acquire_exclusive, try_acquire_read veya exclusive lease içermez.",
      "S399 source addr_of!, addr_of_mut! veya crate::task::scheduler içermez.",
      "S399 source take_s245 veya request_state.take içermez.",
      "S399 source publish_s244 içermez.",
      "S399 source try_construct_s400 veya G8lS400 authority type içermez.",
      "Production service exact target_arch=aarch64 + target_os=none + board-rpi5 cfg'si altındadır.",
      "Production service gerçek percpu identity sonucunu CPU1'e karşı doğrular.",
      "Production service inspect_s245_exclusion_admission_request_on_cpu1'i exact bir kez çağırır.",
      "Kernel main ve simulation lib exact uzun S399 module adını ayrı registration ile yayımlar.",
      "CPU1 timer service sırası service_s398... < service_s399... < service_s242... olarak sabitlenmiştir.",
      "Kernel main ve simulation lib içinde S400 module registration'ı yoktur.",
      "S399 module dokümanı S399 preflight ile S400 constructor sınırını açıkça ayırır.",
      "Selected regression final sonucu 5 grup / 94/94 PASS'tir.",
      "Selected gruplar S399 23/23, S398 21/21, S397 23/23, tarihsel S246 provider target 13/13 ve tarihsel dosya adı S246 olan S247 gate 14/14'tür.",
      "İlk selected turda S398 historical successor assertion 20/21 ile RED oldu.",
      "İlk selected turda S397 historical successor assertion 22/23 ile RED oldu.",
      "İki historical assertion yalnız exact yetkili S399 successor'a izin verecek biçimde düzeltildi; S400 prohibition korunur.",
      "S399-owned product, authority, exclusion veya coverage assertion'ı zayıflatılmadı.",
      "S398'in exact 162-target dependency listesi korunup yalnız S399 sona eklendi.",
      "İki S238–S399 dependency koşusunun her biri 163 grup / 4217/4217 PASS verdi.",
      "Dependency timing-normalized özetleri 15810 B ve byte-eşittir.",
      "Dependency canonical SHA-256 dd2aba50c4d925b4564b7d7e81805807543ec89e005ffe93c568a733864a8f54'tür.",
      "Dependency run1 raw 393285 B / a6149013e262e8bffae954ae4920cb89bcd5ff198adcb35c7fb374a849334d29 SHA-256'dır.",
      "Dependency run2 raw 376496 B / 092cfa6f1e811db5eec8c86168dcf07300b273dbc944aa5773e890a317407660 SHA-256'dır.",
      "Dependency artifact root /tmp/aselsanos-s399-dependency.KR8AhR'dir.",
      "Exact yedi tarihsel assertion filtered serial workspace audit 362 grup / 6104 PASS / 0 fail verdi.",
      "Filtered workspace raw 591919 B / addae1342292651ab0fd03394296183cb4568ab241c9f660c306a82aee255732 SHA-256'dır.",
      "Unfiltered workspace exit 101 ile 315 grup / 5849 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 560256 B / c6fd5d36af9b9e535c322148455eb7a4cea3de34dd952e4a5996f55375133721 SHA-256'dır.",
      "Workspace artifact root /tmp/aselsanos-s399-workspace.9dJlN6'dır.",
      "Global unfiltered workspace GREEN iddiası yapılmaz.",
      "cargo fmt --all -- --check exit 0 ve boş output verdi.",
      "git diff --check exit 0 ve boş output verdi.",
      "Dört fresh AArch64 profil 4/4 exit 0 verdi.",
      "QEMU profile warning/log/ELF 293 / 112090 B / 16814128 B'dir.",
      "QEMU ELF SHA-256 0e907fa3c72e1bb38efd6f89426347955bf0d6b0a9f2008eb01f28b4e958a1e8'dir.",
      "RPi4 profile warning/log/ELF 391 / 150995 B / 11925464 B'dir.",
      "RPi4 ELF SHA-256 48dba4790f5b0a2674eb77d760279ac6fabcbd082544cdf7d7c215a2b3983c58'dir.",
      "RPi5 profile warning/log/ELF 1579 / 687795 B / 15544136 B'dir.",
      "RPi5 ELF SHA-256 4c38de4ec95034eb6dc154d151fadc1117fbc70ad9a837c2f8a4a5f5ce9d1919'dur.",
      "RPi5+SMP profile warning/log/ELF 1579 / 687738 B / 15574992 B'dir.",
      "RPi5+SMP ELF SHA-256 4a5dbcf3c366aa9589738facf02393c3e5d99d4e062129c7b7ac2bafb136f3dc'dir.",
      "Profile artifact root /tmp/aselsanos-s399-profiles.4YLcKg'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 / 701dc74f459522cb3c1d18a78c11fe301367fdf5ff01fb27cc7c9a73fbcbc600 SHA-256'dır.",
      "QEMU artifact /tmp/aselsanos-s399-qemu.Cglzcq'dir.",
      "Board-QEMU common regression S399 CPU1 provider-preflight service runtime observation'ı değildir.",
      "Status manifest S399'u ayrı verification object, physical-zero list ve gate marker ile kaydeder.",
      "S399 proof docs/M8.1-RPi5-G8l-S399-Whole-Scheduler-Provider-Preflight-Proof.md altında ayrı dosyadır.",
      "Code publication hedefi S1–S399 399/399 unique karttır.",
      "S328 öncesi S1–S327 aralığı 327/327 ayrı kart olarak korunur.",
      "S1, S327, S328, S398 ve S399 exact birer kart; missing=none, duplicate=0 ve S400=0 olmalıdır.",
      "S399 Code kartı complete provider-preflight module, complete focused target, complete Operations record ve proof katmanlarını ayrı göstermelidir.",
      "S399 writer-guard veya provider-authority kartı olarak yanlış etiketlenmemelidir.",
      "İlk production publication öncesi generated Code registry S1–S399 aralığında 399/399 unique gate ve 1161 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 + 228 focused-test + 94 command-contract + 8 operation-record = 399'dur.",
      "İlk generated JSON 9244764 B / 2bed40717a53993b33bfeb5a08cf45700811fc843f735f9b02325be5417ef87f dosya SHA-256 taşıdı.",
      "İlk registry semantic SHA-256 9ad6eddff536129d66dd9bf18b5560782ebe5543ae0efd26b8ac6756f8db2861'dir.",
      "S399 Code kartı complete-file provider-preflight implementation, complete-file 23-test target ve complete Operations record olmak üzere üç exact excerpt yayımlar.",
      "S399 Code compatibility alanlarında sourceBound=true, testBound=true ve implementationSequenceBound=true korunur.",
      "İlk website kabulü 733/733 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ı 238 data-gate-policy kartı taşır.",
      "İlk yayın öncesi S399 core policy 11810 karakter / 12168 UTF-8 byte, 120 evidence, 4 terminal session ve 10 limitation taşır.",
      "İlk production/main deployment a14fd7cd-609d-476f-a42e-3dce42fe32f1 ile https://a14fd7cd.aselsan-microkernel.pages.dev adresine 115 upload + 84 existing = 199 asset ve _headers yayımladı.",
      "Wrangler production deployment-list kaydı 9509 B / 8af17f424153a11392983216312661661afd888f29203ddee35704bf70f77ea7 SHA-256'dır.",
      "Cache-busted custom-domain /code/ 25770281 B / 7f9b9428d1f5fc934c83d7b323a826fb44ef42913f4ad465853d8c7eb7a60d23 SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /operations/ 16222707 B / c1b1fd2445f0afe65d3666587cc3119b12ad5d761fb6bcb7b43a36bf0fc0f0ec SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /timeline/ 6888374 B / e1f1da52a7aba3bbbdb75b48b6ebe53917e294ce118608ee75e00d9663681cdc SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Cache-busted custom-domain /yol-haritasi/ 6888122 B / 93f38f0be0729bb39d0a85c5f34ba1286916102c5e4bbba5f3c52bfa139c7a3d SHA-256 ile HTTP 200 ve deployment out'una byte-exact=true verdi.",
      "Canlı Code literal gate labels total=399, unique=399, pre-S328=327; S1/S327/S328/S398/S399 exact birer ve S400=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-s399-readback-initial.4Fd9yY'dir.",
      "İlk yayın kanıtını taşıyan Operations/Timeline/Code payload'ı ayrı evidence-sync deployment transaction'ında yayımlanır.",
      "S399 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_S399=NO; fiziksel RPi5 runtime veya device acceptance iddiası yoktur.",
      "Bağlayıcı olmayan S399 projeksiyonu R1 S399–S429, R2 S454–S504, R3 S583+, risk aralığı S559–S609 ve merkez yaklaşık S584'tür.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight -- --test-threads=1",
      "run S399, S398, S397, historical-filename S246 provider-preflight and S247 shared-gate targets serially",
      "run S238-S399 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",
      "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: "s399-focused-provider-preflight",
        title: "S399 focused provider-preflight qualification",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight -- --test-threads=1",
        ],
        outputLines: [
          "initial test result: compile RED; S399 source and simulation export absent; exit 101",
          "final test result: ok; S399 focused 1 group / 23 passed / 0 failed",
          "receipt: non-Copy/non-Clone; request taken=false; authority=false; admission=false; exclusion=false",
          "S400 module/provider constructor remains absent",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s399-selected-regression",
        title: "S399 selected provider-boundary regression",
        commandLines: [
          "run S399, S398, S397, historical-filename S246 provider-preflight and S247 shared-gate targets serially",
        ],
        outputLines: [
          "initial historical source assertions: S398 20/21 RED and S397 22/23 RED",
          "fixed predecessor-only contracts: exact S399 allowed; S400 remains prohibited",
          "final result: 5 groups / 94 passed / 0 failed",
          "S399-owned product/authority/exclusion assertions weakened=false",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s399-full-acceptance",
        title: "S399 dependency, workspace, profiles and QEMU acceptance",
        commandLines: [
          "run S238-S399 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 163 groups / 4217/4217 twice; normalized 15810-byte summaries byte-identical",
          "filtered workspace 362 groups / 6104 PASS / 7 historical filtered",
          "unfiltered workspace frozen-S96 RED after 315 groups / 5849 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 S399 runtime observation",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s399-production-publication",
        title: "S399 Operations/Timeline/Code production publication",
        commandLines: [
          "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 733/733 PASS; lint PASS; TypeScript exit 0 with empty output; static routes 24/24",
          "registry S1-S399: 399/399 gates; 1161 exact excerpts; S1-S327 327/327; missing=0; duplicate=0",
          "deployment a14fd7cd-609d-476f-a42e-3dce42fe32f1; 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=399, unique=399, pre-S328=327, S399=1 and S400=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "TAM ÇIKTI oturumları compile RED→23/23 focused geçişini, iki predecessor-only assertion düzeltmesini, 94/94 seçili regresyonu, iki kez 4217/4217 dependency tekrarını, filtered/unfiltered workspace ayrımını, dört fresh profili, QEMU kabulünü ve production publication/readback'i birbirine karıştırmadan taşır. S399 yalnız provider preflight'tır; S400 authority constructor ayrı kapıdır.",
    limitations: [
      "S245 request pending ve unconsumed kalır.",
      "S399 receipt yalnız eligibility evidence'dır; provider authority değildir.",
      "S399 S247 lease almaz ve scheduler access yapmaz.",
      "S244 admission publication yapılmaz.",
      "S400 production provider-authority constructor henüz yoktur.",
      "Whole-scheduler exclusion complete değildir.",
      "Supported-profile S399 runtime observation=0'dır.",
      "Ortak QEMU regresyonu S399 production service 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_S399=NO.",
    ],
  },