S543 · R1 remediated fiziksel boot/UART retry — RED

#![allow(unexpected_cfgs)]

//! S543 records the second real R1 Raspberry Pi 5 boot/UART attempt.
//!
//! The exact S542 candidate was written to the exact removable card, read
//! back byte-for-byte, ejected, and observed through an exclusively opened
//! 115200/8N1 Debug Probe capture. The board again completed G8h, but neither
//! S541 readiness nor the required Boot-to-UI marker was emitted. The terminal
//! production line is `ASELSAN/S541ERR Cpu0ReadinessTimeout`; S543 is therefore
//! an immutable physical RED even though its evidence-integrity tests pass.
//!
//! The source audit narrows the cause: G8h consumes CPU1-owned PPI27 before the
//! generic timer path and disables that timer at completion, while the only
//! S541 CPU1 producer callsite is below that early return. Extending CPU0's
//! bounded wait cannot make the producer reachable. A later source gate must
//! move the producer to a reachable, ownership-safe boundary; a still later
//! sequence must create a new candidate and a new immutable physical raw.
//!
//! This host-evidence module is simulation-only. It performs no device or
//! power operation, cannot rewrite S540 or S543, and cannot promote S544.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s540_r1_first_physical_boot_uart_attempt_red::S540_RAW_SHA256;
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s542_r1_remediated_candidate_freeze_prearm_contract::{
    S542_CANDIDATE_PROFILE, S542_EXPECTED_CARD_RAW_CID, S542_EXPECTED_CARD_SERIAL_HEX,
    S542_EXPECTED_DEBUG_PROBE_SERIAL, S542_IMAGE_SHA256, S542_SEQUENCE, S542_TARGET_BOARD,
    S542_UART_BAUD, S542_UART_DATA_BITS, S542_UART_STOP_BITS,
};

pub const S543_SEQUENCE: usize = 543;
pub const S543_EXPECTED_PREDECESSOR: usize = S542_SEQUENCE;
pub const S543_NEXT_SEQUENCE: usize = 544;
pub const S543_R1_RANGE: &str = "S536-S565";

pub const S543_PRIOR_BOOT_MARKER: &str = "ASELSAN/BOOT8H";
pub const S543_REQUIRED_MARKER: &str = "[R1:S536] BOOT_TO_UI_READY";
pub const S543_ROUTE_MARKER: &str = "ASELSAN/S538 ROUTE=PRIOR_BOOT_TO_UI";
pub const S543_HANDOFF_MARKER: &str = "ASELSAN/S541 HANDOFF=CPU1_PREFLIGHT_ARMED";
pub const S543_ERROR_MARKER: &str = "ASELSAN/S541ERR";
pub const S543_ERROR_REASON: &str = "Cpu0ReadinessTimeout";
pub const S543_TERMINAL_ERROR_LINE: &str = "ASELSAN/S541ERR Cpu0ReadinessTimeout";

pub const S543_UART_DEVICE: &str = "/dev/cu.usbmodem21302";
pub const S543_RAW_BYTES: u64 = 20_509;
pub const S543_RAW_SHA256: &str =
    "1f1111a1a39ab6263b505b0889d025df19d5c48bb2f84e30708412b0da47dc11";
pub const S543_RAW_MODE: u32 = 0o444;
pub const S543_RAW_LINK_COUNT: u64 = 1;
pub const S543_RAW_INODE: u64 = 33_802_311;
pub const S543_RAW_LEADING_NUL_BYTES: usize = 3;
pub const S543_RAW_TOTAL_NUL_BYTES: usize = 3;
pub const S543_RAW_CR_BYTES: usize = 213;
pub const S543_RAW_LF_BYTES: usize = 213;
pub const S543_PRIOR_BOOT_MARKER_COUNT: usize = 1;
pub const S543_REQUIRED_MARKER_COUNT: usize = 0;
pub const S543_ROUTE_MARKER_COUNT: usize = 0;
pub const S543_HANDOFF_MARKER_COUNT: usize = 0;
pub const S543_ERROR_MARKER_COUNT: usize = 1;
pub const S543_ERROR_REASON_COUNT: usize = 1;
pub const S543_S538_ERROR_MARKER_COUNT: usize = 0;
pub const S543_PANIC_MARKER_COUNT: usize = 0;
pub const S543_UNKNOWN_IRQ_MARKER_COUNT: usize = 0;

pub const S543_FLASH_TOOL_BYTES: u64 = 23_814;
pub const S543_FLASH_TOOL_SHA256: &str =
    "53e007869ac2fdcb14fdaf201632f7c4470e0b4d34e7703ffbf5c40337025232";
pub const S543_CAPTURE_WRAPPER_BYTES: u64 = 351;
pub const S543_CAPTURE_WRAPPER_SHA256: &str =
    "b5c50b45f9a7517cad05ed2d8af369d6cb41d7fbc7909e5963fd7fb2d15476cb";
pub const S543_CAPTURE_ENGINE_BYTES: u64 = 20_572;
pub const S543_CAPTURE_ENGINE_SHA256: &str =
    "9f001c4cec407bbb4310ca0f89d9cc7e8a1be32307ba8d7ea0541e315ff1efec";
pub const S543_CAPTURE_BINARY_BYTES: u64 = 35_056;
pub const S543_CAPTURE_BINARY_SHA256: &str =
    "6c42d307b9f607e2cb5dde4173d300d0951a37f0ed82d185b81a3aa44272dfca";
pub const S543_ZERO_WRITE_PREFLIGHT_LOG_BYTES: u64 = 119;
pub const S543_ZERO_WRITE_PREFLIGHT_LOG_SHA256: &str =
    "207fc3ec03a1abd7c125e614fe749e467e50776d0bdfaa44edbb200972e7ef19";
pub const S543_SD_LOG_BYTES: u64 = 225;
pub const S543_SD_LOG_SHA256: &str =
    "a2204aaec3c6657c14d8901a58ad13596c8091d32732c87a7c3c5a077db7f62c";
pub const S543_CAPTURE_BUILD_LOG_BYTES: u64 = 540;
pub const S543_CAPTURE_BUILD_LOG_SHA256: &str =
    "4e3a36093b45cf403c823cfb842ed6fb61e390f9bbca84aa2b4d3e516eca29ee";
pub const S543_CAPTURE_CONTROL_LOG_BYTES: u64 = 484;
pub const S543_CAPTURE_CONTROL_LOG_SHA256: &str =
    "1f8d450c0c3f5157de46fe6d872b659494c0274e56551b292555ed7606d4ee56";
pub const S543_POWER_CLOSEOUT_LOG_BYTES: u64 = 892;
pub const S543_POWER_CLOSEOUT_LOG_SHA256: &str =
    "f3702d624310fe4f44f39bcced9774c92baa6d7394d5c6a4572c37f27ba780e3";

pub const S543_SD_WRITE_TRANSACTIONS: usize = 1;
pub const S543_SD_PAYLOAD_COMMITS: usize = 4;
pub const S543_SD_READ_BACK_VERIFICATIONS: usize = 4;
pub const S543_SD_EJECTS: usize = 1;
pub const S543_UART_OPENS: usize = 1;
pub const S543_UART_CAPTURES: usize = 1;
pub const S543_OPERATOR_REPORTED_POWER_TRANSITIONS: usize = 2;
pub const S543_INDEPENDENT_POWER_TRANSITION_OBSERVATIONS: usize = 0;
pub const S543_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 1;
pub const S543_PHYSICAL_OBSERVATIONS: usize = 1;
pub const S543_CAPTURE_SESSION_EXIT_CODE: i32 = 1;
pub const RUNBOOK_EXECUTED_IN_S543: bool = true;
pub const S543_BOOT_TO_UI_OBSERVED: bool = false;
pub const S543_R1_ACCEPTANCE_COMPLETE: bool = false;
pub const S543_RERUN_FORBIDDEN: bool = true;
pub const S543_AUTOMATIC_S544_PROMOTION: bool = false;
pub const S543_S540_RED_RETAINED: bool = true;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS543PhysicalVerdict {
    RedCpu0ReadinessTimeout,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS543PhysicalObservation {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub target_board: &'static str,
    pub profile: &'static str,
    pub candidate_image_sha256: &'static str,
    pub card_serial_hex: &'static str,
    pub card_raw_cid: &'static str,
    pub debug_probe_serial: &'static str,
    pub serial_device: &'static str,
    pub uart_baud: u32,
    pub uart_data_bits: u8,
    pub uart_stop_bits: u8,
    pub uart_parity_none: bool,
    pub uart_flow_control_none: bool,
    pub serial_open_exclusive: bool,
    pub serial_input_flushed_before_capture: bool,
    pub sd_candidate_read_back_exact: bool,
    pub sd_ejected_before_power_on: bool,
    pub capture_prearmed_before_power_on: bool,
    pub operator_power_on_reported: bool,
    pub operator_power_off_reported: bool,
    pub power_off_independently_observed: bool,
    pub raw_bytes: u64,
    pub raw_sha256: &'static str,
    pub raw_mode: u32,
    pub raw_link_count: u64,
    pub raw_finalized_read_only: bool,
    pub capture_session_exit_code: i32,
    pub leading_nul_bytes: usize,
    pub total_nul_bytes: usize,
    pub cr_bytes: usize,
    pub lf_bytes: usize,
    pub prior_boot_marker_count: usize,
    pub required_marker_count: usize,
    pub route_marker_count: usize,
    pub handoff_marker_count: usize,
    pub error_marker_count: usize,
    pub readiness_timeout_count: usize,
    pub s538_error_marker_count: usize,
    pub panic_marker_count: usize,
    pub unknown_irq_marker_count: usize,
}

pub const S543_CANONICAL_PHYSICAL_OBSERVATION: G8lS543PhysicalObservation =
    G8lS543PhysicalObservation {
        sequence: S543_SEQUENCE,
        predecessor_sequence: S543_EXPECTED_PREDECESSOR,
        target_board: S542_TARGET_BOARD,
        profile: S542_CANDIDATE_PROFILE,
        candidate_image_sha256: S542_IMAGE_SHA256,
        card_serial_hex: S542_EXPECTED_CARD_SERIAL_HEX,
        card_raw_cid: S542_EXPECTED_CARD_RAW_CID,
        debug_probe_serial: S542_EXPECTED_DEBUG_PROBE_SERIAL,
        serial_device: S543_UART_DEVICE,
        uart_baud: S542_UART_BAUD,
        uart_data_bits: S542_UART_DATA_BITS,
        uart_stop_bits: S542_UART_STOP_BITS,
        uart_parity_none: true,
        uart_flow_control_none: true,
        serial_open_exclusive: true,
        serial_input_flushed_before_capture: true,
        sd_candidate_read_back_exact: true,
        sd_ejected_before_power_on: true,
        capture_prearmed_before_power_on: true,
        operator_power_on_reported: true,
        operator_power_off_reported: true,
        power_off_independently_observed: false,
        raw_bytes: S543_RAW_BYTES,
        raw_sha256: S543_RAW_SHA256,
        raw_mode: S543_RAW_MODE,
        raw_link_count: S543_RAW_LINK_COUNT,
        raw_finalized_read_only: true,
        capture_session_exit_code: S543_CAPTURE_SESSION_EXIT_CODE,
        leading_nul_bytes: S543_RAW_LEADING_NUL_BYTES,
        total_nul_bytes: S543_RAW_TOTAL_NUL_BYTES,
        cr_bytes: S543_RAW_CR_BYTES,
        lf_bytes: S543_RAW_LF_BYTES,
        prior_boot_marker_count: S543_PRIOR_BOOT_MARKER_COUNT,
        required_marker_count: S543_REQUIRED_MARKER_COUNT,
        route_marker_count: S543_ROUTE_MARKER_COUNT,
        handoff_marker_count: S543_HANDOFF_MARKER_COUNT,
        error_marker_count: S543_ERROR_MARKER_COUNT,
        readiness_timeout_count: S543_ERROR_REASON_COUNT,
        s538_error_marker_count: S543_S538_ERROR_MARKER_COUNT,
        panic_marker_count: S543_PANIC_MARKER_COUNT,
        unknown_irq_marker_count: S543_UNKNOWN_IRQ_MARKER_COUNT,
    };

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS543ReachabilityAudit {
    pub g8h_interceptor_precedes_generic_timer_path: bool,
    pub g8h_owned_irq_returns_before_generic_timer_path: bool,
    pub s541_cpu1_producer_callsite_count: usize,
    pub s541_cpu1_producer_only_in_generic_timer_path: bool,
    pub g8h_terminal_timer_disabled: bool,
    pub cpu0_acquire_wait_seconds: u64,
    pub raw_handoff_marker_count: usize,
    pub raw_timeout_count: usize,
}

pub const S543_CANONICAL_REACHABILITY_AUDIT: G8lS543ReachabilityAudit = G8lS543ReachabilityAudit {
    g8h_interceptor_precedes_generic_timer_path: true,
    g8h_owned_irq_returns_before_generic_timer_path: true,
    s541_cpu1_producer_callsite_count: 1,
    s541_cpu1_producer_only_in_generic_timer_path: true,
    g8h_terminal_timer_disabled: true,
    cpu0_acquire_wait_seconds: 5,
    raw_handoff_marker_count: S543_HANDOFF_MARKER_COUNT,
    raw_timeout_count: S543_ERROR_REASON_COUNT,
};

pub const fn s543_physical_observation_is_exact(observation: G8lS543PhysicalObservation) -> bool {
    observation.sequence == S543_SEQUENCE
        && observation.predecessor_sequence == S543_EXPECTED_PREDECESSOR
        && str_eq(observation.target_board, S542_TARGET_BOARD)
        && str_eq(observation.profile, S542_CANDIDATE_PROFILE)
        && str_eq(observation.candidate_image_sha256, S542_IMAGE_SHA256)
        && str_eq(observation.card_serial_hex, S542_EXPECTED_CARD_SERIAL_HEX)
        && str_eq(observation.card_raw_cid, S542_EXPECTED_CARD_RAW_CID)
        && str_eq(
            observation.debug_probe_serial,
            S542_EXPECTED_DEBUG_PROBE_SERIAL,
        )
        && str_eq(observation.serial_device, S543_UART_DEVICE)
        && observation.uart_baud == S542_UART_BAUD
        && observation.uart_data_bits == S542_UART_DATA_BITS
        && observation.uart_stop_bits == S542_UART_STOP_BITS
        && observation.uart_parity_none
        && observation.uart_flow_control_none
        && observation.serial_open_exclusive
        && observation.serial_input_flushed_before_capture
        && observation.sd_candidate_read_back_exact
        && observation.sd_ejected_before_power_on
        && observation.capture_prearmed_before_power_on
        && observation.operator_power_on_reported
        && observation.operator_power_off_reported
        && !observation.power_off_independently_observed
        && observation.raw_bytes == S543_RAW_BYTES
        && str_eq(observation.raw_sha256, S543_RAW_SHA256)
        && observation.raw_mode == S543_RAW_MODE
        && observation.raw_link_count == S543_RAW_LINK_COUNT
        && observation.raw_finalized_read_only
        && observation.capture_session_exit_code == S543_CAPTURE_SESSION_EXIT_CODE
        && observation.leading_nul_bytes == S543_RAW_LEADING_NUL_BYTES
        && observation.total_nul_bytes == S543_RAW_TOTAL_NUL_BYTES
        && observation.cr_bytes == S543_RAW_CR_BYTES
        && observation.lf_bytes == S543_RAW_LF_BYTES
        && observation.prior_boot_marker_count == S543_PRIOR_BOOT_MARKER_COUNT
        && observation.required_marker_count == S543_REQUIRED_MARKER_COUNT
        && observation.route_marker_count == S543_ROUTE_MARKER_COUNT
        && observation.handoff_marker_count == S543_HANDOFF_MARKER_COUNT
        && observation.error_marker_count == S543_ERROR_MARKER_COUNT
        && observation.readiness_timeout_count == S543_ERROR_REASON_COUNT
        && observation.s538_error_marker_count == S543_S538_ERROR_MARKER_COUNT
        && observation.panic_marker_count == S543_PANIC_MARKER_COUNT
        && observation.unknown_irq_marker_count == S543_UNKNOWN_IRQ_MARKER_COUNT
}

pub const fn s543_reachability_audit_supports_root_cause(audit: G8lS543ReachabilityAudit) -> bool {
    audit.g8h_interceptor_precedes_generic_timer_path
        && audit.g8h_owned_irq_returns_before_generic_timer_path
        && audit.s541_cpu1_producer_callsite_count == 1
        && audit.s541_cpu1_producer_only_in_generic_timer_path
        && audit.g8h_terminal_timer_disabled
        && audit.cpu0_acquire_wait_seconds == 5
        && audit.raw_handoff_marker_count == 0
        && audit.raw_timeout_count == 1
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS543PhysicalAttemptReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub verdict: G8lS543PhysicalVerdict,
    pub candidate_image_sha256: &'static str,
    pub raw_sha256: &'static str,
    pub historical_s540_raw_sha256: &'static str,
    pub candidate_booted_through_g8h: bool,
    pub s541_handoff_observed: bool,
    pub boot_to_ui_observed: bool,
    pub r1_acceptance_complete: bool,
    pub s540_red_retained: bool,
    pub s543_rerun_forbidden: bool,
    pub automatic_s544_promotion: bool,
    pub next_sequence: usize,
    pub separate_remediation_and_retry_required: bool,
    pub operator_power_off_reported: bool,
    pub power_off_independently_observed: bool,
}

#[derive(Debug, Default)]
pub struct G8lS543PhysicalAttemptState {
    receipt: Option<G8lS543PhysicalAttemptReceipt>,
}

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

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS543PhysicalAttemptOutcome {
    AwaitingPhysicalObservation,
    RedRecorded(G8lS543PhysicalAttemptReceipt),
    RedRetained(G8lS543PhysicalAttemptReceipt),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS543PhysicalAttemptError {
    ObservationDrift,
    ReachabilityAuditDrift,
    RecordedStateDrift,
}

pub fn record_s543_model_physical_attempt(
    state: &mut G8lS543PhysicalAttemptState,
    observation: Option<G8lS543PhysicalObservation>,
    audit: G8lS543ReachabilityAudit,
) -> Result<G8lS543PhysicalAttemptOutcome, G8lS543PhysicalAttemptError> {
    let Some(observation) = observation else {
        return Ok(G8lS543PhysicalAttemptOutcome::AwaitingPhysicalObservation);
    };
    if !s543_physical_observation_is_exact(observation) {
        return Err(G8lS543PhysicalAttemptError::ObservationDrift);
    }
    if !s543_reachability_audit_supports_root_cause(audit) {
        return Err(G8lS543PhysicalAttemptError::ReachabilityAuditDrift);
    }
    let receipt = G8lS543PhysicalAttemptReceipt {
        sequence: S543_SEQUENCE,
        predecessor_sequence: S543_EXPECTED_PREDECESSOR,
        verdict: G8lS543PhysicalVerdict::RedCpu0ReadinessTimeout,
        candidate_image_sha256: S542_IMAGE_SHA256,
        raw_sha256: S543_RAW_SHA256,
        historical_s540_raw_sha256: S540_RAW_SHA256,
        candidate_booted_through_g8h: true,
        s541_handoff_observed: false,
        boot_to_ui_observed: S543_BOOT_TO_UI_OBSERVED,
        r1_acceptance_complete: S543_R1_ACCEPTANCE_COMPLETE,
        s540_red_retained: S543_S540_RED_RETAINED,
        s543_rerun_forbidden: S543_RERUN_FORBIDDEN,
        automatic_s544_promotion: S543_AUTOMATIC_S544_PROMOTION,
        next_sequence: S543_NEXT_SEQUENCE,
        separate_remediation_and_retry_required: true,
        operator_power_off_reported: observation.operator_power_off_reported,
        power_off_independently_observed: observation.power_off_independently_observed,
    };
    if let Some(recorded) = state.receipt {
        if recorded != receipt {
            return Err(G8lS543PhysicalAttemptError::RecordedStateDrift);
        }
        return Ok(G8lS543PhysicalAttemptOutcome::RedRetained(recorded));
    }
    state.receipt = Some(receipt);
    Ok(G8lS543PhysicalAttemptOutcome::RedRecorded(receipt))
}

const fn str_eq(left: &str, right: &str) -> bool {
    let left = left.as_bytes();
    let right = right.as_bytes();
    if left.len() != right.len() {
        return false;
    }
    let mut index = 0;
    while index < left.len() {
        if left[index] != right[index] {
            return false;
        }
        index += 1;
    }
    true
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s543_r1_remediated_physical_boot_uart_retry_red::*;
use sha2::{Digest, Sha256};
use std::fs;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::path::{Path, PathBuf};

const SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s543_r1_remediated_physical_boot_uart_retry_red.rs"
);
const S541_SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s541_r1_cross_cpu_marker_readiness_handoff.rs"
);
const EXCEPTIONS_SOURCE: &str = include_str!("../../kernel/src/arch/aarch64/exceptions.rs");
const G8H_SOURCE: &str = include_str!("../../kernel/src/rpi5_g8h.rs");
const SIMULATION_LIB: &str = include_str!("../src/lib.rs");
const KERNEL_MAIN: &str = include_str!("../../kernel/src/main.rs");
const FLASH_TOOL: &[u8] =
    include_bytes!("../../scripts/flash-rpi5-s543-r1-remediated-candidate.sh");
const CAPTURE_WRAPPER: &[u8] = include_bytes!("../../scripts/capture-rpi5-s543-r1-uart.c");
const CAPTURE_ENGINE: &[u8] = include_bytes!("../../scripts/capture-rpi5-s540-r1-uart.c");
const RAW: &[u8] =
    include_bytes!("../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-uart.raw");
const ZERO_WRITE_PREFLIGHT_LOG: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-zero-write-preflight.log"
);
const SD_LOG: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-sd-write-readback-eject.log"
);
const CAPTURE_BUILD_LOG: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-uart-capture-build.log"
);
const CAPTURE_CONTROL_LOG: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-uart-capture-control.log"
);
const POWER_CLOSEOUT_LOG: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-power-closeout.log"
);

fn repository_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .expect("simulation repository parent")
        .to_path_buf()
}

fn sha256(bytes: impl AsRef<[u8]>) -> String {
    format!("{:x}", Sha256::digest(bytes.as_ref()))
}

fn count_bytes(haystack: &[u8], needle: &[u8]) -> usize {
    haystack
        .windows(needle.len())
        .filter(|window| *window == needle)
        .count()
}

fn leading_nul_bytes(bytes: &[u8]) -> usize {
    bytes.iter().take_while(|byte| **byte == 0).count()
}

#[test]
fn sequence_and_physical_scope_are_exact() {
    assert_eq!(S543_SEQUENCE, 543);
    assert_eq!(S543_EXPECTED_PREDECESSOR, 542);
    assert_eq!(S543_NEXT_SEQUENCE, 544);
    assert_eq!(S543_R1_RANGE, "S536-S565");
    assert_eq!(S543_SD_WRITE_TRANSACTIONS, 1);
    assert_eq!(S543_SD_PAYLOAD_COMMITS, 4);
    assert_eq!(S543_SD_READ_BACK_VERIFICATIONS, 4);
    assert_eq!(S543_SD_EJECTS, 1);
    assert_eq!(S543_UART_OPENS, 1);
    assert_eq!(S543_UART_CAPTURES, 1);
    assert_eq!(S543_OPERATOR_REPORTED_POWER_TRANSITIONS, 2);
    assert_eq!(S543_INDEPENDENT_POWER_TRANSITION_OBSERVATIONS, 0);
    assert_eq!(S543_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 1);
    assert_eq!(S543_PHYSICAL_OBSERVATIONS, 1);
    assert!(RUNBOOK_EXECUTED_IN_S543);
    assert!(S543_RERUN_FORBIDDEN);
    assert!(S543_S540_RED_RETAINED);
    assert!(!S543_BOOT_TO_UI_OBSERVED);
    assert!(!S543_R1_ACCEPTANCE_COMPLETE);
    assert!(!S543_AUTOMATIC_S544_PROMOTION);
}

#[test]
fn missing_physical_observation_waits_without_mutation() {
    let mut state = G8lS543PhysicalAttemptState::new();
    assert_eq!(
        record_s543_model_physical_attempt(&mut state, None, S543_CANONICAL_REACHABILITY_AUDIT),
        Ok(G8lS543PhysicalAttemptOutcome::AwaitingPhysicalObservation)
    );
    assert_eq!(state.receipt(), None);
}

#[test]
fn exact_observation_is_red_and_never_a_pass() {
    assert!(s543_physical_observation_is_exact(
        S543_CANONICAL_PHYSICAL_OBSERVATION
    ));
    assert!(s543_reachability_audit_supports_root_cause(
        S543_CANONICAL_REACHABILITY_AUDIT
    ));
    let mut state = G8lS543PhysicalAttemptState::new();
    let G8lS543PhysicalAttemptOutcome::RedRecorded(receipt) = record_s543_model_physical_attempt(
        &mut state,
        Some(S543_CANONICAL_PHYSICAL_OBSERVATION),
        S543_CANONICAL_REACHABILITY_AUDIT,
    )
    .unwrap() else {
        panic!("S543 must record RED");
    };
    assert_eq!(
        receipt.verdict,
        G8lS543PhysicalVerdict::RedCpu0ReadinessTimeout
    );
    assert!(receipt.candidate_booted_through_g8h);
    assert!(!receipt.s541_handoff_observed);
    assert!(!receipt.boot_to_ui_observed);
    assert!(!receipt.r1_acceptance_complete);
    assert!(receipt.s540_red_retained);
    assert!(receipt.s543_rerun_forbidden);
    assert!(!receipt.automatic_s544_promotion);
    assert_eq!(receipt.next_sequence, 544);
    assert!(receipt.separate_remediation_and_retry_required);
    assert!(receipt.operator_power_off_reported);
    assert!(!receipt.power_off_independently_observed);
}

#[test]
fn exact_red_replay_retains_the_same_receipt() {
    let mut state = G8lS543PhysicalAttemptState::new();
    let first = record_s543_model_physical_attempt(
        &mut state,
        Some(S543_CANONICAL_PHYSICAL_OBSERVATION),
        S543_CANONICAL_REACHABILITY_AUDIT,
    )
    .unwrap();
    let G8lS543PhysicalAttemptOutcome::RedRecorded(receipt) = first else {
        panic!("first S543 RED missing");
    };
    assert_eq!(
        record_s543_model_physical_attempt(
            &mut state,
            Some(S543_CANONICAL_PHYSICAL_OBSERVATION),
            S543_CANONICAL_REACHABILITY_AUDIT,
        ),
        Ok(G8lS543PhysicalAttemptOutcome::RedRetained(receipt))
    );
}

#[test]
fn every_material_observation_drift_fails_closed() {
    let exact = S543_CANONICAL_PHYSICAL_OBSERVATION;
    let mut variants = Vec::new();
    let mut drift = exact;
    drift.sequence = 544;
    variants.push(drift);
    drift = exact;
    drift.candidate_image_sha256 = "wrong";
    variants.push(drift);
    drift = exact;
    drift.card_serial_hex = "wrong";
    variants.push(drift);
    drift = exact;
    drift.debug_probe_serial = "wrong";
    variants.push(drift);
    drift = exact;
    drift.serial_open_exclusive = false;
    variants.push(drift);
    drift = exact;
    drift.sd_candidate_read_back_exact = false;
    variants.push(drift);
    drift = exact;
    drift.operator_power_off_reported = false;
    variants.push(drift);
    drift = exact;
    drift.raw_sha256 = "wrong";
    variants.push(drift);
    drift = exact;
    drift.raw_mode = 0o644;
    variants.push(drift);
    drift = exact;
    drift.handoff_marker_count = 1;
    variants.push(drift);
    drift = exact;
    drift.required_marker_count = 1;
    variants.push(drift);
    drift = exact;
    drift.error_marker_count = 0;
    variants.push(drift);
    drift = exact;
    drift.panic_marker_count = 1;
    variants.push(drift);

    for variant in variants {
        let mut state = G8lS543PhysicalAttemptState::new();
        assert_eq!(
            record_s543_model_physical_attempt(
                &mut state,
                Some(variant),
                S543_CANONICAL_REACHABILITY_AUDIT,
            ),
            Err(G8lS543PhysicalAttemptError::ObservationDrift)
        );
        assert_eq!(state.receipt(), None);
    }
}

#[test]
fn every_reachability_audit_drift_fails_closed() {
    let exact = S543_CANONICAL_REACHABILITY_AUDIT;
    let mut variants = Vec::new();
    let mut drift = exact;
    drift.g8h_interceptor_precedes_generic_timer_path = false;
    variants.push(drift);
    drift = exact;
    drift.g8h_owned_irq_returns_before_generic_timer_path = false;
    variants.push(drift);
    drift = exact;
    drift.s541_cpu1_producer_callsite_count = 2;
    variants.push(drift);
    drift = exact;
    drift.s541_cpu1_producer_only_in_generic_timer_path = false;
    variants.push(drift);
    drift = exact;
    drift.g8h_terminal_timer_disabled = false;
    variants.push(drift);
    drift = exact;
    drift.cpu0_acquire_wait_seconds = 10;
    variants.push(drift);
    drift = exact;
    drift.raw_handoff_marker_count = 1;
    variants.push(drift);
    drift = exact;
    drift.raw_timeout_count = 0;
    variants.push(drift);

    for audit in variants {
        let mut state = G8lS543PhysicalAttemptState::new();
        assert_eq!(
            record_s543_model_physical_attempt(
                &mut state,
                Some(S543_CANONICAL_PHYSICAL_OBSERVATION),
                audit,
            ),
            Err(G8lS543PhysicalAttemptError::ReachabilityAuditDrift)
        );
    }
}

#[test]
fn immutable_raw_has_exact_identity_mode_link_and_inode() {
    assert_eq!(RAW.len() as u64, S543_RAW_BYTES);
    assert_eq!(sha256(RAW), S543_RAW_SHA256);
    let path = repository_root()
        .join("evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-uart.raw");
    let metadata = fs::metadata(path).unwrap();
    assert_eq!(metadata.permissions().mode() & 0o777, S543_RAW_MODE);
    assert_eq!(metadata.nlink(), S543_RAW_LINK_COUNT);
    assert_eq!(metadata.ino(), S543_RAW_INODE);
    assert!(metadata.is_file());
}

#[test]
fn raw_wire_shape_preserves_exact_nuls_and_line_endings() {
    assert_eq!(leading_nul_bytes(RAW), S543_RAW_LEADING_NUL_BYTES);
    assert_eq!(
        RAW.iter().filter(|byte| **byte == 0).count(),
        S543_RAW_TOTAL_NUL_BYTES
    );
    assert_eq!(
        RAW.iter().filter(|byte| **byte == b'\r').count(),
        S543_RAW_CR_BYTES
    );
    assert_eq!(
        RAW.iter().filter(|byte| **byte == b'\n').count(),
        S543_RAW_LF_BYTES
    );
}

#[test]
fn raw_binds_exact_card_candidate_config_dtb_and_board() {
    assert_eq!(
        count_bytes(RAW, b"CID: 009f5449534436344761425001fa01a1"),
        1
    );
    assert_eq!(count_bytes(RAW, b"ASELSANBOOT"), 2);
    assert_eq!(count_bytes(RAW, b"Read config.txt bytes      415"), 1);
    assert_eq!(
        count_bytes(RAW, b"Read bcm2712-rpi-5-b.dtb bytes    78703"),
        1
    );
    assert_eq!(count_bytes(RAW, b"Board: Raspberry Pi 5 (BCM2712)"), 1);
}

#[test]
fn raw_reaches_g8h_then_records_exact_s541_timeout_red() {
    assert_eq!(
        count_bytes(RAW, S543_PRIOR_BOOT_MARKER.as_bytes()),
        S543_PRIOR_BOOT_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, S543_REQUIRED_MARKER.as_bytes()),
        S543_REQUIRED_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, S543_ROUTE_MARKER.as_bytes()),
        S543_ROUTE_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, S543_HANDOFF_MARKER.as_bytes()),
        S543_HANDOFF_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, S543_ERROR_MARKER.as_bytes()),
        S543_ERROR_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, S543_ERROR_REASON.as_bytes()),
        S543_ERROR_REASON_COUNT
    );
    assert_eq!(count_bytes(RAW, S543_TERMINAL_ERROR_LINE.as_bytes()), 1);
    assert_eq!(count_bytes(RAW, b"ASELSAN/S538ERR"), 0);
    let boot = RAW
        .windows(S543_PRIOR_BOOT_MARKER.len())
        .position(|window| window == S543_PRIOR_BOOT_MARKER.as_bytes())
        .unwrap();
    let error = RAW
        .windows(S543_TERMINAL_ERROR_LINE.len())
        .position(|window| window == S543_TERMINAL_ERROR_LINE.as_bytes())
        .unwrap();
    assert!(boot < error);
}

#[test]
fn raw_has_no_panic_or_unknown_irq_marker() {
    assert_eq!(count_bytes(RAW, b"panic"), S543_PANIC_MARKER_COUNT);
    assert_eq!(count_bytes(RAW, b"PANIC"), S543_PANIC_MARKER_COUNT);
    assert_eq!(
        count_bytes(RAW, b"unknown IRQ"),
        S543_UNKNOWN_IRQ_MARKER_COUNT
    );
    assert_eq!(
        count_bytes(RAW, "Bilinmeyen IRQ".as_bytes()),
        S543_UNKNOWN_IRQ_MARKER_COUNT
    );
}

#[test]
fn source_order_proves_the_cpu1_producer_is_below_g8h_early_return() {
    assert_eq!(
        EXCEPTIONS_SOURCE
            .matches("service_s541_readiness_handoff_on_cpu1()")
            .count(),
        1
    );
    let interceptor = EXCEPTIONS_SOURCE
        .find("crate::rpi5_g8h::rpi5_g8h_try_handle_secondary_irq")
        .unwrap();
    let generic_timer = EXCEPTIONS_SOURCE
        .find("if let Some(_tick) = timer_tick")
        .unwrap();
    let producer = EXCEPTIONS_SOURCE
        .find("service_s541_readiness_handoff_on_cpu1()")
        .unwrap();
    assert!(interceptor < generic_timer && generic_timer < producer);
    let early_return = &EXCEPTIONS_SOURCE[interceptor..generic_timer];
    assert!(early_return.contains("return g8h_resume_ctx;"));
    assert!(G8H_SOURCE.contains("timer::read_control() & 0b11 != 0b10"));
    assert!(G8H_SOURCE.contains("FINAL_TIMER_CTL.store(timer::read_control()"));
    assert!(RAW
        .windows(b"FINAL_TIMER=OFF".len())
        .any(|window| window == b"FINAL_TIMER=OFF"));
    assert!(S541_SOURCE.contains("S541_CPU0_READINESS_TIMEOUT_SECONDS: u64 = 5"));
    assert!(S541_SOURCE.contains("S541_PRODUCTION_READY_REQUEST_ID.load(Ordering::Acquire)"));
    assert!(S541_SOURCE.contains("Cpu0ReadinessTimeout"));
}

#[test]
fn one_shot_writer_pins_candidate_card_probe_and_never_opens_uart_or_power() {
    assert_eq!(FLASH_TOOL.len() as u64, S543_FLASH_TOOL_BYTES);
    assert_eq!(sha256(FLASH_TOOL), S543_FLASH_TOOL_SHA256);
    let source = std::str::from_utf8(FLASH_TOOL).unwrap();
    for required in [
        "EXPECTED_IMAGE_SHA256=aa0c459b987c3f4c143b4eb14ce0ed655c2812e2a36516793e7bd8b27b60d87c",
        "EXPECTED_CARD_SERIAL_HEX=0x425001fa",
        "EXPECTED_USB_SERIAL=E6647C74033F9131",
        "S543_AUTHORIZE_SD_WRITE_READBACK_EJECT_UART_PREARM_ONE_POWER_ON_aa0c459b_425001fa_62549655552",
        "RERUN_FORBIDDEN=YES",
        "UART=NOT_OPENED POWER=NOT_RUN",
    ] {
        assert!(source.contains(required), "missing writer contract: {required}");
    }
    assert!(!source.contains("stty"));
    assert!(!source.contains("screen "));
}

#[test]
fn capture_wrapper_preserves_the_audited_exclusive_engine() {
    assert_eq!(CAPTURE_WRAPPER.len() as u64, S543_CAPTURE_WRAPPER_BYTES);
    assert_eq!(sha256(CAPTURE_WRAPPER), S543_CAPTURE_WRAPPER_SHA256);
    assert_eq!(CAPTURE_ENGINE.len() as u64, S543_CAPTURE_ENGINE_BYTES);
    assert_eq!(sha256(CAPTURE_ENGINE), S543_CAPTURE_ENGINE_SHA256);
    let wrapper = std::str::from_utf8(CAPTURE_WRAPPER).unwrap();
    assert_eq!(
        wrapper
            .matches("#include \"capture-rpi5-s540-r1-uart.c\"")
            .count(),
        1
    );
    let engine = std::str::from_utf8(CAPTURE_ENGINE).unwrap();
    for required in [
        "#define TERMINAL_MARKER \"[R1:S536] BOOT_TO_UI_READY\"",
        "TIOCEXCL",
        "B115200",
        "TCIFLUSH",
        "O_WRONLY | O_CREAT | O_EXCL",
        "fchmod(output_fd, 0444)",
    ] {
        assert!(
            engine.contains(required),
            "missing capture contract: {required}"
        );
    }
}

#[test]
fn preparation_and_capture_logs_have_exact_immutable_identities() {
    let logs = [
        (
            "s543-zero-write-preflight.log",
            ZERO_WRITE_PREFLIGHT_LOG,
            S543_ZERO_WRITE_PREFLIGHT_LOG_BYTES,
            S543_ZERO_WRITE_PREFLIGHT_LOG_SHA256,
        ),
        (
            "s543-sd-write-readback-eject.log",
            SD_LOG,
            S543_SD_LOG_BYTES,
            S543_SD_LOG_SHA256,
        ),
        (
            "s543-uart-capture-build.log",
            CAPTURE_BUILD_LOG,
            S543_CAPTURE_BUILD_LOG_BYTES,
            S543_CAPTURE_BUILD_LOG_SHA256,
        ),
        (
            "s543-uart-capture-control.log",
            CAPTURE_CONTROL_LOG,
            S543_CAPTURE_CONTROL_LOG_BYTES,
            S543_CAPTURE_CONTROL_LOG_SHA256,
        ),
    ];
    for (name, bytes, expected_bytes, expected_sha) in logs {
        assert_eq!(bytes.len() as u64, expected_bytes, "{name} bytes");
        assert_eq!(sha256(bytes), expected_sha, "{name} SHA-256");
        let metadata = fs::metadata(
            repository_root()
                .join("evidence/rpi5/r1/sequence-543-remediated-physical-retry")
                .join(name),
        )
        .unwrap();
        assert_eq!(metadata.permissions().mode() & 0o777, 0o444, "{name} mode");
        assert_eq!(metadata.nlink(), 1, "{name} link count");
    }
    let preflight = std::str::from_utf8(ZERO_WRITE_PREFLIGHT_LOG).unwrap();
    assert!(preflight.contains("WRITE=0 EJECT=0 UART_OPEN=0 POWER=0"));
    let sd = std::str::from_utf8(SD_LOG).unwrap();
    assert!(sd.contains("exact4 staged/commit/read-back/sync/eject"));
    assert!(sd.contains("EJECT=PASS UART=NOT_OPENED POWER=NOT_RUN"));
    let build = std::str::from_utf8(CAPTURE_BUILD_LOG).unwrap();
    assert!(build.contains(&format!(
        "binary_bytes={} binary_sha256={}",
        S543_CAPTURE_BINARY_BYTES, S543_CAPTURE_BINARY_SHA256
    )));
    let control = std::str::from_utf8(CAPTURE_CONTROL_LOG).unwrap();
    assert!(control.contains("exclusive_request=TIOCEXCL_APPLIED"));
    assert!(control.contains("effective_baud_115200=true"));
    assert!(control.contains("format=8N1 raw=true flow_control=false"));
    assert!(control.contains("input_flushed=true method=TCIFLUSH"));
    assert!(control.contains("capture_armed=YES"));
}

#[test]
fn power_closeout_records_operator_transitions_without_electrical_overclaim() {
    assert_eq!(
        POWER_CLOSEOUT_LOG.len() as u64,
        S543_POWER_CLOSEOUT_LOG_BYTES
    );
    assert_eq!(sha256(POWER_CLOSEOUT_LOG), S543_POWER_CLOSEOUT_LOG_SHA256);
    let path = repository_root()
        .join("evidence/rpi5/r1/sequence-543-remediated-physical-retry/s543-power-closeout.log");
    let metadata = fs::metadata(path).unwrap();
    assert_eq!(metadata.permissions().mode() & 0o777, 0o444);
    assert_eq!(metadata.nlink(), 1);
    let closeout = std::str::from_utf8(POWER_CLOSEOUT_LOG).unwrap();
    assert!(closeout.contains("OPERATOR_POWER_ON_REPORTED=YES"));
    assert!(closeout.contains("OPERATOR_POWER_OFF_REPORTED=YES"));
    assert!(closeout.contains("INDEPENDENT_POWER_TRANSITION_OBSERVATIONS=0"));
    assert!(closeout.contains("UART_HOLDERS_AFTER_CLOSEOUT=0"));
    assert!(closeout.contains("PHYSICAL_VERDICT=RED_CPU0_READINESS_TIMEOUT"));
    assert!(closeout.contains("S543_RERUN_FORBIDDEN=YES"));
    assert!(closeout.contains("AUTOMATIC_S544_PROMOTION=NO"));
}

#[test]
fn historical_s540_red_raw_remains_byte_exact_and_unpromoted() {
    let path =
        repository_root().join("evidence/rpi5/r1/sequence-540-physical-boot-uart/s540-uart.raw");
    let raw = fs::read(&path).unwrap();
    let metadata = fs::metadata(path).unwrap();
    assert_eq!(raw.len(), 20_525);
    assert_eq!(
        sha256(&raw),
        "fc3f934543ab5d829ad8a16e2b332dd2bdc35a81c6c0f6423256101448e45114"
    );
    assert_eq!(metadata.permissions().mode() & 0o777, 0o444);
    assert_eq!(metadata.nlink(), 1);
    assert_eq!(count_bytes(&raw, b"ASELSAN/S538ERR AwaitingPreflight"), 1);
    assert!(S543_S540_RED_RETAINED);
}

#[test]
fn host_evidence_model_is_simulation_only_and_cannot_promote_s544() {
    let module_name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s543_r1_remediated_physical_boot_uart_retry_red";
    assert!(SIMULATION_LIB.contains(module_name));
    assert!(!KERNEL_MAIN.contains(module_name));
    assert!(SOURCE.contains("immutable physical RED"));
    assert!(SOURCE.contains("simulation-only"));
    assert!(SOURCE.contains("cannot promote S544"));
    assert!(!S543_AUTOMATIC_S544_PROMOTION);
}

  {
    id: "g8l-s543-r1-remediated-physical-boot-uart-retry-red",
    date: "2026-08-30",
    sequence: 543,
    status: "failed",
    umbrella_status: "partial",
    title: "S543 · R1 remediated fiziksel boot/UART retry — RED",
    summary:
      "S543 ikinci gerçek RPi5 boot/UART fiziksel koşusudur ve immutable RED'dir. Exact S542 candidate exact karta dört payload staged write/read-back/sync/eject ile yazıldı; Debug Probe E6647C74033F9131 /dev/cu.usbmodem21302 üzerinde exclusive 115200/8N1 + TCIFLUSH ile güçten önce pre-arm edildi ve tek yetkili power-on tüketildi. Yeni raw 20509 B / 1f1111a1a39ab6263b505b0889d025df19d5c48bb2f84e30708412b0da47dc11 / 0444 / nlink=1'dir: BOOT8H=1, S541 handoff=0, required BOOT_TO_UI_READY=0, S538 route=0, S541ERR Cpu0ReadinessTimeout=1, panic=0 ve unknown IRQ=0. Kaynak denetimi G8h'nin CPU1 PPI27'yi genel timer zincirinden önce tüketip terminalde timer'ı kapattığını, tek S541 CPU1 producer callsite'ının ise bu erken dönüşün altında kaldığını doğrular. Focused 18/18 ve selected S536–S543 8 grup / 137/137 PASS yalnız RED kaydının bütünlüğünü doğrular; fiziksel PASS değildir. Operatör power-off bildirdi, bağımsız elektrik gözlemi=0. RUNBOOK_EXECUTED_IN_S543=YES, supported-profile runtime/physical observations=1/1, Boot-to-UI=false, R1 acceptance=false, S543 rerun=false ve automatic S544 promotion=false'dur.",
    evidence: [
      "S543, S542'den ayrı simulation-only host evidence module, 18-test focused target, one-shot SD writer, sequence wrapper'lı audited UART capture engine, immutable raw, closeout log, evidence README, proof, Operations kaydı, Timeline/Yol Haritası açıklaması ve complete Code kartına sahiptir.",
      "Dar fiziksel S543 status=RED; global R1 umbrella=PARTIAL'dır. Focused yazılım sonucu PASS olsa da fiziksel karar yükseltilmez.",
      "S542 candidate image kimliği 941392 B / aa0c459b987c3f4c143b4eb14ce0ed655c2812e2a36516793e7bd8b27b60d87c SHA-256 olarak yeniden bağlandı.",
      "Hedef kart serial 0x425001fa, raw CID 009f5449534436344761425001fa01a1, size 62549655552 B ve volume UUID 44ABB50F-DB63-3DB8-A6B2-C5303E3211E9 olarak fresh doğrulandı.",
      "Debug Probe product/vendor/VID/PID ve exact serial E6647C74033F9131 yeniden doğrulandı; serial callout /dev/cu.usbmodem21302 idi.",
      "Zero-write preflight PASS verdi: WRITE=0, EJECT=0, UART_OPEN=0, POWER=0.",
      "Açık operatör yetkisi exact candidate/card/size token'ına bağlandı; one-shot retained lock aynı S543 transaction'ın tekrarını yasaklar.",
      "SD transaction dört payload'ı stage/commit etti, her birini byte-exact read-back yaptı, sync uyguladı ve /dev/disk6'yı eject etti.",
      "SD log 225 B / a2204aaec3c6657c14d8901a58ad13596c8091d32732c87a7c3c5a077db7f62c SHA-256 / 0444 / nlink=1'dir.",
      "UART wrapper 351 B / b5c50b45f9a7517cad05ed2d8af369d6cb41d7fbc7909e5963fd7fb2d15476cb SHA-256 ile audited S540 capture engine'ini exact include eder.",
      "Audited engine 20572 B / 9f001c4cec407bbb4310ca0f89d9cc7e8a1be32307ba8d7ea0541e315ff1efec SHA-256'dır.",
      "Strict capture binary 35056 B / 6c42d307b9f607e2cb5dde4173d300d0951a37f0ed82d185b81a3aa44272dfca SHA-256 ve mode 0755 üretildi.",
      "Capture aynı descriptor üzerinde TIOCEXCL, effective baud 115200, raw 8N1, no flow control, TCIFLUSH ve fresh O_EXCL raw inode sınırlarını güçten önce kurdu.",
      "Tek yetkili power-on koşusu tüketildi; capture başarı marker'ı gelmediğinde sınıflandırma sonrası helper kontrollü durduruldu ve aynı raw inode 0444 finalize edildi.",
      "Immutable raw 20509 B / 1f1111a1a39ab6263b505b0889d025df19d5c48bb2f84e30708412b0da47dc11 SHA-256 / mode 0444 / nlink 1 / inode 33802311'dir.",
      "Raw wire şekli leading NUL=3, total NUL=3 ve CR/LF=213/213 değerlerini korur.",
      "Raw exact card CID, iki ASELSANBOOT satırı, config.txt=415 B, bcm2712-rpi-5-b.dtb=78703 B ve Raspberry Pi 5 BCM2712 kimliğini taşır.",
      "Marker matrisi BOOT8H=1, BOOT_TO_UI_READY=0, S538 route=0, S541 handoff=0, S541ERR=1, Cpu0ReadinessTimeout=1 ve S538ERR=0'dır.",
      "Raw panic/PANIC=0/0, unknown IRQ=0 ve Bilinmeyen IRQ=0 kaydeder; bunların yokluğu required marker eksikliğini telafi etmez.",
      "Raw sırası BOOT8H'den sonra exact terminal ASELSAN/S541ERR Cpu0ReadinessTimeout satırını gösterir; Boot-to-UI marker'ı hiçbir konumda yoktur.",
      "exceptions.rs G8h interceptor'ını generic timer yolundan önce çağırır ve Some(...) sonucunda return eder.",
      "service_s541_readiness_handoff_on_cpu1() production çağrısı source genelinde exact bir adettir ve G8h early-return sınırından sonra generic timer yolundadır.",
      "G8h terminali CPU1 timer'ı disabled biçimde doğrular; raw FINAL_TIMER=OFF değerini ayrıca taşır.",
      "CPU0 beş saniyelik bounded Ordering::Acquire wait sonunda readiness word sıfır kaldığı için exact Cpu0ReadinessTimeout ile fail-closed park etti.",
      "Kök neden timeout süresinin kısalığı olarak değil, CPU1 producer callsite reachability hatası olarak sınırlandırılır.",
      "Operatör power-on ve power-off bildirdi; reported transition=2, independent electrical observation=0'dır.",
      "Power closeout sonrasında Mac external physical disk sayısı 0, Debug Probe exact serial ile mevcut, UART holders=0 ve raw hash/inode değişmezdi.",
      "Power closeout log 892 B / f3702d624310fe4f44f39bcced9774c92baa6d7394d5c6a4572c37f27ba780e3 SHA-256 / 0444 / nlink=1'dir.",
      "S543 focused evidence-integrity target 1 grup / 18 passed / 0 failed / 0 ignored / 0 filtered verdi.",
      "S543 focused log 1741 B / 40ca4033477ce8a0182a7221b4d0a0a2763b0b7aa19a4e7b4bdafcf8a8a5b145 SHA-256 / 0444'tür.",
      "Selected S536–S543 sekiz ayrı targetta 15+15+15+16+17+20+21+18 = 137 passed / 0 failed verdi.",
      "Selected log 14088 B / 1ace684442e47bb943aca7b7731b69ff59fcdd2150e0ebea4da959b6a8ecef42 SHA-256 / 0444'tür.",
      "S543 modelinin PASS verdict varyantı yoktur; exact observation yalnız RedCpu0ReadinessTimeout receipt'i üretir ve bütün material drift'ler fail-closed reddedilir.",
      "Tarihsel S540 raw 20525 B / fc3f934543ab5d829ad8a16e2b332dd2bdc35a81c6c0f6423256101448e45114 / 0444 / nlink 1 ve fiziksel RED olarak byte-exact korunur.",
      "S543 runbook counters: SD transaction=1, payload commits/read-backs=4/4, eject=1, UART open/capture=1/1, operator power transitions=2, new immutable physical raw=1.",
      "RUNBOOK_EXECUTED_IN_S543=YES, supported-profile runtime observations=1, physical observations=1, Boot-to-UI physically observed=false ve R1 acceptance=false'dur.",
      "S543_RERUN_FORBIDDEN=YES ve AUTOMATIC_S544_PROMOTION=NO'dur; S544 yalnız ayrı source remediation kapısı olabilir.",
      "Yeni fiziksel deneme S544 değildir; reachable producer düzeltmesi, yeni candidate freeze/pre-arm ve ayrıca yetkilendirilen yeni immutable raw sırası zorunludur.",
    ],
    commands: [
      "scripts/flash-rpi5-s543-r1-remediated-candidate.sh EXACT_AUTH S542_PACKAGE /Volumes/ASELSANBOOT /dev/disk6",
      "build scripts/capture-rpi5-s543-r1-uart.c with strict warnings; pre-arm /dev/cu.usbmodem21302 and capture one power-on",
      "cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s543_r1_remediated_physical_boot_uart_retry_red -- --test-threads=1",
      "run S536-S543 focused targets serially",
      "npm run code:generate && npm run code:check && npm test && npm run lint && npx tsc --noEmit && npm run build",
    ],
    terminalSessions: [
      {
        id: "s543-sd-write-readback-eject",
        title: "S543 exact target, SD write/read-back ve eject",
        commandLines: [
          "run zero-write exact target preflight",
          "scripts/flash-rpi5-s543-r1-remediated-candidate.sh EXACT_AUTH S542_PACKAGE /Volumes/ASELSANBOOT /dev/disk6",
        ],
        outputLines: [
          "zero-write preflight=PASS; write/eject/UART/power=0/0/0/0",
          "candidate=941392 B / aa0c459b…d87c; card=0x425001fa; probe=E6647C74033F9131",
          "exact4 stage/commit/read-back/sync/eject=PASS",
          "retained one-shot lock; rerun forbidden; UART and power not run by writer",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s543-one-power-uart-capture",
        title: "S543 tek power-on immutable UART koşusu",
        commandLines: [
          "strict-build S543 wrapper + audited capture engine",
          "pre-arm exact Debug Probe at exclusive 115200/8N1; operator power-on; capture; operator power-off",
        ],
        outputLines: [
          "capture armed before power-on: TIOCEXCL + 115200/8N1 + TCIFLUSH + O_EXCL",
          "raw=20509 B / 1f1111a1…dc11 / 0444 / nlink1 / inode33802311",
          "BOOT8H=1; S541 handoff=0; BOOT_TO_UI_READY=0; Cpu0ReadinessTimeout=1",
          "physical verdict=RED; capture success marker absent; session exit 1",
          "operator power-off reported; UART holders=0; independent electrical observation=0",
        ],
        exitCode: 1,
        outputMode: "complete",
        outputNote:
          "TAM ÇIKTI · exit 1 fiziksel RED sonucudur; evidence helper/test arızası değildir.",
      },
      {
        id: "s543-focused-and-reachability-audit",
        title: "S543 focused RED sınıflandırması ve source reachability",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s543_r1_remediated_physical_boot_uart_retry_red -- --test-threads=1",
          "run S536-S543 focused targets serially",
        ],
        outputLines: [
          "focused=1 group / 18 passed / 0 failed; verdict remains physical RED",
          "selected=8 groups / 137 passed / 0 failed",
          "source order: G8h interceptor/return < generic timer path < sole S541 producer callsite",
          "G8h final timer=OFF; increasing CPU0 wait is not accepted as remediation",
          "S540 raw and RED verdict byte-exact retained",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s543-publication",
        title: "S543 Operations/Timeline/Code publication",
        commandLines: [
          "npm run code:generate && npm run code:check",
          "npm test && npm run lint && npx tsc --noEmit && npm run build",
          "npm run deploy; cache-busted custom-domain byte-exact readback",
        ],
        outputLines: [
          "S543 physical RED and focused software PASS remain visually and semantically separate",
          "Code S543 binds the complete model, complete 18-test target and complete Operations record",
          "Timeline/Yol Haritası preserve S540 and S543 as two distinct immutable RED events",
          "website tests=815/815 PASS; lint=PASS; TypeScript exit=0/empty; static pages=681/681",
          "Code registry=S1-S543 / 543 cards / 1593 exact excerpts / missing none",
          "custom-domain deployment/read-back receipt is recorded separately after publication",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "S543 physical exit 1/RED ile focused 18/18 PASS aynı sonuç değildir: birincisi cihaz kabulünü reddeder, ikincisi bu reddin kanıt ve kaynak sınıflandırmasını doğrular.",
    limitations: [
      "S543 fiziksel kapısı RED'dir; website, focused test, build veya QEMU sonucu bunu PASS yapamaz.",
      "BOOT_TO_UI_READY ve S538 route marker'ları gerçek UART raw'da yoktur.",
      "Panic/unknown IRQ yokluğu required marker eksikliğini telafi etmez.",
      "Power geçişleri operatör beyanıdır; bağımsız elektrik ölçümü yoktur.",
      "S540 ve S543 raw dosyaları ayrı immutable RED tarihçeleridir ve yeniden yazılamaz.",
      "S544 otomatik kabul veya fiziksel retry değildir; önce reachable source remediation gerekir.",
      "Yeni fiziksel retry yeni frozen candidate, yeni açık operatör yetkisi ve yeni immutable raw ister.",
      "Boot-to-UI, scanout, input ve R1 demonstratör kabulü açık kalır.",
    ],
  },