S398 · Whole-scheduler direct-access coverage reconciliation

#![allow(unexpected_cfgs)]

//! S398 whole-scheduler direct-access coverage reconciliation.
//!
//! S397 reconciled all 69 production writers against the independent S327
//! source inventory. S398 closes the next, wider accounting boundary: all 113
//! direct scheduler accesses must be represented on both sides as 44 immutable
//! reads plus 69 writers. The source/model partition and the production-guarded
//! partition are checked independently before either may equal the 113-site
//! direct surface. No S398 writer is created and the shared S247 gate is not
//! acquired here. The S245 request remains inspect-only. S399 provider preflight
//! remains open, along with admission publication, provider construction,
//! supported-profile runtime observation and 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_s397_whole_scheduler_writer_coverage_reconciliation::{
    preflight_s397_whole_scheduler_writer_coverage_reconciliation,
    G8lS397WriterCoverageReconciliationError, G8lS397WriterCoverageReconciliationOutcome,
    S397_DIRECT_SCHEDULER_ACCESS_SITES, S397_GUARDED_READ_SITES,
    S397_MUTABLE_SOURCE_UNITS, S397_OPEN_PRODUCTION_WRITER_SITES,
    S397_PRODUCTION_GUARDED_WRITER_SITES, S397_PRODUCTION_WRITER_ACQUIRE_SITES,
    S397_SOURCE_AUDIT_UNITS, S397_SOURCE_IMMUTABLE_READ_SITES,
    S397_SOURCE_MODEL_COVERED_WRITER_SITES, S397_TOTAL_WRITER_SITES,
};

pub const S398_SOURCE_AUDIT_UNITS: usize = S397_SOURCE_AUDIT_UNITS;
pub const S398_MUTABLE_SOURCE_UNITS: usize = S397_MUTABLE_SOURCE_UNITS;
pub const S398_DIRECT_SCHEDULER_ACCESS_SITES: usize = S397_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S398_SOURCE_IMMUTABLE_READ_SITES: usize = S397_SOURCE_IMMUTABLE_READ_SITES;
pub const S398_SOURCE_MODEL_COVERED_WRITER_SITES: usize = S397_SOURCE_MODEL_COVERED_WRITER_SITES;
pub const S398_TOTAL_WRITER_SITES: usize = S397_TOTAL_WRITER_SITES;
pub const S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S398_SOURCE_IMMUTABLE_READ_SITES + S398_SOURCE_MODEL_COVERED_WRITER_SITES;
pub const S398_GUARDED_READ_SITES: usize = S397_GUARDED_READ_SITES;
pub const S398_PRODUCTION_GUARDED_WRITER_SITES: usize = S397_PRODUCTION_GUARDED_WRITER_SITES;
pub const S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S398_GUARDED_READ_SITES + S398_PRODUCTION_GUARDED_WRITER_SITES;
pub const S398_UNROUTED_DIRECT_ACCESS_SITES: usize =
    S398_DIRECT_SCHEDULER_ACCESS_SITES - S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S398_DISTINCT_WRITER_GATE_MODULES: usize = S397_TOTAL_WRITER_SITES;
pub const S398_PRODUCTION_WRITER_ACQUIRE_SITES: usize = S397_PRODUCTION_WRITER_ACQUIRE_SITES;
pub const S398_PRODUCTION_PROVIDER_AUTHORITY_SITES: usize = 0;
pub const S398_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S398_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S398_WRITER_COVERAGE_RECONCILIATION_COMPLETE: bool = true;
pub const S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE: bool = true;
pub const S398_PROVIDER_PREFLIGHT_COMPLETE: bool = false;
pub const S398_WHOLE_SCHEDULER_EXCLUSION_COMPLETE: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS398DirectAccessCoverageLedger {
    pub source_audit_units: usize,
    pub direct_scheduler_access_sites: usize,
    pub source_immutable_read_sites: usize,
    pub source_model_covered_writer_sites: usize,
    pub source_model_covered_direct_access_sites: usize,
    pub guarded_read_sites: usize,
    pub production_guarded_writer_sites: usize,
    pub production_guarded_direct_access_sites: usize,
    pub unrouted_direct_access_sites: usize,
}

impl G8lS398DirectAccessCoverageLedger {
    pub const fn canonical() -> Self {
        Self {
            source_audit_units: S398_SOURCE_AUDIT_UNITS,
            direct_scheduler_access_sites: S398_DIRECT_SCHEDULER_ACCESS_SITES,
            source_immutable_read_sites: S398_SOURCE_IMMUTABLE_READ_SITES,
            source_model_covered_writer_sites: S398_SOURCE_MODEL_COVERED_WRITER_SITES,
            source_model_covered_direct_access_sites: S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
            guarded_read_sites: S398_GUARDED_READ_SITES,
            production_guarded_writer_sites: S398_PRODUCTION_GUARDED_WRITER_SITES,
            production_guarded_direct_access_sites: S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
            unrouted_direct_access_sites: S398_UNROUTED_DIRECT_ACCESS_SITES,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS398DirectAccessCoverageReceipt {
    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,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS398DirectAccessCoverageReconciliationOutcome {
    Idle,
    DirectAccessCoverageReconciledAwaitingProviderPreflight {
        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,
    },
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS398DirectAccessCoverageReconciliationError {
    S397(G8lS397WriterCoverageReconciliationError),
    S245(G8lS245ExclusionAdmissionRequestError),
    PredecessorDrift {
        source_audit_units: usize,
        mutable_source_units: usize,
        guarded_read_sites: usize,
        source_model_covered_writer_sites: usize,
        production_guarded_writer_sites: usize,
        open_writer_sites: usize,
        distinct_writer_gate_modules: usize,
        production_writer_acquire_sites: usize,
    },
    InventoryDrift {
        observed: G8lS398DirectAccessCoverageLedger,
        expected: G8lS398DirectAccessCoverageLedger,
    },
}

pub fn reconcile_s398_direct_access_coverage(
    ledger: G8lS398DirectAccessCoverageLedger,
) -> Result<G8lS398DirectAccessCoverageReceipt, G8lS398DirectAccessCoverageReconciliationError> {
    let expected = G8lS398DirectAccessCoverageLedger::canonical();
    let source_partition =
        ledger.source_immutable_read_sites + ledger.source_model_covered_writer_sites;
    let production_partition = ledger.guarded_read_sites + ledger.production_guarded_writer_sites;
    let dimensions_are_exact = ledger == expected
        && source_partition == ledger.source_model_covered_direct_access_sites
        && production_partition == ledger.production_guarded_direct_access_sites
        && 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 !dimensions_are_exact {
        return Err(
            G8lS398DirectAccessCoverageReconciliationError::InventoryDrift {
                observed: ledger,
                expected,
            },
        );
    }
    Ok(G8lS398DirectAccessCoverageReceipt {
        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_s398_whole_scheduler_direct_access_coverage_reconciliation(
    caller_cpu: usize,
    request: Option<G8lS245WholeSchedulerExclusionAdmissionRequestView>,
) -> Result<
    G8lS398DirectAccessCoverageReconciliationOutcome,
    G8lS398DirectAccessCoverageReconciliationError,
> {
    match preflight_s397_whole_scheduler_writer_coverage_reconciliation(caller_cpu, request)
        .map_err(G8lS398DirectAccessCoverageReconciliationError::S397)?
    {
        G8lS397WriterCoverageReconciliationOutcome::Idle => {
            Ok(G8lS398DirectAccessCoverageReconciliationOutcome::Idle)
        }
        G8lS397WriterCoverageReconciliationOutcome::WriterCoverageReconciledAwaitingDirectAccessReconciliation {
            request_id,
            source_audit_units,
            mutable_source_units,
            guarded_read_sites,
            source_model_covered_writer_sites,
            production_guarded_writer_sites,
            open_writer_sites,
            distinct_writer_gate_modules,
            production_writer_acquire_sites,
        } => {
            if source_audit_units != S398_SOURCE_AUDIT_UNITS
                || mutable_source_units != S398_MUTABLE_SOURCE_UNITS
                || guarded_read_sites != S398_GUARDED_READ_SITES
                || source_model_covered_writer_sites
                    != S398_SOURCE_MODEL_COVERED_WRITER_SITES
                || production_guarded_writer_sites
                    != S398_PRODUCTION_GUARDED_WRITER_SITES
                || open_writer_sites != S397_OPEN_PRODUCTION_WRITER_SITES
                || distinct_writer_gate_modules != S398_DISTINCT_WRITER_GATE_MODULES
                || production_writer_acquire_sites != S398_PRODUCTION_WRITER_ACQUIRE_SITES
            {
                return Err(
                    G8lS398DirectAccessCoverageReconciliationError::PredecessorDrift {
                        source_audit_units,
                        mutable_source_units,
                        guarded_read_sites,
                        source_model_covered_writer_sites,
                        production_guarded_writer_sites,
                        open_writer_sites,
                        distinct_writer_gate_modules,
                        production_writer_acquire_sites,
                    },
                );
            }
            let receipt = reconcile_s398_direct_access_coverage(
                G8lS398DirectAccessCoverageLedger::canonical(),
            )?;
            Ok(
                G8lS398DirectAccessCoverageReconciliationOutcome::DirectAccessCoverageReconciledAwaitingProviderPreflight {
                    request_id,
                    source_audit_units: receipt.source_audit_units,
                    direct_scheduler_access_sites: receipt.direct_scheduler_access_sites,
                    source_model_covered_direct_access_sites:
                        receipt.source_model_covered_direct_access_sites,
                    production_guarded_direct_access_sites:
                        receipt.production_guarded_direct_access_sites,
                    unrouted_direct_access_sites: receipt.unrouted_direct_access_sites,
                },
            )
        }
    }
}

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

    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
            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(G8lS398DirectAccessCoverageReconciliationError::S245)?;
    preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(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_s397_whole_scheduler_writer_coverage_reconciliation::{
    S397_DIRECT_SCHEDULER_ACCESS_SITES, S397_GUARDED_READ_SITES,
    S397_OPEN_PRODUCTION_WRITER_SITES, S397_PRODUCTION_GUARDED_WRITER_SITES,
    S397_PRODUCTION_WRITER_ACQUIRE_SITES, S397_SOURCE_AUDIT_UNITS,
    S397_SOURCE_IMMUTABLE_READ_SITES, S397_SOURCE_MODEL_COVERED_WRITER_SITES,
    S397_TOTAL_WRITER_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation::*;

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_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")
}

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

fn scheduler_source() -> &'static str {
    include_str!("../../kernel/src/task/scheduler.rs")
}

fn capability_source() -> &'static str {
    include_str!("../../kernel/src/ui/capability.rs")
}

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

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

fn macro_sites(source: &str) -> (usize, usize) {
    let compact = source
        .chars()
        .filter(|character| !character.is_whitespace())
        .collect::<String>();
    let count = |needle: &str| {
        compact
            .match_indices(needle)
            .filter(|(offset, _)| {
                compact[*offset..]
                    .split(')')
                    .next()
                    .unwrap_or("")
                    .contains("SCHEDULER")
            })
            .count()
    };
    (count("addr_of!("), count("addr_of_mut!("))
}

fn seven_audit_units() -> [&'static str; 7] {
    [
        exception_source(),
        current_task_source(),
        request_publication_source(),
        kernel_main_source(),
        scheduler_source(),
        capability_source(),
        user_copy_source(),
    ]
}

fn five_mutable_sources() -> [&'static str; 5] {
    [
        current_task_source(),
        scheduler_source(),
        capability_source(),
        exception_source(),
        kernel_main_source(),
    ]
}

#[test]
fn constants_reconcile_all_one_hundred_thirteen_direct_accesses_only() {
    assert_eq!(S398_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S398_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S398_SOURCE_IMMUTABLE_READ_SITES, 44);
    assert_eq!(S398_SOURCE_MODEL_COVERED_WRITER_SITES, 69);
    assert_eq!(S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S398_GUARDED_READ_SITES, 44);
    assert_eq!(S398_PRODUCTION_GUARDED_WRITER_SITES, 69);
    assert_eq!(S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S398_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert!(S398_WRITER_COVERAGE_RECONCILIATION_COMPLETE);
    assert!(S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE);
    assert!(!S398_PROVIDER_PREFLIGHT_COMPLETE);
    assert_eq!(S398_PRODUCTION_PROVIDER_AUTHORITY_SITES, 0);
    assert_eq!(S398_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert_eq!(S398_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert!(!S398_WHOLE_SCHEDULER_EXCLUSION_COMPLETE);
}

#[test]
fn s397_predecessor_is_the_exact_writer_and_access_input() {
    assert_eq!(S397_SOURCE_AUDIT_UNITS, S398_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S397_DIRECT_SCHEDULER_ACCESS_SITES,
        S398_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S397_SOURCE_IMMUTABLE_READ_SITES,
        S398_SOURCE_IMMUTABLE_READ_SITES
    );
    assert_eq!(S397_GUARDED_READ_SITES, S398_GUARDED_READ_SITES);
    assert_eq!(
        S397_SOURCE_MODEL_COVERED_WRITER_SITES,
        S398_SOURCE_MODEL_COVERED_WRITER_SITES
    );
    assert_eq!(S397_TOTAL_WRITER_SITES, S398_TOTAL_WRITER_SITES);
    assert_eq!(
        S397_PRODUCTION_GUARDED_WRITER_SITES,
        S398_PRODUCTION_GUARDED_WRITER_SITES
    );
    assert_eq!(S397_OPEN_PRODUCTION_WRITER_SITES, 0);
    assert_eq!(S397_PRODUCTION_WRITER_ACQUIRE_SITES, 74);
}

#[test]
fn canonical_ledger_reconciles_to_a_typed_direct_access_receipt() {
    assert_eq!(
        reconcile_s398_direct_access_coverage(G8lS398DirectAccessCoverageLedger::canonical()),
        Ok(G8lS398DirectAccessCoverageReceipt {
            source_audit_units: 7,
            direct_scheduler_access_sites: 113,
            source_model_covered_direct_access_sites: 113,
            production_guarded_direct_access_sites: 113,
            unrouted_direct_access_sites: 0,
        })
    );
}

#[test]
fn every_independent_direct_access_ledger_dimension_fails_closed_on_drift() {
    let canonical = G8lS398DirectAccessCoverageLedger::canonical();
    let drifts = [
        G8lS398DirectAccessCoverageLedger {
            source_audit_units: 6,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            direct_scheduler_access_sites: 112,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            source_immutable_read_sites: 43,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            source_model_covered_writer_sites: 68,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            source_model_covered_direct_access_sites: 112,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            guarded_read_sites: 43,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            production_guarded_writer_sites: 68,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            production_guarded_direct_access_sites: 112,
            ..canonical
        },
        G8lS398DirectAccessCoverageLedger {
            unrouted_direct_access_sites: 1,
            ..canonical
        },
    ];
    for ledger in drifts {
        assert!(matches!(
            reconcile_s398_direct_access_coverage(ledger),
            Err(G8lS398DirectAccessCoverageReconciliationError::InventoryDrift { .. })
        ));
    }
}

#[test]
fn idle_without_s245_request() {
    assert_eq!(
        preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
            S245_TARGET_CPU1,
            None
        ),
        Ok(G8lS398DirectAccessCoverageReconciliationOutcome::Idle)
    );
}

#[test]
fn pending_request_reports_reconciled_direct_accesses_and_preserves_s399_boundary() {
    let state = pending();
    let view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    assert_eq!(
        preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
            S245_TARGET_CPU1,
            Some(view)
        ),
        Ok(
            G8lS398DirectAccessCoverageReconciliationOutcome::DirectAccessCoverageReconciledAwaitingProviderPreflight {
                request_id: 1,
                source_audit_units: 7,
                direct_scheduler_access_sites: 113,
                source_model_covered_direct_access_sites: 113,
                production_guarded_direct_access_sites: 113,
                unrouted_direct_access_sites: 0,
            }
        )
    );
}

#[test]
fn preflight_never_consumes_the_s245_request() {
    let state = pending();
    let view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
        S245_TARGET_CPU1,
        Some(view),
    )
    .unwrap();
    assert_eq!(state.pending_request_id(), Some(1));
}

#[test]
fn wrong_cpu_fails_closed_through_the_typed_s397_predecessor() {
    let state = pending();
    let view = state.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    assert!(matches!(
        preflight_s398_whole_scheduler_direct_access_coverage_reconciliation(
            S245_SOURCE_CPU0,
            Some(view)
        ),
        Err(G8lS398DirectAccessCoverageReconciliationError::S397(_))
    ));
}

#[test]
fn live_source_inventory_is_exactly_forty_four_reads_plus_sixty_nine_writers() {
    let (reads, writers) = seven_audit_units().into_iter().map(macro_sites).fold(
        (0, 0),
        |(read_total, writer_total), (unit_reads, unit_writers)| {
            (read_total + unit_reads, writer_total + unit_writers)
        },
    );
    assert_eq!((reads, writers), (44, 69));
    assert_eq!(reads + writers, 113);
}

#[test]
fn source_and_production_partitions_independently_cover_the_same_direct_surface() {
    assert_eq!(
        S398_SOURCE_IMMUTABLE_READ_SITES + S398_SOURCE_MODEL_COVERED_WRITER_SITES,
        S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S398_GUARDED_READ_SITES + S398_PRODUCTION_GUARDED_WRITER_SITES,
        S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S398_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S398_DIRECT_SCHEDULER_ACCESS_SITES
    );
}

#[test]
fn all_sixty_nine_writer_memberships_remain_distinct_under_direct_reconciliation() {
    let sources = five_mutable_sources();
    for sequence in 328..=396 {
        let marker = format!("acquire_s{sequence}_production_scheduler_writer_access");
        assert!(
            sources.iter().any(|source| source.contains(&marker)),
            "missing production membership marker {marker}"
        );
    }
}

#[test]
fn no_s398_writer_acquire_is_invented_by_a_direct_access_reconciliation_gate() {
    for source in five_mutable_sources() {
        assert!(!source.contains("acquire_s398_production_scheduler_writer_access"));
    }
    assert!(!module_source().contains("acquire_s398_production_scheduler_writer_access"));
}

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

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

#[test]
fn cpu1_service_only_inspects_and_never_takes_the_request() {
    let source = module_source();
    assert!(source.contains("inspect_s245_exclusion_admission_request_on_cpu1"));
    assert!(!source.contains("take_s245_exclusion_admission_request"));
    assert!(!source.contains("request_state.take("));
}

#[test]
fn direct_reconciliation_source_cannot_mutate_or_acquire_the_scheduler() {
    let source = module_source();
    for forbidden in [
        "addr_of_mut!(",
        "S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE",
        "try_acquire_exclusive",
        "try_construct_s400",
        "publish_s244",
        "ProviderAuthority",
    ] {
        assert!(!source.contains(forbidden), "forbidden source: {forbidden}");
    }
}

#[test]
fn source_names_s398_as_direct_reconciliation_and_s399_as_the_next_boundary() {
    let normalized = module_source()
        .replace("//!", " ")
        .split_whitespace()
        .collect::<Vec<_>>()
        .join(" ");
    assert!(normalized.contains("S398"));
    assert!(normalized.contains("direct-access coverage reconciliation"));
    assert!(normalized.contains("S399 provider preflight remains open"));
}

#[test]
fn source_does_not_claim_provider_admission_runtime_or_exclusion_completion() {
    let source = module_source();
    assert!(source.contains("S398_WRITER_COVERAGE_RECONCILIATION_COMPLETE: bool = true"));
    assert!(source.contains("S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE: bool = true"));
    assert!(source.contains("S398_PROVIDER_PREFLIGHT_COMPLETE: bool = false"));
    assert!(source.contains("S398_PRODUCTION_PROVIDER_AUTHORITY_SITES: usize = 0"));
    assert!(source.contains("S398_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0"));
    assert!(source.contains("S398_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0"));
    assert!(source.contains("S398_WHOLE_SCHEDULER_EXCLUSION_COMPLETE: bool = false"));
}

#[test]
fn source_depends_on_s397_without_skipping_back_to_the_writer_chain() {
    let source = module_source();
    assert!(source.contains("s397_whole_scheduler_writer_coverage_reconciliation"));
    assert!(!source.contains("s396_qemu_s136"));
    assert!(!source.contains("s335_s400"));
    assert!(!source.contains("writer_stage("));
}

#[test]
fn production_service_uses_exact_rpi5_aarch64_cfg() {
    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 s398_registers_the_exact_s399_through_s402_successor_chain() {
    let kernel = kernel_main_source();
    let simulation = simulation_lib_source();
    let s399 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s399_whole_scheduler_provider_preflight";
    assert!(kernel.contains(&format!("mod {s399};")));
    assert!(simulation.contains(&format!("pub mod {s399};")));
    let s400 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s400_whole_scheduler_provider_authority_constructor";
    assert!(kernel.contains(&format!("mod {s400};")));
    assert!(simulation.contains(&format!("pub mod {s400};")));
    let s401 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s401_provider_authority_timer_callsite";
    assert!(kernel.contains(&format!("mod {s401};")));
    assert!(simulation.contains(&format!("pub mod {s401};")));
    let s402 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication";
    assert!(kernel.contains(&format!("mod {s402};")));
    assert!(simulation.contains(&format!("pub mod {s402};")));
}

  {
    id: "g8l-s398-whole-scheduler-direct-access-coverage-reconciliation-partial",
    date: "2026-08-30",
    sequence: 398,
    status: "passed",
    umbrella_status: "partial",
    title: "S398 · Whole-scheduler direct-access coverage reconciliation",
    summary:
      "S398 yeni bir scheduler erişimi veya lease domain'i eklemez; S397'nin uzlaştırılmış 44 immutable read + 69 mutable writer envanterini iki bağımsız partition üzerinden 113/113 whole-scheduler direct-access kapsamına kapatır. Source/model tarafı 44 source read + 69 source/model writer = 113/113, production tarafı 44 guarded reader + 69 guarded writer = 113/113 ve unrouted direct access=0'dır. Ayrı G8lS398DirectAccessCoverageLedger ve typed receipt her boyutu, iki toplamı ve iki tarafın birbirine eşitliğini fail-closed doğrular. CPU1 service S397'den sonra ve S242'den önce yalnız S245 request view inspect eder; request alınmaz. S398 S247 acquire etmez, mutable SCHEDULER aliası kurmaz, S244 admission yayımlamaz ve provider authority oluşturmaz. Writer reconciliation=true ve direct-access reconciliation=true olur; provider preflight=false, production provider authority=0 ve whole-scheduler exclusion=false kalır. S399 provider preflight ve S400 constructor ayrı kapılardır; supported-profile runtime observation=0'dır.",
    evidence: [
      "Canonical S398 focused target ayrı S398 module source ve simulation export yokken compile RED verdi.",
      "İlk focused koşu exit 101 ile missing S398 include_str source ve unresolved simulation import'u birlikte gösterdi.",
      "S397'nin 69/69 writer sonucu S398 direct-access reconciliation yerine otomatik PASS sayılmadı.",
      "Ayrı S398 kernel source unit, simulation export ve CPU1 inspection service eklendikten sonra aynı focused target 21/21 PASS oldu.",
      "Focused final koşuda ignored veya filtered assertion yoktur.",
      "S398 reconciliation module 12060 B / b894e10b5eddef657c4a1c4326152f67047bef24c2b30f3127219a78399cb3a4 SHA-256'dır.",
      "S398 focused test source 15421 B / c034ded7a8ee7b3240b12eea330593f052ea558bb4fab50a9bfd5d6c15521929 SHA-256'dır.",
      "G8lS398DirectAccessCoverageLedger source/model ve production coverage boyutlarını ayrı typed alanlarda taşır.",
      "G8lS398DirectAccessCoverageReceipt yalnız bütün canonical boyutlar ve partition eşitlikleri sağlandığında üretilir.",
      "Source audit unit drift 7→6 InventoryDrift verir.",
      "Direct scheduler access drift 113→112 InventoryDrift verir.",
      "Source immutable read drift 44→43 InventoryDrift verir.",
      "Source/model covered writer drift 69→68 InventoryDrift verir.",
      "Source/model covered direct-access drift 113→112 InventoryDrift verir.",
      "Guarded reader drift 44→43 InventoryDrift verir.",
      "Production guarded writer drift 69→68 InventoryDrift verir.",
      "Production guarded direct-access drift 113→112 InventoryDrift verir.",
      "Unrouted direct-access drift 0→1 InventoryDrift verir.",
      "Source partition 44 + 69 = 113 exact ayrı doğrulanır.",
      "Production partition 44 + 69 = 113 exact ayrı doğrulanır.",
      "Source/model direct total ile production guarded direct total exact 113 olarak birbirine eşitlenir.",
      "Her iki bağımsız total canonical direct_scheduler_access_sites=113 ile ayrıca eşitlenir.",
      "S398_SOURCE_AUDIT_UNITS=7'dir.",
      "S398_MUTABLE_SOURCE_UNITS=5 yalnız predecessor reconciliation carry-forward alanıdır.",
      "S398_DIRECT_SCHEDULER_ACCESS_SITES=113'tür.",
      "S398_SOURCE_IMMUTABLE_READ_SITES=44'tür.",
      "S398_SOURCE_MODEL_COVERED_WRITER_SITES=69'dur.",
      "S398_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES=113'tür.",
      "S398_GUARDED_READ_SITES=44'tür.",
      "S398_PRODUCTION_GUARDED_WRITER_SITES=69'dur.",
      "S398_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES=113'tür.",
      "S398_UNROUTED_DIRECT_ACCESS_SITES=0'dır.",
      "S398_DISTINCT_WRITER_GATE_MODULES=69 predecessor kimliğini korur.",
      "S398_PRODUCTION_WRITER_ACQUIRE_SITES=74 beş resume handoff'u dahil ham marker sayısını korur.",
      "Yedi live source unit yeniden tarandığında exact 44 addr_of scheduler read ve 69 addr_of_mut scheduler writer bulunur.",
      "Live source recount toplamı exact 113'tür.",
      "İki audit-only kaynak writer-free kalır.",
      "Beş mutable kaynak unit'i S397'nin exact 1/29/14/8/17 partition'ını korur.",
      "S398_WRITER_COVERAGE_RECONCILIATION_COMPLETE=true predecessor sonucudur.",
      "S398_DIRECT_ACCESS_COVERAGE_RECONCILIATION_COMPLETE=true bu kapının yeni ve tek pozitif kapanışıdır.",
      "S398_PROVIDER_PREFLIGHT_COMPLETE=false S399 sınırını korur.",
      "S398_PRODUCTION_PROVIDER_AUTHORITY_SITES=0'dır.",
      "S398_PRODUCTION_ADMISSION_PUBLISHER_SITES=0'dır.",
      "S398_WHOLE_SCHEDULER_EXCLUSION_COMPLETE=false'dur.",
      "S398_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS=0'dır.",
      "Pending S245 request view preflight öncesi ve sonrası aynı request id ile state içinde kalır.",
      "No-request yolu Idle döndürür ve reconciliation receipt uydurmaz.",
      "Wrong CPU çağrısı typed S397 predecessor zinciri üzerinden fail-closed reddedilir.",
      "Pending request outcome adı DirectAccessCoverageReconciledAwaitingProviderPreflight olarak S399'u açık taşır.",
      "Outcome request id yanında 7 source unit, 113 direct, 113 source/model, 113 production ve 0 unrouted değerlerini typed taşır.",
      "S397 predecessor outcome'daki source units, mutable units, reads, writers, open writers, distinct gate ve acquire değerleri tekrar doğrulanır.",
      "Predecessor boyutlarından herhangi biri drift ederse PredecessorDrift typed hatası üretilir.",
      "G8lS398DirectAccessCoverageReconciliationError S397 ve S245 hatalarını ayrı variant'larda korur.",
      "Kernel main ve simulation lib exact uzun S398 module adını ayrı registration ile yayımlar.",
      "CPU1 timer service sırası service_s397... < service_s398... < service_s242... olarak sabitlenmiştir.",
      "CPU1 service gerçek percpu identity sonucunu doğrular.",
      "CPU1 service yalnız inspect_s245_exclusion_admission_request_on_cpu1 çağrısı yapar.",
      "Production service exact target_arch=aarch64 + target_os=none + board-rpi5 cfg'si altındadır.",
      "S398 source addr_of_mut! veya mutable SCHEDULER aliası içermez.",
      "S398 source try_acquire_exclusive veya S247 production static gate sembolü içermez.",
      "S398 source acquire_s398_production_scheduler_writer_access içermez.",
      "S398 source request_state.take veya take_s245_exclusion_admission_request içermez.",
      "S398 source publish_s244 veya admission publisher içermez.",
      "S398 source try_construct_s400 veya provider constructor içermez.",
      "S398 source S399/S400 module import veya service çağrısı içermez.",
      "S398 reconciliation yalnız sayısal toplam doğrulamaz: source-side read/writer kökenleri ile production-side guard üyeliklerini iki ayrı authority sınıfı olarak tutar.",
      "Source/model partition doğruluğu production gate sabitlerinden türetilmeden S327/S397 inventory değerleriyle kurulur.",
      "Production partition doğruluğu live source taramasından türetilmeden S247 reader ve S396 writer-guard sonuçlarıyla kurulur.",
      "Bu iki bağımsız provenance zincirinin 113'te buluşması accidental self-check yerine cross-reconciliation sağlar.",
      "Receipt yalnız source_audit_units, direct_scheduler_access_sites, iki covered total ve unrouted total'i dışarı verir; iç partition girdileri yeniden yetki olarak taşınmaz.",
      "Preflight canonical ledger'i local value olarak kurar ve reconciliation fonksiyonunu exact bir kez çağırır.",
      "Typed outcome receipt'ten gelen değerleri taşır; predecessor outcome alanlarını doğrudan PASS sonucu diye kopyalamaz.",
      "S245 request id outcome'a gözlem kimliği olarak girer fakat request ownership'i veya authority bit'i değişmez.",
      "CPU1 service wrong-CPU yolunda fabricated request yaratmadan aynı typed preflight üzerinden fail-closed olur.",
      "Production cfg dışındaki simulation build yalnız pure ledger/preflight modelini derler; board authority taklidi yapmaz.",
      "S398 registration'ı S397 module kaydının hemen sonrasındadır ve generic S335–S400 facade'ı yeniden canlandırmaz.",
      "Exceptions service sırası direct-access receipt'i eski S242 request-service zincirinin önünde gözlemler fakat zincirin request state'ini tüketmez.",
      "No-new-access assertion hem reconciliation module source'unda hem yedi production audit unit'inde inventory totalinin 113 kalmasıyla iki taraftan doğrulanır.",
      "No-provider assertion constructor, provider authority site, admission publisher ve request take yüzeylerinin ayrı ayrı sıfır kalmasıyla doğrulanır.",
      "S399 exact successor adı source outcome ve Operations limitation içinde bulunur; S400 yalnız daha sonraki constructor sınırı olarak anılır.",
      "Focused successor testi kernel main ve simulation lib içinde S399/S400 modüllerinin olmadığını doğrular.",
      "Focused source test complete module'ü include_str ile exact repository yolundan denetler.",
      "Focused test yedi source unit'i ayrı array içinde açıkça listeler.",
      "Focused test beş mutable source unit'i ayrı array içinde açıkça listeler.",
      "Source scanner yalnız SCHEDULER içeren addr_of!/addr_of_mut! macro çağrılarını sayar.",
      "Source/model coverage ile production guard coverage aynı tarayıcıdan türetilmez; bağımsız sabit kümeleri karşılaştırılır.",
      "Selected regression final sonucu 5 grup / 123/123 PASS'tir.",
      "Selected gruplar S398 21/21, S397 23/23, S396 50/50, S327 15/15 ve tarihsel dosya adı S246 olan S247 14/14'tür.",
      "Selected ilk turda S397 historical successor assertion 22/23 ile RED oldu.",
      "Historical assertion yalnız exact yetkili S398 successor'a izin verecek biçimde düzeltildi; S399 ve S400 prohibition korunur.",
      "S398-owned product veya coverage assertion'ı zayıflatılmadı.",
      "S397'nin exact 161-target dependency listesi byte-for-byte korunup yalnız S398 sona eklendi.",
      "İki S238–S398 dependency koşusunun her biri 162 grup / 4194/4194 PASS verdi.",
      "Dependency timing-normalized özetleri 15713 B ve byte-eşittir.",
      "Dependency canonical SHA-256 b7f9cb22044c34ee52010bb3fd140e8cf6fc496f49089f02082d2270ce9d1bc8'dir.",
      "Dependency run1 raw 390570 B / 920e7a72a5f20fedb7f932500699b76c67758426a46fbe0cf1a1f844aa3dd100 SHA-256'dır.",
      "Dependency run2 raw 374399 B / e9f1a5d8a504acc7b0f375cb2d921e0ae1c1b6fca927d29e12f24aca72e1965e SHA-256'dır.",
      "Dependency artifact root /tmp/aselsanos-s398-dependency.5PLsDt'tir.",
      "Exact yedi tarihsel assertion filtered serial workspace audit 361 grup / 6080 PASS / 0 fail verdi.",
      "Filtered workspace raw 76340 B / 3bce8bdae89f325d02b00ff60ea8d5d072fce592ea4132c1597a156eec5f0521 SHA-256'dır.",
      "Unfiltered workspace exit 101 ile 314 grup / 5825 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 71562 B / 61771a70041ea4eab734eb5ca27890ebf917bae41dc84be698e6fb502eb2529c SHA-256'dır.",
      "Workspace artifact root /tmp/aselsanos-s398-workspace.zRHmAL'dir.",
      "Global unfiltered workspace GREEN iddiası yapılmaz.",
      "Dört fresh AArch64 profil 4/4 exit 0 verdi.",
      "QEMU profile warning/log/ELF 293 / 111450 B / 12222320 B'dir.",
      "QEMU ELF SHA-256 4270e4c601a60bef660654d97f907eb908943d0532747116b46c5e2e7efd4fff'tir.",
      "RPi4 profile warning/log/ELF 391 / 150191 B / 7421768 B'dir.",
      "RPi4 ELF SHA-256 8a35b744b53f06e2be71f96ba69875627f71d7babe1ead796a775ec06fe71f7b'dir.",
      "RPi5 profile warning/log/ELF 1570 / 682534 B / 11429016 B'dir.",
      "RPi5 ELF SHA-256 c56f9035334b5a4e370a6f08702078be2f4e40807e5adf8196f53ab539853fc3'tür.",
      "RPi5+SMP profile warning/log/ELF 1570 / 682476 B / 11416512 B'dir.",
      "RPi5+SMP ELF SHA-256 26e351a16c1df18cf251af0e07bf102314009ae46730bd28bc70b930534566c6'dır.",
      "Profile artifact root /tmp/aselsanos-s398-profiles.J7ikxI'tir.",
      "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 / 84e16fd88f836a31fe816c0d37a2b81febbc28aa79c19b2d53ea4e82f1eb4340 SHA-256'dır.",
      "QEMU artifact /tmp/aselsanos-s398-qemu.kAjTNW'dir.",
      "Board-QEMU common regression S398 CPU1 inspection service runtime observation'ı değildir.",
      "Status manifest S398'i ayrı verification object, physical-zero list ve gate marker ile kaydeder.",
      "Project-status renderer write/check ve manifest 278/278 PASS'tir.",
      "S398 proof docs/M8.1-RPi5-G8l-S398-Whole-Scheduler-Direct-Access-Coverage-Reconciliation-Proof.md altında ayrı dosyadır.",
      "Code publication hedefi S1–S398 398/398 unique karttır.",
      "Kullanıcının istediği S328 öncesi S1–S327 aralığı 327/327 ayrı kart olarak korunur.",
      "S1, S327, S328, S397 ve S398 exact birer kart; missing=none, duplicate=0 ve S399=0 olmalıdır.",
      "S398 Code kartı complete reconciliation module, complete focused target, complete Operations record ve proof katmanlarını ayrı göstermelidir.",
      "S398 writer-guard kartı olarak yanlış etiketlenmemeli; focused reconciliation implementation olmalıdır.",
      "İlk production publication öncesi generated Code registry S1–S398 aralığında 398/398 unique gate, 1158 exact excerpt, pre-S328 327/327, missing=none ve duplicate=0 verdi.",
      "İlk registry mapping 69 writer-guard + 227 focused-test + 94 command-contract + 8 operation-record = 398'dir.",
      "İlk generated registry JSON 9194555 B / 31e989ab680c2ee8df57f46c2c555b887a600e1d8d30886ba1c200eb100680de dosya SHA-256'dır.",
      "İlk registry semantic SHA-256 d17465b8b2badee94aa1b50d5f10c77b5148dff9c44f2a5373cfb5ccd4d4ba96'dır.",
      "S398 Code kartı complete-file reconciliation implementation, complete-file 21-test target ve complete Operations record olmak üzere üç exact excerpt yayımlar.",
      "S398 Code compatibility sourceBound=true, testBound=true ve implementationSequenceBound=true'dur.",
      "İlk production yayın öncesi website 730/730 test, lint PASS, TypeScript exit 0/boş output ve 24/24 static route PASS verdi.",
      "İlk export 200 dosya; Timeline ve yol-haritasi ayrı ayrı 237 data-gate-policy kartıdır.",
      "İlk yayın öncesi S398 core policy 13976 karakter / 14439 UTF-8 byte, 135 evidence, 3 teknik terminal session ve 10 limitation taşır.",
      "İlk production/main deployment b18bee6f-6450-4df3-bb1c-30c9be39fe77 ile tamamlandı.",
      "İlk deployment 115 uploaded + 84 existing = 199 asset ve _headers yayımladı.",
      "Wrangler deployment-list kaydı 29554 B / 011e96a868db6f65227008a49963a67ca3cbad88e93e84bdac0ee8d979683569 SHA-256'dır.",
      "Cache-busted custom-domain /code/ HTTP 200, 25650081 B / 834f69c488e34c9764b35a3034f55b0c7bab14bdbf0421eaba30284b7646dfc9 SHA-256 ve local out ile byte-exact=true verdi.",
      "Cache-busted custom-domain /operations/ HTTP 200, 16084022 B / bdf90ded46fe828d0144373816346d954b9c9596b53384d9d170422ad2ffbd5b SHA-256 ve local out ile byte-exact=true verdi.",
      "Cache-busted custom-domain /timeline/ HTTP 200, 6831850 B / e3ca0f82e1b67d1114267b0e77a6374b481620a2459574ea4e4ea550322669a0 SHA-256 ve local out ile byte-exact=true verdi.",
      "Cache-busted custom-domain /yol-haritasi/ HTTP 200, 6831598 B / 9c86a86873d5e9664bb18121c6cf3c4b5f48bb705b87e16a9450df19d8122f74 SHA-256 ve local out ile byte-exact=true verdi.",
      "Canlı Code literal gate labels total=398, unique=398 ve pre-S328=327'dir.",
      "Canlı Code S1/S327/S328/S397/S398 exact birer, S399=0, missing=none ve duplicate=0'dır.",
      "Canlı /code/ response no-transform ve nosniff header'larını taşır; Cloudflare email rewrite=0'dır.",
      "İlk custom-domain readback artifact root /tmp/aselsanos-s398-readback-initial.bwY7Bl'dir.",
      "Immutable b18bee6f hostname probe'u curl exit 28 / HTTP 000 verdi; custom-domain PASS yerine geçirilmedi.",
      "İlk ölçümleri içeren payload ayrı evidence-sync production/main transaction'ında yayımlanır; dönen final deployment kimliği self-referential redeploy zinciri oluşturmamak için bu metne geri yazılmaz.",
      "S398 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_S398=NO; fiziksel RPi5 runtime veya device acceptance iddiası yoktur.",
      "Bağlayıcı olmayan S398 projeksiyonu R1 S398–S428, R2 S453–S503, R3 S582+, risk aralığı S558–S608 ve merkez yaklaşık S583'tür.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation -- --test-threads=1",
      "run S398, S397, S396, S327 and historical-filename S247 shared-gate target serially",
      "run S238-S398 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",
      "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: "g8l-s398-focused-source-contract",
        title: "S398 focused direct-access reconciliation",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s398_whole_scheduler_direct_access_coverage_reconciliation -- --test-threads=1",
        ],
        outputLines: [
          "initial result: compile RED; S398 source and simulation export absent",
          "initial exit code: 101",
          "final result: ok; S398 focused 1 group / 21 passed / 0 failed",
          "source/model 44+69=113; production 44+69=113; unrouted=0",
          "provider preflight=false; provider authority=0; whole exclusion=false",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s398-selected-regression",
        title: "S398/S397/S396/S327/S247 selected reconciliation regression",
        commandLines: [
          "run S398, S397, S396, S327 and historical-filename S247 shared-gate target serially",
        ],
        outputLines: [
          "initial historical S397 assertion: 22/23 PASS + 1 expected successor-source RED",
          "fixed predecessor assertion: exact S398 allowed; S399/S400 remain prohibited",
          "final result: 5 groups / 123 passed / 0 failed",
          "S398-owned product/coverage assertions weakened=false",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s398-full-acceptance",
        title: "S398 dependency, workspace, profiles and QEMU acceptance",
        commandLines: [
          "run S238-S398 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: 162 groups / 4194/4194 twice; normalized 15713-byte summaries byte-identical",
          "filtered workspace: 361 groups / 6080 PASS / 7 historical filtered",
          "unfiltered: frozen-S96 RED after 314 groups / 5825 PASS; global green not claimed",
          "four fresh profiles: 4/4 exit 0; zero-warning not claimed",
          "QEMU W^X 31/31 + S130-S154 + S271/S136 + IPC 20/20 + SEC5 PASS; not an S398 runtime observation",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s398-production-publication",
        title: "S398 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: 730/730 PASS; lint PASS; TypeScript exit 0 empty; static routes 24/24",
          "registry: S1-S398 398/398; 1158 excerpts; pre-S328=327; missing=0; duplicate=0; S399=0",
          "first deployment: b18bee6f-6450-4df3-bb1c-30c9be39fe77; 115 uploaded + 84 existing",
          "custom domain: four routes HTTP 200 and raw byte-exact=true; Code no-transform/nosniff",
          "immutable hostname: curl exit 28 / HTTP 000; not substituted for custom-domain acceptance",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "TAM ÇIKTI oturumları compile RED→21/21 focused geçişini, predecessor assertion düzeltmesini, 123/123 seçili regresyonu, iki kez 4194/4194 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. S398 yalnız direct-access reconciliation'dır; S399 provider preflight ve S400 constructor ayrı kapılardır.",
    limitations: [
      "S398 yalnız 113 direct scheduler erişimin source/model ve production guard partition'larını uzlaştırır; yeni scheduler access veya runtime mutation eklemez.",
      "S398 S247 lease almaz, S245 request'i tüketmez ve S244 admission yayımlamaz.",
      "Provider preflight S399'a, production provider-authority constructor ve end-to-end admission S400'e aittir.",
      "Direct-access reconciliation whole-scheduler exclusion veya migration admission tamamlandı anlamına gelmez.",
      "Dört AArch64 build ve ortak QEMU regresyonu supported-profile S398 CPU1 service invocation kanıtı değildir.",
      "Unfiltered workspace frozen S96 exact-source assertion nedeniyle global GREEN değildir; yedi historical filter açıkça sayılmıştır.",
      "Warning header'ları sıfır değildir; zero-warning iddiası yapılmaz.",
      "Generic SMP, CPU2/CPU3, hotplug, soak ve saha operasyonu açıktır.",
      "İlk Code/Operations/Timeline production publication ve custom-domain byte-exact readback doğrulandı; ölçümlerin evidence-sync payload'ı ayrı transaction olarak yayımlanır.",
      "Fiziksel güç, SD, Mac kart erişimi, UART, raw validation, archive veya promotion yapılmadı; RUNBOOK_EXECUTED_IN_S398=NO.",
    ],
  },