S574 · R2 fresh supported-profile tekrar aday dondurması

//! S574 freezes a fresh immutable package record for the first independent
//! R2 supported-profile repeat campaign.
//!
//! The four payload files are byte-equal to the retained S570/S571 candidate,
//! but live at a new path with four new distinct inodes. S574 also freezes the
//! source identities for a read-only S575 preflight and the sequence-specific
//! UART capture wrapper. It does not accept operator authorization, mutate a
//! device, open UART, change Pi power or claim a runtime observation.

#![allow(dead_code)]

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s570_r1_frozen_manifest_candidate_freeze_prearm_contract::{
    S570_CONFIG_BYTES, S570_CONFIG_SHA256, S570_DTB_BYTES, S570_DTB_SHA256,
    S570_IMAGE_BYTES, S570_IMAGE_SHA256, S570_MANIFEST_BYTES, S570_MANIFEST_SHA256,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract::{
    S573_CAMPAIGN_ID, S573_EVIDENCE_TRANSPORT, S573_GATE_STATUS, S573_NEW_EVIDENCE_ROOT,
    S573_NEW_TRANSACTION_LOCK_PATH, S573_REQUIRED_FUTURE_NEW_RAW_CAPTURES,
    S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS, S573_REQUIRED_FUTURE_RAW_LINK_COUNT,
    S573_REQUIRED_FUTURE_RAW_MODE_OCTAL, S573_REQUIRED_FUTURE_SD_EJECTS,
    S573_REQUIRED_FUTURE_SD_READBACKS, S573_REQUIRED_FUTURE_SD_WRITES,
    S573_REQUIRED_FUTURE_UART_OPENS, S573_REQUIRED_PHYSICAL_RUN_SEQUENCE, S573_SEQUENCE,
    S573_SUPPORTED_PROFILE, S573_TARGET_ARCH,
};

pub const S574_SEQUENCE: usize = 574;
pub const S574_EXPECTED_PREDECESSOR: usize = S573_SEQUENCE;
pub const S574_NEXT_SEQUENCE: usize = S573_REQUIRED_PHYSICAL_RUN_SEQUENCE;
pub const S574_R2_TRANSITION_FIRST: usize = 572;
pub const S574_R2_TRANSITION_LAST: usize = 707;
pub const S574_R2_WORKSTREAM_ORDINAL: usize = 1;
pub const S574_GATE_STATUS: &str = "PASS";
pub const S574_ACCEPTANCE_DOMAIN: &str = "supported_profile_fresh_repeat_candidate_freeze";
pub const S574_SUPPORTED_PROFILE: &str = S573_SUPPORTED_PROFILE;
pub const S574_TARGET_ARCH: &str = S573_TARGET_ARCH;
pub const S574_EVIDENCE_TRANSPORT: &str = S573_EVIDENCE_TRANSPORT;
pub const S574_CAMPAIGN_ID: &str = S573_CAMPAIGN_ID;

pub const S574_REFERENCE_PACKAGE_DIRECTORY: &str =
    "evidence/rpi5/r1/sequence-570-candidate-freeze/package";
pub const S574_PACKAGE_DIRECTORY: &str =
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package";
pub const S574_EVIDENCE_DIRECTORY: &str =
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze";
pub const S574_FUTURE_S575_EVIDENCE_ROOT: &str = S573_NEW_EVIDENCE_ROOT;
pub const S574_FUTURE_S575_TRANSACTION_LOCK_PATH: &str = S573_NEW_TRANSACTION_LOCK_PATH;
pub const S574_RETAINED_S571_TRANSACTION_LOCK_PATH: &str =
    "/private/tmp/aselsanos-s571-r1-425001fa.lock";

pub const S574_PACKAGE_ENTRIES: usize = 4;
pub const S574_PACKAGE_DIRECTORY_MODE: u32 = 0o700;
pub const S574_PACKAGE_FILE_MODE: u32 = 0o444;
pub const S574_PACKAGE_FILE_NLINK: u32 = 1;
pub const S574_REQUIRED_FRESH_INODES: usize = 4;
pub const S574_IMAGE_NAME: &str = "aselsanos-rpi5.img";
pub const S574_DTB_NAME: &str = "bcm2712-rpi-5-b.dtb";
pub const S574_CONFIG_NAME: &str = "config.txt";
pub const S574_MANIFEST_NAME: &str = "SHA256SUMS";
pub const S574_IMAGE_BYTES: u64 = S570_IMAGE_BYTES;
pub const S574_IMAGE_SHA256: &str = S570_IMAGE_SHA256;
pub const S574_DTB_BYTES: u64 = S570_DTB_BYTES;
pub const S574_DTB_SHA256: &str = S570_DTB_SHA256;
pub const S574_CONFIG_BYTES: u64 = S570_CONFIG_BYTES;
pub const S574_CONFIG_SHA256: &str = S570_CONFIG_SHA256;
pub const S574_MANIFEST_BYTES: u64 = S570_MANIFEST_BYTES;
pub const S574_MANIFEST_SHA256: &str = S570_MANIFEST_SHA256;
pub const S574_MANIFEST_LINES: usize = 3;

pub const S574_FREEZE_TOOL_PATH: &str = "scripts/freeze-rpi5-s574-r2-repeat-candidate.sh";
pub const S574_FREEZE_TOOL_BYTES: u64 = 8_896;
pub const S574_FREEZE_TOOL_SHA256: &str =
    "5562c426b21f48cf61fae7818055b12725e32e546a3850bcd8061f40a0a1ba55";
pub const S574_FREEZE_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/s574-freeze.log";
pub const S574_FREEZE_LOG_BYTES: u64 = 1_439;
pub const S574_FREEZE_LOG_SHA256: &str =
    "3742a9d9371240003395849d07a98911270ef6f97b2eb357153478888bac41a8";
pub const S574_EVIDENCE_MANIFEST_PATH: &str =
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/EVIDENCE_SHA256SUMS";
pub const S574_EVIDENCE_MANIFEST_BYTES: u64 = 531;
pub const S574_EVIDENCE_MANIFEST_SHA256: &str =
    "084d58b39eb2060639c839eb628b1e6f350ab992c53239b2a1a2b86f6bd27001";
pub const S574_BOARD_RPI5_CHECK_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/s574-board-rpi5-check.log";
pub const S574_BOARD_RPI5_CHECK_LOG_BYTES: u64 = 1_698_974;
pub const S574_BOARD_RPI5_CHECK_LOG_SHA256: &str =
    "879d6f5fb32ae95b6c6eecaba0e18b903e00a72f237211125ec4dd41e2bef60b";
pub const S574_BOARD_RPI5_CHECK_COMMAND: &str = "CARGO_INCREMENTAL=0 cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5";
pub const S574_BOARD_RPI5_CHECK_EXIT_CODE: i32 = 0;
pub const S574_BOARD_RPI5_COMPILER_REPORTED_WARNINGS: usize = 4_496;
pub const S574_BOARD_RPI5_WARNING_PREFIXED_LINES: usize = 4_497;
pub const S574_BOARD_RPI5_ZERO_WARNING_CLAIMED: bool = false;
pub const S574_MODULE_LINKED_INTO_BOARD_RPI5: bool = false;
pub const S574_S575_PREFLIGHT_TOOL_PATH: &str = "scripts/preflight-rpi5-s575-r2-repeat.sh";
pub const S574_S575_PREFLIGHT_TOOL_BYTES: u64 = 11_430;
pub const S574_S575_PREFLIGHT_TOOL_SHA256: &str =
    "f846a01e0e4800c39600471d0b529efbddc7811cf512f400f7789edf733c751a";
pub const S574_S575_CAPTURE_WRAPPER_PATH: &str = "scripts/capture-rpi5-s575-r2-repeat-uart.c";
pub const S574_S575_CAPTURE_WRAPPER_BYTES: u64 = 249;
pub const S574_S575_CAPTURE_WRAPPER_SHA256: &str =
    "e4325ae7c9eef419aadc86cabdc2fcf94035d1026b3656d27ec1227060328c82";
pub const S574_CAPTURE_ENGINE_PATH: &str = "scripts/capture-rpi5-s540-r1-uart.c";
pub const S574_CAPTURE_ENGINE_BYTES: u64 = 20_572;
pub const S574_CAPTURE_ENGINE_SHA256: &str =
    "9f001c4cec407bbb4310ca0f89d9cc7e8a1be32307ba8d7ea0541e315ff1efec";

pub const S574_EXPECTED_CARD_SERIAL_HEX: &str = "425001fa";
pub const S574_EXPECTED_CARD_BYTES: u64 = 62_549_655_552;
pub const S574_EXPECTED_DEBUG_PROBE_SERIAL: &str = "E6647C74033F9131";
pub const S574_EXPECTED_UART_PATH: &str = "/dev/cu.usbmodem21302";
pub const S574_EXPECTED_PI_ASSERTION: &str = "S575_PI_UNPOWERED_ASSERTED";
pub const S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN: &str =
    "S575_AUTHORIZE_FRESH_FREEZE_SD_WRITE_READBACK_EJECT_UART_PREARM_ONE_POWER_ON_a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04_425001fa_62549655552_r2-ws01-board-rpi5-repeat-01";

pub const S574_FRESH_RECORD_CREATED: bool = true;
pub const S574_REFERENCE_PAYLOAD_BYTE_EQUAL: bool = true;
pub const S574_REFERENCE_HISTORY_RETAINED: bool = true;
pub const S574_S571_LOCK_RETAINED: bool = true;
pub const S574_S575_READ_ONLY_PREFLIGHT_SOURCE_BOUND: bool = true;
pub const S574_S575_CAPTURE_SOURCE_BOUND: bool = true;
pub const S574_S575_TRANSACTION_TOOL_PREPARED: bool = false;
pub const S574_S575_CAPTURE_BINARY_PREPARED: bool = false;
pub const S574_AUTHORIZATION_RECEIVED: bool = false;
pub const S574_EXECUTION_PERMIT: bool = false;
pub const S574_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S574_NEW_PHYSICAL_OBSERVATIONS: usize = 0;
pub const S574_NEW_INDEPENDENT_PHYSICAL_REPEATS: usize = 0;
pub const S574_PHYSICAL_OR_DEVICE_OPERATIONS: usize = 0;
pub const S574_SD_WRITES: usize = 0;
pub const S574_SD_READBACKS: usize = 0;
pub const S574_SD_EJECTS: usize = 0;
pub const S574_UART_OPENS: usize = 0;
pub const S574_POWER_TRANSITIONS: usize = 0;
pub const S574_NEW_RAW_CAPTURES: usize = 0;
pub const S574_PHYSICAL_RUN_EXECUTED: bool = false;
pub const S574_REPEATABILITY_COMPLETE: bool = false;
pub const S574_CROSS_PROFILE_COVERAGE_COMPLETE: bool = false;
pub const S574_R2_FIELD_ACCEPTANCE_COMPLETE: bool = false;
pub const S574_AUTOMATIC_PROMOTION: bool = false;
pub const RUNBOOK_EXECUTED_IN_S574: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS574ArtifactIdentity {
    pub bytes: u64,
    pub sha256: &'static str,
}

pub const fn s574_identity(bytes: u64, sha256: &'static str) -> G8lS574ArtifactIdentity {
    G8lS574ArtifactIdentity { bytes, sha256 }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS574PackageEntryObservation {
    pub name: &'static str,
    pub identity: G8lS574ArtifactIdentity,
    pub mode: u32,
    pub link_count: u32,
    pub source_inode: u64,
    pub destination_inode: u64,
    pub byte_equal: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS574FreezeRequest<'a> {
    pub predecessor_sequence: usize,
    pub predecessor_status: &'a str,
    pub profile: &'a str,
    pub target_arch: &'a str,
    pub transport: &'a str,
    pub campaign_id: &'a str,
    pub reference_package: &'a str,
    pub destination_package: &'a str,
    pub future_evidence_root: &'a str,
    pub future_transaction_lock_path: &'a str,
    pub retained_s571_lock_path: &'a str,
    pub package_directory_mode: u32,
    pub package: [G8lS574PackageEntryObservation; S574_PACKAGE_ENTRIES],
    pub manifest: G8lS574ArtifactIdentity,
    pub freeze_tool: G8lS574ArtifactIdentity,
    pub freeze_log: G8lS574ArtifactIdentity,
    pub evidence_manifest: G8lS574ArtifactIdentity,
    pub board_rpi5_check_log: G8lS574ArtifactIdentity,
    pub preflight_tool: G8lS574ArtifactIdentity,
    pub capture_wrapper: G8lS574ArtifactIdentity,
    pub capture_engine: G8lS574ArtifactIdentity,
    pub authorization_token: Option<&'a str>,
    pub reference_history_retained: bool,
    pub s571_lock_retained: bool,
    pub physical_or_device_operations: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS574FreezeReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub status: &'static str,
    pub acceptance_domain: &'static str,
    pub profile: &'static str,
    pub campaign_id: &'static str,
    pub package_directory: &'static str,
    pub candidate: G8lS574ArtifactIdentity,
    pub package_manifest: G8lS574ArtifactIdentity,
    pub fresh_record_created: bool,
    pub reference_payload_byte_equal: bool,
    pub fresh_inode_count: usize,
    pub package_inode_signature: u64,
    pub future_physical_run_sequence: usize,
    pub future_evidence_root: &'static str,
    pub future_transaction_lock_path: &'static str,
    pub expected_future_authorization_token: &'static str,
    pub authorization_received: bool,
    pub execution_permit: bool,
    pub read_only_preflight_source_bound: bool,
    pub capture_source_bound: bool,
    pub transaction_tool_prepared: bool,
    pub capture_binary_prepared: bool,
    pub board_rpi5_check_exit_code: i32,
    pub board_rpi5_compiler_reported_warnings: usize,
    pub board_rpi5_zero_warning_claimed: bool,
    pub module_linked_into_board_rpi5: bool,
    pub required_future_sd_writes: usize,
    pub required_future_sd_readbacks: usize,
    pub required_future_sd_ejects: usize,
    pub required_future_uart_opens: usize,
    pub required_future_power_transitions: usize,
    pub required_future_raw_captures: usize,
    pub required_future_raw_mode_octal: &'static str,
    pub required_future_raw_link_count: usize,
    pub physical_or_device_operations: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub repeatability_complete: bool,
    pub r2_field_acceptance_complete: bool,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS574FreezeState {
    receipt: Option<G8lS574FreezeReceipt>,
}

impl G8lS574FreezeState {
    pub const fn new() -> Self {
        Self { receipt: None }
    }

    pub const fn receipt(&self) -> Option<G8lS574FreezeReceipt> {
        self.receipt
    }
}

impl Default for G8lS574FreezeState {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS574FreezeOutcome {
    CandidateFrozen(G8lS574FreezeReceipt),
    CandidateRetained(G8lS574FreezeReceipt),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS574FreezeError {
    PredecessorRejected,
    ProfileDrift,
    CampaignDrift,
    NamespaceDrift,
    PackageShapeDrift,
    PayloadIdentityDrift,
    PackagePermissionDrift,
    FreshIdentityRejected,
    ToolIdentityDrift,
    HistoryRewriteRejected,
    PrematureAuthorizationRejected,
    ObservationOverclaim,
    PublishedStateDrift,
}

impl G8lS574FreezeError {
    pub const fn diagnostic_code(self) -> u64 {
        match self {
            Self::PredecessorRejected => 0x5741_01,
            Self::ProfileDrift => 0x5741_02,
            Self::CampaignDrift => 0x5741_03,
            Self::NamespaceDrift => 0x5741_04,
            Self::PackageShapeDrift => 0x5741_05,
            Self::PayloadIdentityDrift => 0x5741_06,
            Self::PackagePermissionDrift => 0x5741_07,
            Self::FreshIdentityRejected => 0x5741_08,
            Self::ToolIdentityDrift => 0x5741_09,
            Self::HistoryRewriteRejected => 0x5741_0a,
            Self::PrematureAuthorizationRejected => 0x5741_0b,
            Self::ObservationOverclaim => 0x5741_0c,
            Self::PublishedStateDrift => 0x5741_0d,
        }
    }
}

const fn expected_entry(index: usize) -> (&'static str, G8lS574ArtifactIdentity) {
    match index {
        0 => (
            S574_IMAGE_NAME,
            s574_identity(S574_IMAGE_BYTES, S574_IMAGE_SHA256),
        ),
        1 => (
            S574_DTB_NAME,
            s574_identity(S574_DTB_BYTES, S574_DTB_SHA256),
        ),
        2 => (
            S574_CONFIG_NAME,
            s574_identity(S574_CONFIG_BYTES, S574_CONFIG_SHA256),
        ),
        _ => (
            S574_MANIFEST_NAME,
            s574_identity(S574_MANIFEST_BYTES, S574_MANIFEST_SHA256),
        ),
    }
}

pub fn service_s574_model_supported_profile_repeat_candidate_freeze(
    state: &mut G8lS574FreezeState,
    request: G8lS574FreezeRequest<'_>,
) -> Result<G8lS574FreezeOutcome, G8lS574FreezeError> {
    if request.predecessor_sequence != S574_EXPECTED_PREDECESSOR
        || request.predecessor_status != S573_GATE_STATUS
    {
        return Err(G8lS574FreezeError::PredecessorRejected);
    }
    if request.profile != S574_SUPPORTED_PROFILE
        || request.target_arch != S574_TARGET_ARCH
        || request.transport != S574_EVIDENCE_TRANSPORT
    {
        return Err(G8lS574FreezeError::ProfileDrift);
    }
    if request.campaign_id != S574_CAMPAIGN_ID {
        return Err(G8lS574FreezeError::CampaignDrift);
    }
    if request.reference_package != S574_REFERENCE_PACKAGE_DIRECTORY
        || request.destination_package != S574_PACKAGE_DIRECTORY
        || request.reference_package == request.destination_package
        || request.future_evidence_root != S574_FUTURE_S575_EVIDENCE_ROOT
        || request.future_transaction_lock_path != S574_FUTURE_S575_TRANSACTION_LOCK_PATH
        || request.retained_s571_lock_path != S574_RETAINED_S571_TRANSACTION_LOCK_PATH
        || request.future_transaction_lock_path == request.retained_s571_lock_path
    {
        return Err(G8lS574FreezeError::NamespaceDrift);
    }
    if request.package_directory_mode != S574_PACKAGE_DIRECTORY_MODE
        || request.manifest != s574_identity(S574_MANIFEST_BYTES, S574_MANIFEST_SHA256)
    {
        return Err(G8lS574FreezeError::PackageShapeDrift);
    }

    let mut fresh_inode_count = 0usize;
    let mut source_inode_xor = 0u64;
    let mut destination_inode_xor = 0u64;
    for (index, observed) in request.package.iter().enumerate() {
        let (expected_name, expected_identity) = expected_entry(index);
        if observed.name != expected_name || observed.identity != expected_identity {
            return Err(G8lS574FreezeError::PayloadIdentityDrift);
        }
        if observed.mode != S574_PACKAGE_FILE_MODE || observed.link_count != S574_PACKAGE_FILE_NLINK
        {
            return Err(G8lS574FreezeError::PackagePermissionDrift);
        }
        if !observed.byte_equal
            || observed.source_inode == 0
            || observed.destination_inode == 0
            || observed.source_inode == observed.destination_inode
        {
            return Err(G8lS574FreezeError::FreshIdentityRejected);
        }
        if request
            .package
            .iter()
            .any(|source| observed.destination_inode == source.source_inode)
        {
            return Err(G8lS574FreezeError::FreshIdentityRejected);
        }
        for earlier in request.package[..index].iter() {
            if observed.source_inode == earlier.source_inode
                || observed.destination_inode == earlier.destination_inode
            {
                return Err(G8lS574FreezeError::FreshIdentityRejected);
            }
        }
        fresh_inode_count += 1;
        source_inode_xor ^= observed.source_inode.rotate_left(index as u32);
        destination_inode_xor ^= observed.destination_inode.rotate_left(index as u32);
    }
    if fresh_inode_count != S574_REQUIRED_FRESH_INODES || source_inode_xor == destination_inode_xor
    {
        return Err(G8lS574FreezeError::FreshIdentityRejected);
    }

    if request.freeze_tool != s574_identity(S574_FREEZE_TOOL_BYTES, S574_FREEZE_TOOL_SHA256)
        || request.freeze_log != s574_identity(S574_FREEZE_LOG_BYTES, S574_FREEZE_LOG_SHA256)
        || request.evidence_manifest
            != s574_identity(S574_EVIDENCE_MANIFEST_BYTES, S574_EVIDENCE_MANIFEST_SHA256)
        || request.board_rpi5_check_log
            != s574_identity(
                S574_BOARD_RPI5_CHECK_LOG_BYTES,
                S574_BOARD_RPI5_CHECK_LOG_SHA256,
            )
        || request.preflight_tool
            != s574_identity(
                S574_S575_PREFLIGHT_TOOL_BYTES,
                S574_S575_PREFLIGHT_TOOL_SHA256,
            )
        || request.capture_wrapper
            != s574_identity(
                S574_S575_CAPTURE_WRAPPER_BYTES,
                S574_S575_CAPTURE_WRAPPER_SHA256,
            )
        || request.capture_engine
            != s574_identity(S574_CAPTURE_ENGINE_BYTES, S574_CAPTURE_ENGINE_SHA256)
    {
        return Err(G8lS574FreezeError::ToolIdentityDrift);
    }
    if !request.reference_history_retained
        || !request.s571_lock_retained
        || !S574_REFERENCE_HISTORY_RETAINED
        || !S574_S571_LOCK_RETAINED
    {
        return Err(G8lS574FreezeError::HistoryRewriteRejected);
    }
    if request.authorization_token.is_some() || S574_AUTHORIZATION_RECEIVED || S574_EXECUTION_PERMIT
    {
        return Err(G8lS574FreezeError::PrematureAuthorizationRejected);
    }
    if request.physical_or_device_operations != S574_PHYSICAL_OR_DEVICE_OPERATIONS
        || request.new_runtime_observations != S574_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS
        || request.new_physical_observations != S574_NEW_PHYSICAL_OBSERVATIONS
        || request.new_independent_physical_repeats != S574_NEW_INDEPENDENT_PHYSICAL_REPEATS
        || request.runbook_executed != RUNBOOK_EXECUTED_IN_S574
    {
        return Err(G8lS574FreezeError::ObservationOverclaim);
    }

    let receipt = G8lS574FreezeReceipt {
        sequence: S574_SEQUENCE,
        predecessor_sequence: request.predecessor_sequence,
        status: S574_GATE_STATUS,
        acceptance_domain: S574_ACCEPTANCE_DOMAIN,
        profile: S574_SUPPORTED_PROFILE,
        campaign_id: S574_CAMPAIGN_ID,
        package_directory: S574_PACKAGE_DIRECTORY,
        candidate: request.package[0].identity,
        package_manifest: request.manifest,
        fresh_record_created: S574_FRESH_RECORD_CREATED,
        reference_payload_byte_equal: S574_REFERENCE_PAYLOAD_BYTE_EQUAL,
        fresh_inode_count,
        package_inode_signature: destination_inode_xor,
        future_physical_run_sequence: S574_NEXT_SEQUENCE,
        future_evidence_root: S574_FUTURE_S575_EVIDENCE_ROOT,
        future_transaction_lock_path: S574_FUTURE_S575_TRANSACTION_LOCK_PATH,
        expected_future_authorization_token: S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN,
        authorization_received: S574_AUTHORIZATION_RECEIVED,
        execution_permit: S574_EXECUTION_PERMIT,
        read_only_preflight_source_bound: S574_S575_READ_ONLY_PREFLIGHT_SOURCE_BOUND,
        capture_source_bound: S574_S575_CAPTURE_SOURCE_BOUND,
        transaction_tool_prepared: S574_S575_TRANSACTION_TOOL_PREPARED,
        capture_binary_prepared: S574_S575_CAPTURE_BINARY_PREPARED,
        board_rpi5_check_exit_code: S574_BOARD_RPI5_CHECK_EXIT_CODE,
        board_rpi5_compiler_reported_warnings: S574_BOARD_RPI5_COMPILER_REPORTED_WARNINGS,
        board_rpi5_zero_warning_claimed: S574_BOARD_RPI5_ZERO_WARNING_CLAIMED,
        module_linked_into_board_rpi5: S574_MODULE_LINKED_INTO_BOARD_RPI5,
        required_future_sd_writes: S573_REQUIRED_FUTURE_SD_WRITES,
        required_future_sd_readbacks: S573_REQUIRED_FUTURE_SD_READBACKS,
        required_future_sd_ejects: S573_REQUIRED_FUTURE_SD_EJECTS,
        required_future_uart_opens: S573_REQUIRED_FUTURE_UART_OPENS,
        required_future_power_transitions: S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS,
        required_future_raw_captures: S573_REQUIRED_FUTURE_NEW_RAW_CAPTURES,
        required_future_raw_mode_octal: S573_REQUIRED_FUTURE_RAW_MODE_OCTAL,
        required_future_raw_link_count: S573_REQUIRED_FUTURE_RAW_LINK_COUNT,
        physical_or_device_operations: request.physical_or_device_operations,
        new_runtime_observations: request.new_runtime_observations,
        new_physical_observations: request.new_physical_observations,
        new_independent_physical_repeats: request.new_independent_physical_repeats,
        repeatability_complete: S574_REPEATABILITY_COMPLETE,
        r2_field_acceptance_complete: S574_R2_FIELD_ACCEPTANCE_COMPLETE,
        runbook_executed: request.runbook_executed,
    };

    match state.receipt {
        None => {
            state.receipt = Some(receipt);
            Ok(G8lS574FreezeOutcome::CandidateFrozen(receipt))
        }
        Some(existing) if existing == receipt => {
            Ok(G8lS574FreezeOutcome::CandidateRetained(existing))
        }
        Some(_) => Err(G8lS574FreezeError::PublishedStateDrift),
    }
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze::*;
use sha2::{Digest, Sha256};
use std::collections::HashSet;
use std::fs;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::path::{Path, PathBuf};
use std::process::Command;

const SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze.rs"
);
const MAIN: &str = include_str!("../../kernel/src/main.rs");
const SIMULATION_LIB: &str = include_str!("../src/lib.rs");
const S573_PROOF: &str = include_str!(
    "../../docs/M8.1-RPi5-G8l-S573-R2-Supported-Profile-Repeat-Campaign-Request-Contract-Proof.md"
);
const FREEZE_TOOL: &str = include_str!("../../scripts/freeze-rpi5-s574-r2-repeat-candidate.sh");
const PREFLIGHT_TOOL: &str = include_str!("../../scripts/preflight-rpi5-s575-r2-repeat.sh");
const CAPTURE_WRAPPER: &str = include_str!("../../scripts/capture-rpi5-s575-r2-repeat-uart.c");
const CAPTURE_ENGINE: &str = include_str!("../../scripts/capture-rpi5-s540-r1-uart.c");
const FREEZE_LOG: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/s574-freeze.log"
);
const EVIDENCE_MANIFEST: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/EVIDENCE_SHA256SUMS"
);
const BOARD_RPI5_CHECK_LOG: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/s574-board-rpi5-check.log"
);

const REFERENCE_FILES: [&str; S574_PACKAGE_ENTRIES] = [
    "evidence/rpi5/r1/sequence-570-candidate-freeze/package/aselsanos-rpi5.img",
    "evidence/rpi5/r1/sequence-570-candidate-freeze/package/bcm2712-rpi-5-b.dtb",
    "evidence/rpi5/r1/sequence-570-candidate-freeze/package/config.txt",
    "evidence/rpi5/r1/sequence-570-candidate-freeze/package/SHA256SUMS",
];
const FROZEN_FILES: [&str; S574_PACKAGE_ENTRIES] = [
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package/aselsanos-rpi5.img",
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package/bcm2712-rpi-5-b.dtb",
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package/config.txt",
    "evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package/SHA256SUMS",
];

fn sha256(bytes: &[u8]) -> String {
    format!("{:x}", Sha256::digest(bytes))
}

fn repository_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
}

fn repository_path(path: &str) -> PathBuf {
    repository_root().join(path)
}

fn identity(path: &str) -> G8lS574ArtifactIdentity {
    let bytes = fs::read(repository_path(path)).unwrap();
    s574_identity(
        bytes.len() as u64,
        Box::leak(sha256(&bytes).into_boxed_str()),
    )
}

fn entry(index: usize) -> G8lS574PackageEntryObservation {
    let source_bytes = fs::read(repository_path(REFERENCE_FILES[index])).unwrap();
    let destination_bytes = fs::read(repository_path(FROZEN_FILES[index])).unwrap();
    let source_metadata = fs::metadata(repository_path(REFERENCE_FILES[index])).unwrap();
    let destination_metadata = fs::metadata(repository_path(FROZEN_FILES[index])).unwrap();
    let names = [
        S574_IMAGE_NAME,
        S574_DTB_NAME,
        S574_CONFIG_NAME,
        S574_MANIFEST_NAME,
    ];
    G8lS574PackageEntryObservation {
        name: names[index],
        identity: s574_identity(
            destination_bytes.len() as u64,
            Box::leak(sha256(&destination_bytes).into_boxed_str()),
        ),
        mode: destination_metadata.permissions().mode() & 0o777,
        link_count: destination_metadata.nlink() as u32,
        source_inode: source_metadata.ino(),
        destination_inode: destination_metadata.ino(),
        byte_equal: source_bytes == destination_bytes,
    }
}

fn request() -> G8lS574FreezeRequest<'static> {
    G8lS574FreezeRequest {
        predecessor_sequence: S574_EXPECTED_PREDECESSOR,
        predecessor_status: "PASS",
        profile: S574_SUPPORTED_PROFILE,
        target_arch: S574_TARGET_ARCH,
        transport: S574_EVIDENCE_TRANSPORT,
        campaign_id: S574_CAMPAIGN_ID,
        reference_package: S574_REFERENCE_PACKAGE_DIRECTORY,
        destination_package: S574_PACKAGE_DIRECTORY,
        future_evidence_root: S574_FUTURE_S575_EVIDENCE_ROOT,
        future_transaction_lock_path: S574_FUTURE_S575_TRANSACTION_LOCK_PATH,
        retained_s571_lock_path: S574_RETAINED_S571_TRANSACTION_LOCK_PATH,
        package_directory_mode: fs::metadata(repository_path(S574_PACKAGE_DIRECTORY))
            .unwrap()
            .permissions()
            .mode()
            & 0o777,
        package: [entry(0), entry(1), entry(2), entry(3)],
        manifest: identity(FROZEN_FILES[3]),
        freeze_tool: identity(S574_FREEZE_TOOL_PATH),
        freeze_log: identity(S574_FREEZE_LOG_PATH),
        evidence_manifest: identity(S574_EVIDENCE_MANIFEST_PATH),
        board_rpi5_check_log: identity(S574_BOARD_RPI5_CHECK_LOG_PATH),
        preflight_tool: identity(S574_S575_PREFLIGHT_TOOL_PATH),
        capture_wrapper: identity(S574_S575_CAPTURE_WRAPPER_PATH),
        capture_engine: identity(S574_CAPTURE_ENGINE_PATH),
        authorization_token: None,
        reference_history_retained: true,
        s571_lock_retained: true,
        physical_or_device_operations: 0,
        new_runtime_observations: 0,
        new_physical_observations: 0,
        new_independent_physical_repeats: 0,
        runbook_executed: false,
    }
}

#[test]
fn sequence_profile_campaign_and_r2_workstream_are_exact() {
    assert_eq!(S574_SEQUENCE, 574);
    assert_eq!(S574_EXPECTED_PREDECESSOR, 573);
    assert_eq!(S574_NEXT_SEQUENCE, 575);
    assert_eq!(S574_R2_TRANSITION_FIRST, 572);
    assert_eq!(S574_R2_TRANSITION_LAST, 707);
    assert_eq!(S574_R2_WORKSTREAM_ORDINAL, 1);
    assert_eq!(S574_GATE_STATUS, "PASS");
    assert_eq!(S574_SUPPORTED_PROFILE, "board-rpi5");
    assert_eq!(S574_TARGET_ARCH, "aarch64");
    assert_eq!(S574_EVIDENCE_TRANSPORT, "uart-115200-8n1");
    assert_eq!(S574_CAMPAIGN_ID, "r2-ws01-board-rpi5-repeat-01");
}

#[test]
fn predecessor_request_pins_the_fresh_freeze_and_future_run_boundary() {
    assert!(S573_PROOF.contains("S574 must produce a fresh candidate-freeze record"));
    assert!(S573_PROOF.contains("S574 must not write the SD card"));
    assert!(S573_PROOF.contains(S574_FUTURE_S575_EVIDENCE_ROOT));
    assert!(S573_PROOF.contains(S574_FUTURE_S575_TRANSACTION_LOCK_PATH));
    assert_ne!(S574_PACKAGE_DIRECTORY, S574_REFERENCE_PACKAGE_DIRECTORY);
    assert_ne!(
        S574_FUTURE_S575_TRANSACTION_LOCK_PATH,
        S574_RETAINED_S571_TRANSACTION_LOCK_PATH
    );
}

#[test]
fn fresh_package_is_byte_equal_but_has_four_new_inodes() {
    let reference_dir = fs::metadata(repository_path(S574_REFERENCE_PACKAGE_DIRECTORY)).unwrap();
    let frozen_dir = fs::metadata(repository_path(S574_PACKAGE_DIRECTORY)).unwrap();
    assert_eq!(reference_dir.permissions().mode() & 0o777, 0o700);
    assert_eq!(frozen_dir.permissions().mode() & 0o777, 0o700);
    let source_inodes: HashSet<_> = REFERENCE_FILES
        .iter()
        .map(|path| fs::metadata(repository_path(path)).unwrap().ino())
        .collect();
    let destination_inodes: HashSet<_> = FROZEN_FILES
        .iter()
        .map(|path| fs::metadata(repository_path(path)).unwrap().ino())
        .collect();
    assert_eq!(source_inodes.len(), 4);
    assert_eq!(destination_inodes.len(), 4);
    assert!(source_inodes.is_disjoint(&destination_inodes));
    for index in 0..S574_PACKAGE_ENTRIES {
        assert_eq!(
            fs::read(repository_path(REFERENCE_FILES[index])).unwrap(),
            fs::read(repository_path(FROZEN_FILES[index])).unwrap()
        );
        let metadata = fs::metadata(repository_path(FROZEN_FILES[index])).unwrap();
        assert_eq!(metadata.permissions().mode() & 0o777, 0o444);
        assert_eq!(metadata.nlink(), 1);
    }
}

#[test]
fn package_identities_and_manifest_are_exact() {
    let expected = [
        (S574_IMAGE_BYTES, S574_IMAGE_SHA256),
        (S574_DTB_BYTES, S574_DTB_SHA256),
        (S574_CONFIG_BYTES, S574_CONFIG_SHA256),
        (S574_MANIFEST_BYTES, S574_MANIFEST_SHA256),
    ];
    for (path, (bytes, digest)) in FROZEN_FILES.iter().zip(expected) {
        let payload = fs::read(repository_path(path)).unwrap();
        assert_eq!(payload.len() as u64, bytes);
        assert_eq!(sha256(&payload), digest);
    }
    let manifest = fs::read_to_string(repository_path(FROZEN_FILES[3])).unwrap();
    assert_eq!(manifest.lines().count(), S574_MANIFEST_LINES);
    assert!(manifest.contains(S574_IMAGE_SHA256));
    assert!(manifest.contains(S574_DTB_SHA256));
    assert!(manifest.contains(S574_CONFIG_SHA256));
}

#[test]
fn freeze_log_proves_both_stage_and_final_fresh_identity_checks() {
    assert_eq!(FREEZE_LOG.matches("S574_ENTRY=").count(), 8);
    assert_eq!(FREEZE_LOG.matches("BYTE_EQUAL=YES").count(), 8);
    assert_eq!(FREEZE_LOG.matches("MODE=0444 NLINK=1").count(), 8);
    assert!(FREEZE_LOG.contains("S574_CANDIDATE_FREEZE=PASS"));
    assert!(FREEZE_LOG.contains("FRESH_RECORD=YES FRESH_INODES=4"));
    assert!(FREEZE_LOG.contains("PHYSICAL_OBSERVATIONS=0 DEVICE_OPERATIONS=0"));
    assert!(FREEZE_LOG.contains("SD_WRITES=0 UART_OPENS=0 POWER_TRANSITIONS=0"));
    assert!(FREEZE_LOG.contains("EXECUTION_PERMIT=0"));
}

#[test]
fn tool_and_log_source_identities_are_exact() {
    let expected = [
        (
            S574_FREEZE_TOOL_PATH,
            S574_FREEZE_TOOL_BYTES,
            S574_FREEZE_TOOL_SHA256,
        ),
        (
            S574_FREEZE_LOG_PATH,
            S574_FREEZE_LOG_BYTES,
            S574_FREEZE_LOG_SHA256,
        ),
        (
            S574_EVIDENCE_MANIFEST_PATH,
            S574_EVIDENCE_MANIFEST_BYTES,
            S574_EVIDENCE_MANIFEST_SHA256,
        ),
        (
            S574_BOARD_RPI5_CHECK_LOG_PATH,
            S574_BOARD_RPI5_CHECK_LOG_BYTES,
            S574_BOARD_RPI5_CHECK_LOG_SHA256,
        ),
        (
            S574_S575_PREFLIGHT_TOOL_PATH,
            S574_S575_PREFLIGHT_TOOL_BYTES,
            S574_S575_PREFLIGHT_TOOL_SHA256,
        ),
        (
            S574_S575_CAPTURE_WRAPPER_PATH,
            S574_S575_CAPTURE_WRAPPER_BYTES,
            S574_S575_CAPTURE_WRAPPER_SHA256,
        ),
        (
            S574_CAPTURE_ENGINE_PATH,
            S574_CAPTURE_ENGINE_BYTES,
            S574_CAPTURE_ENGINE_SHA256,
        ),
    ];
    for (path, bytes, digest) in expected {
        let payload = fs::read(repository_path(path)).unwrap();
        assert_eq!(payload.len() as u64, bytes, "{path}");
        assert_eq!(sha256(&payload), digest, "{path}");
    }
}

#[test]
fn evidence_manifest_and_board_rpi5_compile_log_are_exact() {
    assert_eq!(EVIDENCE_MANIFEST.lines().count(), 6);
    for digest in [
        S574_IMAGE_SHA256,
        S574_DTB_SHA256,
        S574_CONFIG_SHA256,
        S574_MANIFEST_SHA256,
        S574_FREEZE_LOG_SHA256,
        S574_BOARD_RPI5_CHECK_LOG_SHA256,
    ] {
        assert!(EVIDENCE_MANIFEST.contains(digest));
    }
    assert_eq!(S574_BOARD_RPI5_CHECK_EXIT_CODE, 0);
    assert_eq!(S574_BOARD_RPI5_COMPILER_REPORTED_WARNINGS, 4_496);
    assert_eq!(S574_BOARD_RPI5_WARNING_PREFIXED_LINES, 4_497);
    assert!(!S574_BOARD_RPI5_ZERO_WARNING_CLAIMED);
    assert!(!S574_MODULE_LINKED_INTO_BOARD_RPI5);
    assert!(BOARD_RPI5_CHECK_LOG
        .contains("warning: `aselsan_kernel` (bin \"aselsan_kernel\") generated 4496 warnings"));
    assert!(BOARD_RPI5_CHECK_LOG.contains("Finished `dev` profile"));
    assert!(!BOARD_RPI5_CHECK_LOG.contains("error: could not compile"));
}

#[test]
fn freeze_tool_is_host_only_and_source_check_passes() {
    for forbidden in [
        "diskutil",
        "ioreg",
        "system_profiler",
        "lsof",
        "/dev/disk",
        "/dev/cu.",
        "TIOCEXCL",
        "tcsetattr",
        "stty",
        "power-on",
    ] {
        assert!(
            !FREEZE_TOOL.contains(forbidden),
            "forbidden surface: {forbidden}"
        );
    }
    let output = Command::new("sh")
        .arg(S574_FREEZE_TOOL_PATH)
        .arg("--source-check")
        .current_dir(repository_root())
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.contains("S574_SOURCE_CHECK=PASS"));
    assert!(stdout.contains("DEVICE_OPERATIONS=0 EXECUTION_PERMIT=0"));
}

#[test]
fn immutable_package_verifier_passes_without_device_work() {
    let output = Command::new("sh")
        .arg(S574_FREEZE_TOOL_PATH)
        .arg("--verify-package")
        .arg(S574_PACKAGE_DIRECTORY)
        .current_dir(repository_root())
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.contains("S574_PACKAGE_VERIFY=PASS"));
    assert!(stdout.contains("DEVICE_OPERATIONS=0"));
}

#[test]
fn s575_preflight_source_is_bound_but_not_executed() {
    let output = Command::new("sh")
        .arg(S574_S575_PREFLIGHT_TOOL_PATH)
        .arg("--source-check")
        .arg(S574_PACKAGE_DIRECTORY)
        .current_dir(repository_root())
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.contains("S575_PREFLIGHT_SOURCE_CHECK=PASS"));
    assert!(stdout.contains("READ_ONLY=YES DEVICE_OPERATIONS=0"));
    assert!(stdout.contains("AUTHORIZATION_ACCEPTED=NO EXECUTION_PERMIT=0"));
    for forbidden in [
        "diskutil eject",
        "/bin/cp ",
        "/bin/mv ",
        "/bin/sync",
        " dd ",
        "mkfs",
        "newfs",
        "stty",
        "tcsetattr",
        "TIOCEXCL",
    ] {
        assert!(
            !PREFLIGHT_TOOL.contains(forbidden),
            "mutating surface: {forbidden}"
        );
    }
}

#[test]
fn capture_wrapper_binds_the_audited_engine_without_opening_it() {
    assert_eq!(
        CAPTURE_WRAPPER
            .matches("#include \"capture-rpi5-s540-r1-uart.c\"")
            .count(),
        1
    );
    assert!(CAPTURE_ENGINE.contains("TIOCEXCL"));
    assert!(CAPTURE_ENGINE.contains("tcsetattr"));
    assert!(S574_S575_CAPTURE_SOURCE_BOUND);
    assert!(!S574_S575_CAPTURE_BINARY_PREPARED);
    assert!(!S574_S575_TRANSACTION_TOOL_PREPARED);
}

#[test]
fn future_authorization_identity_is_data_only() {
    assert!(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN.starts_with(
        "S575_AUTHORIZE_FRESH_FREEZE_SD_WRITE_READBACK_EJECT_UART_PREARM_ONE_POWER_ON_"
    ));
    assert!(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN.contains(S574_IMAGE_SHA256));
    assert!(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN.contains(S574_EXPECTED_CARD_SERIAL_HEX));
    assert!(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN.contains("62549655552"));
    assert!(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN.ends_with(S574_CAMPAIGN_ID));
    assert!(!S574_AUTHORIZATION_RECEIVED);
    assert!(!S574_EXECUTION_PERMIT);
}

#[test]
fn physical_and_product_boundaries_remain_closed() {
    assert_eq!(S574_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert_eq!(S574_NEW_PHYSICAL_OBSERVATIONS, 0);
    assert_eq!(S574_NEW_INDEPENDENT_PHYSICAL_REPEATS, 0);
    assert_eq!(S574_PHYSICAL_OR_DEVICE_OPERATIONS, 0);
    assert_eq!(S574_SD_WRITES, 0);
    assert_eq!(S574_SD_READBACKS, 0);
    assert_eq!(S574_SD_EJECTS, 0);
    assert_eq!(S574_UART_OPENS, 0);
    assert_eq!(S574_POWER_TRANSITIONS, 0);
    assert_eq!(S574_NEW_RAW_CAPTURES, 0);
    assert!(!S574_PHYSICAL_RUN_EXECUTED);
    assert!(!S574_REPEATABILITY_COMPLETE);
    assert!(!S574_CROSS_PROFILE_COVERAGE_COMPLETE);
    assert!(!S574_R2_FIELD_ACCEPTANCE_COMPLETE);
    assert!(!S574_AUTOMATIC_PROMOTION);
    assert!(!RUNBOOK_EXECUTED_IN_S574);
}

#[test]
fn model_is_simulation_only_and_contains_no_device_surface() {
    let module = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze";
    assert!(!MAIN.contains(module));
    assert_eq!(
        SIMULATION_LIB
            .matches(&format!("pub mod {module};"))
            .count(),
        1
    );
    for forbidden in [
        "unsafe {",
        "asm!(",
        "global_asm!(",
        "kprintln!(",
        "std::process",
        "diskutil",
        "ioreg",
        "TIOCEXCL",
        "tcsetattr",
        "File::create",
        "OpenOptions",
    ] {
        assert!(
            !SOURCE.contains(forbidden),
            "forbidden model surface: {forbidden}"
        );
    }
}

#[test]
fn diagnostic_codes_are_unique_and_nonzero() {
    let errors = [
        G8lS574FreezeError::PredecessorRejected,
        G8lS574FreezeError::ProfileDrift,
        G8lS574FreezeError::CampaignDrift,
        G8lS574FreezeError::NamespaceDrift,
        G8lS574FreezeError::PackageShapeDrift,
        G8lS574FreezeError::PayloadIdentityDrift,
        G8lS574FreezeError::PackagePermissionDrift,
        G8lS574FreezeError::FreshIdentityRejected,
        G8lS574FreezeError::ToolIdentityDrift,
        G8lS574FreezeError::HistoryRewriteRejected,
        G8lS574FreezeError::PrematureAuthorizationRejected,
        G8lS574FreezeError::ObservationOverclaim,
        G8lS574FreezeError::PublishedStateDrift,
    ];
    let mut unique = HashSet::new();
    for code in errors.into_iter().map(G8lS574FreezeError::diagnostic_code) {
        assert_ne!(code, 0);
        assert!(unique.insert(code));
    }
    assert_eq!(unique.len(), 13);
}

#[test]
fn exact_request_publishes_the_fresh_freeze_receipt() {
    let mut state = G8lS574FreezeState::new();
    let G8lS574FreezeOutcome::CandidateFrozen(receipt) =
        service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, request())
            .unwrap()
    else {
        panic!("first exact request must freeze")
    };
    assert_eq!(receipt.sequence, 574);
    assert_eq!(receipt.predecessor_sequence, 573);
    assert_eq!(receipt.status, "PASS");
    assert_eq!(receipt.package_directory, S574_PACKAGE_DIRECTORY);
    assert_eq!(
        receipt.candidate,
        s574_identity(S574_IMAGE_BYTES, S574_IMAGE_SHA256)
    );
    assert_eq!(
        receipt.package_manifest,
        s574_identity(S574_MANIFEST_BYTES, S574_MANIFEST_SHA256)
    );
    assert!(receipt.fresh_record_created);
    assert!(receipt.reference_payload_byte_equal);
    assert_eq!(receipt.fresh_inode_count, 4);
    assert_ne!(receipt.package_inode_signature, 0);
    assert_eq!(receipt.future_physical_run_sequence, 575);
    assert!(!receipt.authorization_received);
    assert!(!receipt.execution_permit);
    assert!(receipt.read_only_preflight_source_bound);
    assert!(receipt.capture_source_bound);
    assert!(!receipt.transaction_tool_prepared);
    assert!(!receipt.capture_binary_prepared);
    assert_eq!(receipt.board_rpi5_check_exit_code, 0);
    assert_eq!(receipt.board_rpi5_compiler_reported_warnings, 4_496);
    assert!(!receipt.board_rpi5_zero_warning_claimed);
    assert!(!receipt.module_linked_into_board_rpi5);
    assert_eq!(receipt.physical_or_device_operations, 0);
    assert_eq!(state.receipt(), Some(receipt));
}

#[test]
fn exact_replay_is_idempotent_without_issuing_authority() {
    let mut state = G8lS574FreezeState::new();
    let G8lS574FreezeOutcome::CandidateFrozen(receipt) =
        service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, request())
            .unwrap()
    else {
        panic!("first request must freeze")
    };
    let G8lS574FreezeOutcome::CandidateRetained(retained) =
        service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, request())
            .unwrap()
    else {
        panic!("exact replay must retain")
    };
    assert_eq!(retained, receipt);
    assert!(!retained.authorization_received);
    assert!(!retained.execution_permit);
}

#[test]
fn predecessor_profile_and_campaign_drift_fail_closed() {
    let mut predecessor = request();
    predecessor.predecessor_sequence = 572;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            predecessor
        ),
        Err(G8lS574FreezeError::PredecessorRejected)
    );
    let mut profile = request();
    profile.profile = "qemu-virt";
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            profile
        ),
        Err(G8lS574FreezeError::ProfileDrift)
    );
    let mut campaign = request();
    campaign.campaign_id = "r2-ws01-reused";
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            campaign
        ),
        Err(G8lS574FreezeError::CampaignDrift)
    );
}

#[test]
fn namespace_and_legacy_lock_reuse_fail_closed() {
    let mut package = request();
    package.destination_package = S574_REFERENCE_PACKAGE_DIRECTORY;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            package
        ),
        Err(G8lS574FreezeError::NamespaceDrift)
    );
    let mut lock = request();
    lock.future_transaction_lock_path = S574_RETAINED_S571_TRANSACTION_LOCK_PATH;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            lock
        ),
        Err(G8lS574FreezeError::NamespaceDrift)
    );
}

#[test]
fn payload_permission_and_fresh_inode_drift_fail_closed() {
    let mut payload = request();
    payload.package[0].identity.bytes += 1;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            payload
        ),
        Err(G8lS574FreezeError::PayloadIdentityDrift)
    );
    let mut mode = request();
    mode.package[0].mode = 0o644;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            mode
        ),
        Err(G8lS574FreezeError::PackagePermissionDrift)
    );
    let mut inode = request();
    inode.package[0].destination_inode = inode.package[0].source_inode;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            inode
        ),
        Err(G8lS574FreezeError::FreshIdentityRejected)
    );
}

#[test]
fn cross_entry_inode_alias_and_byte_drift_fail_closed() {
    let mut alias = request();
    alias.package[1].destination_inode = alias.package[0].destination_inode;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            alias
        ),
        Err(G8lS574FreezeError::FreshIdentityRejected)
    );
    let mut equality = request();
    equality.package[2].byte_equal = false;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            equality
        ),
        Err(G8lS574FreezeError::FreshIdentityRejected)
    );
}

#[test]
fn tool_identity_drift_fails_closed() {
    let mut drift = request();
    drift.preflight_tool.bytes += 1;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            drift
        ),
        Err(G8lS574FreezeError::ToolIdentityDrift)
    );
}

#[test]
fn history_rewrite_authorization_and_observation_overclaim_fail_closed() {
    let mut history = request();
    history.reference_history_retained = false;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            history
        ),
        Err(G8lS574FreezeError::HistoryRewriteRejected)
    );
    let mut authorization = request();
    authorization.authorization_token = Some(S574_EXPECTED_FUTURE_AUTHORIZATION_TOKEN);
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            authorization
        ),
        Err(G8lS574FreezeError::PrematureAuthorizationRejected)
    );
    let mut observation = request();
    observation.physical_or_device_operations = 1;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(
            &mut G8lS574FreezeState::new(),
            observation
        ),
        Err(G8lS574FreezeError::ObservationOverclaim)
    );
}

#[test]
fn published_state_drift_fails_closed() {
    let mut state = G8lS574FreezeState::new();
    service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, request()).unwrap();
    let mut drift = request();
    drift.package[0].destination_inode = u64::MAX - 1;
    assert_eq!(
        service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, drift),
        Err(G8lS574FreezeError::PublishedStateDrift)
    );
}

#[test]
fn future_s575_requirements_are_not_s574_observations() {
    let mut state = G8lS574FreezeState::new();
    let G8lS574FreezeOutcome::CandidateFrozen(receipt) =
        service_s574_model_supported_profile_repeat_candidate_freeze(&mut state, request())
            .unwrap()
    else {
        panic!("exact request must freeze")
    };
    assert_eq!(receipt.required_future_sd_writes, 4);
    assert_eq!(receipt.required_future_sd_readbacks, 4);
    assert_eq!(receipt.required_future_sd_ejects, 1);
    assert_eq!(receipt.required_future_uart_opens, 1);
    assert_eq!(receipt.required_future_power_transitions, 2);
    assert_eq!(receipt.required_future_raw_captures, 1);
    assert_eq!(receipt.required_future_raw_mode_octal, "0444");
    assert_eq!(receipt.required_future_raw_link_count, 1);
    assert_eq!(receipt.new_runtime_observations, 0);
    assert_eq!(receipt.new_physical_observations, 0);
    assert_eq!(receipt.new_independent_physical_repeats, 0);
    assert!(!receipt.repeatability_complete);
    assert!(!receipt.r2_field_acceptance_complete);
    assert!(!receipt.runbook_executed);
}

#[test]
fn evidence_paths_exist_and_are_regular_or_directories_as_declared() {
    assert!(repository_path(S574_EVIDENCE_DIRECTORY).is_dir());
    assert!(repository_path(S574_PACKAGE_DIRECTORY).is_dir());
    assert!(repository_path(S574_FREEZE_TOOL_PATH).is_file());
    assert!(repository_path(S574_FREEZE_LOG_PATH).is_file());
    assert!(repository_path(S574_EVIDENCE_MANIFEST_PATH).is_file());
    assert!(repository_path(S574_BOARD_RPI5_CHECK_LOG_PATH).is_file());
    assert!(repository_path(S574_S575_PREFLIGHT_TOOL_PATH).is_file());
    assert!(repository_path(S574_S575_CAPTURE_WRAPPER_PATH).is_file());
    assert!(repository_path(S574_CAPTURE_ENGINE_PATH).is_file());
}

  {
    id: "g8l-s574-r2-supported-profile-repeat-candidate-freeze",
    date: "2026-08-31",
    sequence: 574,
    status: "passed",
    umbrella_status: "partial",
    title: "S574 · R2 fresh supported-profile tekrar aday dondurması",
    summary:
      "S574 dar host-only kapısı PASS'tir. S570/S571 dört-file payload'ı byte/SHA değiştirilmeden yeni S574 evidence yoluna dört fresh ve kaynak inode kümesiyle kesişmeyen inode üzerinden donduruldu. Exact S575 read-only preflight ile capture wrapper kaynakları bağlandı; board-rpi5 cargo check kalıcı log/SHA ile exit 0 verdi. S574 SD kartı veya Debug Probe'u incelemedi, SD/UART/güç/raw işlemi yapmadı ve concrete operatör yetkisi almadı. S575 transaction tool ve compiled capture binary henüz hazırlanmadığından execution permit false, repeatability ve R2 saha kabulü açıktır.",
    evidence: [
      "S574 R2 workstream 1 içindedir: acceptance domain=supported_profile_fresh_repeat_candidate_freeze, profile=board-rpi5, arch=aarch64, campaign=r2-ws01-board-rpi5-repeat-01.",
      "Kaynak package evidence/rpi5/r1/sequence-570-candidate-freeze/package; fresh package evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package'tır.",
      "Dört destination dosyası kaynakla byte-eş ve SHA-eştir; source/destination inode kümeleri 4+4 distinct ve disjoint'tir. Package mode=0700; file mode=0444; nlink=1.",
      "Image 945920 B / a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04; DTB 78703 B / 40a2fbe9c29e8b9a4912cf726a943068defb779fc052ec38e457a79c58abca00.",
      "Config 401 B / f1fd182fec3a6b46639195881b2b452efe019ca88556c58081aff0a05daee865; package SHA256SUMS 248 B / 83e8eb41c5fa0b81f5d05557cc1445c1d9834617126de3b798037e6d96025fe1.",
      "Freeze log 1439 B / 3742a9d9371240003395849d07a98911270ef6f97b2eb357153478888bac41a8; evidence manifest 531 B / 084d58b39eb2060639c839eb628b1e6f350ab992c53239b2a1a2b86f6bd27001 ve 6/6 rehash PASS'tir.",
      "Freeze tool 8896 B / 5562c426b21f48cf61fae7818055b12725e32e546a3850bcd8061f40a0a1ba55; S575 read-only preflight 11430 B / f846a01e0e4800c39600471d0b529efbddc7811cf512f400f7789edf733c751a.",
      "S575 capture wrapper 249 B / e4325ae7c9eef419aadc86cabdc2fcf94035d1026b3656d27ec1227060328c82 ve audited engine 20572 B / 9f001c4cec407bbb4310ca0f89d9cc7e8a1be32307ba8d7ea0541e315ff1efec olarak source-bound'dur; capture binary hazırlanmadı.",
      "Focused test 1 grup / 26 passed / 0 failed / 0 ignored / 0 filtered verdi.",
      "Board-rpi5 check exit 0'dır. Compiler 4496 warning bildirdi; aggregate dahil 4497 warning:-prefixed satır vardır ve zero-warning iddiası yoktur. Log 1698974 B / 879d6f5fb32ae95b6c6eecaba0e18b903e00a72f237211125ec4dd41e2bef60b'dir.",
      "S574 model simulation-only ve kernel'e linkli değildir; board check runtime invocation veya fiziksel gözlem değildir.",
      "Implementation 22716 B / cdd6b02b21eb0ec64bef2ed60606abf216679916f1361645dc274a17d3cccb35; focused test 27110 B / 6d3cedbeedd8a626ceeecb05341b27cbf55b0f1ef99ed355b6dca77f165de1e7; proof 5913 B / 716efe16358fc88a61a85cbd3981e8b4179b4e2448f86438debde1e2f9d4d3f7 SHA-256'dır.",
      "New runtime/physical/repeat=0/0/0; physical/device operations=0; authorization_received=false; execution_permit=false; RUNBOOK_EXECUTED_IN_S574=NO.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze -- --test-threads=1",
      "scripts/freeze-rpi5-s574-r2-repeat-candidate.sh --verify-package evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package",
      "scripts/preflight-rpi5-s575-r2-repeat.sh --source-check evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package",
      "cd evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze && shasum -a 256 -c EVIDENCE_SHA256SUMS",
      "CARGO_INCREMENTAL=0 cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test project_status_manifest -- --test-threads=1",
      "python3 scripts/render-project-status.py --check",
      "node website/scripts/generate-code-gates.mjs --check",
      "cd website && npm test && npx tsc --noEmit && npm run lint && npm run build",
      "cd website && npm run deploy",
      "curl -fsS https://aselsan.kerege.net/operations/s574/ && curl -fsS https://aselsan.kerege.net/code/s574/",
    ],
    terminalSessions: [
      {
        id: "s574-focused",
        title: "S574 fresh repeat candidate freeze focused kabulü",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze -- --test-threads=1",
        ],
        outputLines: [
          "test result: ok. 26 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out",
          "fresh record=true; byte-equal=true; source/destination inode sets disjoint=true",
          "new runtime/physical/repeat=0/0/0; device operations=0; execution permit=false",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s574-freeze-and-evidence",
        title: "S574 immutable package ve evidence rehash",
        commandLines: [
          "scripts/freeze-rpi5-s574-r2-repeat-candidate.sh --verify-package evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package",
          "cd evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze && shasum -a 256 -c EVIDENCE_SHA256SUMS",
        ],
        outputLines: [
          "S574_PACKAGE_VERIFY=PASS; package exact4; directory=0700; files=0444/nlink1",
          "reference and S574 payloads byte-equal; four fresh destination inodes",
          "EVIDENCE_SHA256SUMS: 6/6 OK; SD/UART/power operations=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s574-s575-preflight-source",
        title: "S575 read-only preflight source bağı",
        commandLines: [
          "scripts/preflight-rpi5-s575-r2-repeat.sh --source-check evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package",
        ],
        outputLines: [
          "S575_PREFLIGHT_SOURCE_CHECK=PASS; PACKAGE=S574; READ_ONLY=YES",
          "DEVICE_OPERATIONS=0 SD_WRITES=0 EJECTS=0 UART_OPENS=0 POWER_TRANSITIONS=0",
          "AUTHORIZATION_ACCEPTED=NO EXECUTION_PERMIT=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s574-board-rpi5-compile-check",
        title: "S574 supported board-profile compile kanıtı",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
        ],
        outputLines: [
          "cargo check exit 0; target=aarch64-unknown-none; features=board-rpi5; default-features=false",
          "compiler-reported warnings=4496; warning-prefixed lines including aggregate=4497; zero-warning claimed=false",
          "immutable log=1698974 B / 879d6f5fb32ae95b6c6eecaba0e18b903e00a72f237211125ec4dd41e2bef60b",
          "S574 module linked into kernel=false; runtime/physical observation=0/0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s574-status-site-publication",
        title: "S574 status, Operations ve Code yayın bağı",
        commandLines: [
          "python3 scripts/render-project-status.py --check",
          "node website/scripts/generate-code-gates.mjs --check",
          "cd website && npm test && npx tsc --noEmit && npm run lint && npm run build",
          "cd website && npm run deploy",
        ],
        outputLines: [
          "S574 source + focused test + proof + package/evidence + board log: exact identity-bound",
          "Operations /operations/s574 and Code /code/s574: statically generated",
          "production and custom-domain readback are required before closeout",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    limitations: [
      "S574 host-only candidate freeze PASS'tir; fiziksel tekrar veya supported-profile runtime gözlemi değildir.",
      "Gerçek S575 card/probe/Pi-off preflight henüz çalıştırılmadı.",
      "S575 transaction tool ve compiled capture binary henüz hazırlanmadı veya SHA-bound edilmedi.",
      "Concrete S575 operatör token'ı alınmadı; expected token yalnız contract data'dır.",
      "SD write/read-back/eject, UART open/pre-arm, power transition ve fresh raw capture sayıları S574'te sıfırdır.",
      "Independent physical repeat, repeatability, cross-profile coverage, visible scanout/input ve R2 saha kabulü tamamlanmamıştır.",
      "Board-rpi5 cargo check compile compatibility kanıtıdır; runtime veya fiziksel gözlem değildir.",
      "Derleme warnings sıfır değildir.",
      "RUNBOOK_EXECUTED_IN_S574=NO; physical/device operations=0.",
    ],
  },