S573 · R2 bağımsız supported-profile tekrar kampanyası talebi

//! S573 publishes the fail-closed request contract for the first independent
//! R2 supported-profile physical repeat campaign.
//!
//! The retained S571 UART PASS remains immutable and S572 remains the baseline
//! record. S573 only defines the fresh identities, byte-equality requirement,
//! observation accounting and future operator boundary for S574 candidate
//! freeze plus S575 physical execution. It cannot authorize or execute either
//! step and cannot reuse the S571 token, transaction lock or evidence tree.

#![allow(dead_code)]

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s571_r1_frozen_manifest_physical_boot_uart_run::{
    S571_AUTHORIZATION_TOKEN, S571_CANDIDATE_IMAGE_BYTES, S571_CANDIDATE_IMAGE_SHA256,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s572_r2_supported_profile_runtime_evidence_baseline::{
    S572_GATE_STATUS, S572_INDEPENDENT_PHYSICAL_REPEATS, S572_PHYSICAL_INPUT_OBSERVED,
    S572_REPEATABILITY_COMPLETE, S572_R2_FIELD_ACCEPTANCE_COMPLETE, S572_SEQUENCE,
    S572_SUPPORTED_PROFILE, S572_TARGET_ARCH, S572_EVIDENCE_TRANSPORT,
    S572_VISIBLE_SCANOUT_OBSERVED,
};

pub const S573_SEQUENCE: usize = 573;
pub const S573_EXPECTED_PREDECESSOR: usize = S572_SEQUENCE;
pub const S573_R2_TRANSITION_FIRST: usize = 572;
pub const S573_R2_TRANSITION_LAST: usize = 707;
pub const S573_R2_WORKSTREAM_ORDINAL: usize = 1;
pub const S573_ACCEPTANCE_DOMAIN: &str = "supported_profile_independent_repeat_campaign";
pub const S573_GATE_STATUS: &str = "PASS";
pub const S573_SUPPORTED_PROFILE: &str = S572_SUPPORTED_PROFILE;
pub const S573_TARGET_ARCH: &str = S572_TARGET_ARCH;
pub const S573_EVIDENCE_TRANSPORT: &str = S572_EVIDENCE_TRANSPORT;
pub const S573_BASELINE_RECORD_SEQUENCE: usize = S572_SEQUENCE;
pub const S573_BASELINE_SOURCE_OBSERVATION_SEQUENCE: usize = 571;

pub const S573_REFERENCE_CANDIDATE_BYTES: u64 = S571_CANDIDATE_IMAGE_BYTES;
pub const S573_REFERENCE_CANDIDATE_SHA256: &str = S571_CANDIDATE_IMAGE_SHA256;
pub const S573_REQUIRED_CANDIDATE_FREEZE_SEQUENCE: usize = 574;
pub const S573_REQUIRED_PHYSICAL_RUN_SEQUENCE: usize = 575;
pub const S573_CAMPAIGN_ID: &str = "r2-ws01-board-rpi5-repeat-01";
pub const S573_NEW_EVIDENCE_ROOT: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01";
pub const S573_NEW_TRANSACTION_LOCK_PATH: &str =
    "/private/tmp/aselsanos-s575-r2-repeat-01-425001fa.lock";
pub const S573_FORBIDDEN_S571_TRANSACTION_LOCK_PATH: &str =
    "/private/tmp/aselsanos-s571-r1-425001fa.lock";
pub const S573_AUTHORIZATION_TOKEN_TEMPLATE: &str =
    "S575_AUTHORIZE_FRESH_FREEZE_SD_WRITE_READBACK_EJECT_UART_PREARM_ONE_POWER_ON_{candidate_sha256}_{card_serial}_{card_bytes}_{campaign_id}";

pub const S573_FRESH_CANDIDATE_RECORD_REQUIRED: bool = true;
pub const S573_REFERENCE_PAYLOAD_BYTE_EQUAL_REQUIRED: bool = true;
pub const S573_FRESH_RUN_IDENTITY_REQUIRED: bool = true;
pub const S573_FRESH_IMMUTABLE_RAW_REQUIRED: bool = true;
pub const S573_REQUIRED_NEW_INDEPENDENT_PHYSICAL_REPEATS: usize = 1;
pub const S573_REQUIRED_TOTAL_RUNTIME_BASELINES_AFTER_CAMPAIGN: usize = 2;
pub const S573_REQUIRED_TOTAL_PHYSICAL_OBSERVATIONS_AFTER_CAMPAIGN: usize = 2;
pub const S573_REQUIRED_FUTURE_SD_WRITES: usize = 4;
pub const S573_REQUIRED_FUTURE_SD_READBACKS: usize = 4;
pub const S573_REQUIRED_FUTURE_SD_EJECTS: usize = 1;
pub const S573_REQUIRED_FUTURE_UART_OPENS: usize = 1;
pub const S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS: usize = 2;
pub const S573_REQUIRED_FUTURE_NEW_RAW_CAPTURES: usize = 1;
pub const S573_REQUIRED_FUTURE_RAW_MODE_OCTAL: &str = "0444";
pub const S573_REQUIRED_FUTURE_RAW_LINK_COUNT: usize = 1;

pub const S573_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S573_NEW_PHYSICAL_OBSERVATIONS: usize = 0;
pub const S573_NEW_INDEPENDENT_PHYSICAL_REPEATS: usize = 0;
pub const S573_PHYSICAL_OR_DEVICE_OPERATIONS: usize = 0;
pub const S573_AUTHORIZATION_RECEIVED: bool = false;
pub const S573_CANDIDATE_FREEZE_EXECUTED: bool = false;
pub const S573_PHYSICAL_RUN_EXECUTED: bool = false;
pub const S573_REPEATABILITY_COMPLETE: bool = false;
pub const S573_CROSS_PROFILE_COVERAGE_COMPLETE: bool = false;
pub const S573_R2_FIELD_ACCEPTANCE_COMPLETE: bool = false;
pub const S573_AUTOMATIC_PROMOTION: bool = false;
pub const RUNBOOK_EXECUTED_IN_S573: bool = false;

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

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS573RepeatCampaignRequest<'a> {
    pub predecessor_sequence: usize,
    pub predecessor_passed: bool,
    pub baseline_record_sequence: usize,
    pub baseline_status: &'a str,
    pub profile: &'a str,
    pub target_arch: &'a str,
    pub transport: &'a str,
    pub reference_candidate: G8lS573ArtifactIdentity,
    pub candidate_freeze_sequence: usize,
    pub physical_run_sequence: usize,
    pub campaign_id: &'a str,
    pub evidence_root: &'a str,
    pub transaction_lock_path: &'a str,
    pub authorization_token: Option<&'a str>,
    pub fresh_candidate_record_required: bool,
    pub reference_payload_byte_equal_required: bool,
    pub fresh_run_identity_required: bool,
    pub fresh_immutable_raw_required: bool,
    pub reuse_s571_transaction_lock: bool,
    pub rewrite_s571_evidence: bool,
    pub required_new_independent_physical_repeats: usize,
    pub required_total_runtime_baselines_after_campaign: usize,
    pub required_total_physical_observations_after_campaign: usize,
    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_operator_power_transitions: usize,
    pub required_future_new_raw_captures: usize,
    pub required_future_raw_mode_octal: &'a str,
    pub required_future_raw_link_count: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub physical_or_device_operations: usize,
    pub repeatability_complete: bool,
    pub r2_field_acceptance_complete: bool,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS573RepeatCampaignReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub status: &'static str,
    pub acceptance_domain: &'static str,
    pub baseline_record_sequence: usize,
    pub baseline_source_observation_sequence: usize,
    pub profile: &'static str,
    pub target_arch: &'static str,
    pub transport: &'static str,
    pub reference_candidate: G8lS573ArtifactIdentity,
    pub candidate_freeze_sequence: usize,
    pub physical_run_sequence: usize,
    pub campaign_id: &'static str,
    pub evidence_root: &'static str,
    pub transaction_lock_path: &'static str,
    pub authorization_token_template: &'static str,
    pub authorization_received: bool,
    pub s571_history_retained: bool,
    pub s571_lock_reuse_forbidden: bool,
    pub reference_payload_byte_equal_required: bool,
    pub required_new_independent_physical_repeats: usize,
    pub required_total_runtime_baselines_after_campaign: usize,
    pub required_total_physical_observations_after_campaign: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub physical_or_device_operations: usize,
    pub candidate_freeze_executed: bool,
    pub physical_run_executed: bool,
    pub repeatability_complete: bool,
    pub cross_profile_coverage_complete: bool,
    pub visible_scanout_observed: bool,
    pub physical_input_observed: bool,
    pub r2_field_acceptance_complete: bool,
    pub automatic_promotion: bool,
    pub runbook_executed: bool,
}

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

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

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

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS573RepeatCampaignOutcome {
    RequestPublished(G8lS573RepeatCampaignReceipt),
    RequestRetained(G8lS573RepeatCampaignReceipt),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS573RepeatCampaignError {
    PredecessorRejected,
    BaselineRejected,
    ProfileDrift,
    ReferenceIdentityDrift,
    SequencePlanDrift,
    CampaignIdentityDrift,
    EvidenceNamespaceDrift,
    LegacyAuthorizationReuseRejected,
    PrematureAuthorizationRejected,
    LegacyLockReuseRejected,
    HistoryRewriteRejected,
    RequirementDrift,
    CurrentObservationOverclaim,
    BoundaryOverclaim,
    PublishedStateDrift,
}

impl G8lS573RepeatCampaignError {
    pub const fn diagnostic_code(self) -> u64 {
        match self {
            Self::PredecessorRejected => 0x5731_01,
            Self::BaselineRejected => 0x5731_02,
            Self::ProfileDrift => 0x5731_03,
            Self::ReferenceIdentityDrift => 0x5731_04,
            Self::SequencePlanDrift => 0x5731_05,
            Self::CampaignIdentityDrift => 0x5731_06,
            Self::EvidenceNamespaceDrift => 0x5731_07,
            Self::LegacyAuthorizationReuseRejected => 0x5731_08,
            Self::PrematureAuthorizationRejected => 0x5731_09,
            Self::LegacyLockReuseRejected => 0x5731_0a,
            Self::HistoryRewriteRejected => 0x5731_0b,
            Self::RequirementDrift => 0x5731_0c,
            Self::CurrentObservationOverclaim => 0x5731_0d,
            Self::BoundaryOverclaim => 0x5731_0e,
            Self::PublishedStateDrift => 0x5731_0f,
        }
    }
}

pub fn service_s573_model_supported_profile_repeat_campaign_request_contract(
    state: &mut G8lS573RepeatCampaignState,
    request: G8lS573RepeatCampaignRequest<'_>,
) -> Result<G8lS573RepeatCampaignOutcome, G8lS573RepeatCampaignError> {
    if request.predecessor_sequence != S573_EXPECTED_PREDECESSOR || !request.predecessor_passed {
        return Err(G8lS573RepeatCampaignError::PredecessorRejected);
    }
    if request.baseline_record_sequence != S573_BASELINE_RECORD_SEQUENCE
        || request.baseline_status != S572_GATE_STATUS
    {
        return Err(G8lS573RepeatCampaignError::BaselineRejected);
    }
    if request.profile != S573_SUPPORTED_PROFILE
        || request.target_arch != S573_TARGET_ARCH
        || request.transport != S573_EVIDENCE_TRANSPORT
    {
        return Err(G8lS573RepeatCampaignError::ProfileDrift);
    }
    if request.reference_candidate
        != s573_identity(
            S573_REFERENCE_CANDIDATE_BYTES,
            S573_REFERENCE_CANDIDATE_SHA256,
        )
    {
        return Err(G8lS573RepeatCampaignError::ReferenceIdentityDrift);
    }
    if request.candidate_freeze_sequence != S573_REQUIRED_CANDIDATE_FREEZE_SEQUENCE
        || request.physical_run_sequence != S573_REQUIRED_PHYSICAL_RUN_SEQUENCE
        || request.candidate_freeze_sequence <= S573_SEQUENCE
        || request.physical_run_sequence <= request.candidate_freeze_sequence
    {
        return Err(G8lS573RepeatCampaignError::SequencePlanDrift);
    }
    if request.campaign_id != S573_CAMPAIGN_ID {
        return Err(G8lS573RepeatCampaignError::CampaignIdentityDrift);
    }
    if request.evidence_root != S573_NEW_EVIDENCE_ROOT {
        return Err(G8lS573RepeatCampaignError::EvidenceNamespaceDrift);
    }
    if request.authorization_token == Some(S571_AUTHORIZATION_TOKEN) {
        return Err(G8lS573RepeatCampaignError::LegacyAuthorizationReuseRejected);
    }
    if request.authorization_token.is_some() || S573_AUTHORIZATION_RECEIVED {
        return Err(G8lS573RepeatCampaignError::PrematureAuthorizationRejected);
    }
    if request.reuse_s571_transaction_lock
        || request.transaction_lock_path == S573_FORBIDDEN_S571_TRANSACTION_LOCK_PATH
        || request.transaction_lock_path != S573_NEW_TRANSACTION_LOCK_PATH
    {
        return Err(G8lS573RepeatCampaignError::LegacyLockReuseRejected);
    }
    if request.rewrite_s571_evidence {
        return Err(G8lS573RepeatCampaignError::HistoryRewriteRejected);
    }
    if request.fresh_candidate_record_required != S573_FRESH_CANDIDATE_RECORD_REQUIRED
        || request.reference_payload_byte_equal_required
            != S573_REFERENCE_PAYLOAD_BYTE_EQUAL_REQUIRED
        || request.fresh_run_identity_required != S573_FRESH_RUN_IDENTITY_REQUIRED
        || request.fresh_immutable_raw_required != S573_FRESH_IMMUTABLE_RAW_REQUIRED
        || request.required_new_independent_physical_repeats
            != S573_REQUIRED_NEW_INDEPENDENT_PHYSICAL_REPEATS
        || request.required_total_runtime_baselines_after_campaign
            != S573_REQUIRED_TOTAL_RUNTIME_BASELINES_AFTER_CAMPAIGN
        || request.required_total_physical_observations_after_campaign
            != S573_REQUIRED_TOTAL_PHYSICAL_OBSERVATIONS_AFTER_CAMPAIGN
        || request.required_future_sd_writes != S573_REQUIRED_FUTURE_SD_WRITES
        || request.required_future_sd_readbacks != S573_REQUIRED_FUTURE_SD_READBACKS
        || request.required_future_sd_ejects != S573_REQUIRED_FUTURE_SD_EJECTS
        || request.required_future_uart_opens != S573_REQUIRED_FUTURE_UART_OPENS
        || request.required_future_operator_power_transitions
            != S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS
        || request.required_future_new_raw_captures != S573_REQUIRED_FUTURE_NEW_RAW_CAPTURES
        || request.required_future_raw_mode_octal != S573_REQUIRED_FUTURE_RAW_MODE_OCTAL
        || request.required_future_raw_link_count != S573_REQUIRED_FUTURE_RAW_LINK_COUNT
    {
        return Err(G8lS573RepeatCampaignError::RequirementDrift);
    }
    if request.new_runtime_observations != S573_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS
        || request.new_physical_observations != S573_NEW_PHYSICAL_OBSERVATIONS
        || request.new_independent_physical_repeats != S573_NEW_INDEPENDENT_PHYSICAL_REPEATS
        || request.physical_or_device_operations != S573_PHYSICAL_OR_DEVICE_OPERATIONS
    {
        return Err(G8lS573RepeatCampaignError::CurrentObservationOverclaim);
    }
    if request.repeatability_complete != S573_REPEATABILITY_COMPLETE
        || request.r2_field_acceptance_complete != S573_R2_FIELD_ACCEPTANCE_COMPLETE
        || request.runbook_executed != RUNBOOK_EXECUTED_IN_S573
        || S572_INDEPENDENT_PHYSICAL_REPEATS != 0
        || S572_REPEATABILITY_COMPLETE
        || S572_R2_FIELD_ACCEPTANCE_COMPLETE
    {
        return Err(G8lS573RepeatCampaignError::BoundaryOverclaim);
    }

    let receipt = G8lS573RepeatCampaignReceipt {
        sequence: S573_SEQUENCE,
        predecessor_sequence: request.predecessor_sequence,
        status: S573_GATE_STATUS,
        acceptance_domain: S573_ACCEPTANCE_DOMAIN,
        baseline_record_sequence: request.baseline_record_sequence,
        baseline_source_observation_sequence: S573_BASELINE_SOURCE_OBSERVATION_SEQUENCE,
        profile: S573_SUPPORTED_PROFILE,
        target_arch: S573_TARGET_ARCH,
        transport: S573_EVIDENCE_TRANSPORT,
        reference_candidate: request.reference_candidate,
        candidate_freeze_sequence: request.candidate_freeze_sequence,
        physical_run_sequence: request.physical_run_sequence,
        campaign_id: S573_CAMPAIGN_ID,
        evidence_root: S573_NEW_EVIDENCE_ROOT,
        transaction_lock_path: S573_NEW_TRANSACTION_LOCK_PATH,
        authorization_token_template: S573_AUTHORIZATION_TOKEN_TEMPLATE,
        authorization_received: S573_AUTHORIZATION_RECEIVED,
        s571_history_retained: true,
        s571_lock_reuse_forbidden: true,
        reference_payload_byte_equal_required: request.reference_payload_byte_equal_required,
        required_new_independent_physical_repeats: request
            .required_new_independent_physical_repeats,
        required_total_runtime_baselines_after_campaign: request
            .required_total_runtime_baselines_after_campaign,
        required_total_physical_observations_after_campaign: request
            .required_total_physical_observations_after_campaign,
        new_runtime_observations: request.new_runtime_observations,
        new_physical_observations: request.new_physical_observations,
        new_independent_physical_repeats: request.new_independent_physical_repeats,
        physical_or_device_operations: request.physical_or_device_operations,
        candidate_freeze_executed: S573_CANDIDATE_FREEZE_EXECUTED,
        physical_run_executed: S573_PHYSICAL_RUN_EXECUTED,
        repeatability_complete: request.repeatability_complete,
        cross_profile_coverage_complete: S573_CROSS_PROFILE_COVERAGE_COMPLETE,
        visible_scanout_observed: S572_VISIBLE_SCANOUT_OBSERVED,
        physical_input_observed: S572_PHYSICAL_INPUT_OBSERVED,
        r2_field_acceptance_complete: request.r2_field_acceptance_complete,
        automatic_promotion: S573_AUTOMATIC_PROMOTION,
        runbook_executed: request.runbook_executed,
    };

    match state.receipt {
        None => {
            state.receipt = Some(receipt);
            Ok(G8lS573RepeatCampaignOutcome::RequestPublished(receipt))
        }
        Some(existing) if existing == receipt => {
            Ok(G8lS573RepeatCampaignOutcome::RequestRetained(existing))
        }
        Some(_) => Err(G8lS573RepeatCampaignError::PublishedStateDrift),
    }
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s571_r1_frozen_manifest_physical_boot_uart_run::S571_AUTHORIZATION_TOKEN;
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract::*;
use sha2::{Digest, Sha256};
use std::collections::HashSet;

const SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract.rs"
);
const MAIN: &str = include_str!("../../kernel/src/main.rs");
const SIMULATION_LIB: &str = include_str!("../src/lib.rs");
const S571_README: &str =
    include_str!("../../evidence/rpi5/r1/sequence-571-physical-boot-uart/README.md");
const S572_PROOF: &str = include_str!(
    "../../docs/M8.1-RPi5-G8l-S572-R2-Supported-Profile-Runtime-Evidence-Baseline-Proof.md"
);
const REFERENCE_IMAGE: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-570-candidate-freeze/package/aselsanos-rpi5.img"
);

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

fn request() -> G8lS573RepeatCampaignRequest<'static> {
    G8lS573RepeatCampaignRequest {
        predecessor_sequence: S573_EXPECTED_PREDECESSOR,
        predecessor_passed: true,
        baseline_record_sequence: S573_BASELINE_RECORD_SEQUENCE,
        baseline_status: "PASS",
        profile: S573_SUPPORTED_PROFILE,
        target_arch: S573_TARGET_ARCH,
        transport: S573_EVIDENCE_TRANSPORT,
        reference_candidate: s573_identity(
            S573_REFERENCE_CANDIDATE_BYTES,
            S573_REFERENCE_CANDIDATE_SHA256,
        ),
        candidate_freeze_sequence: S573_REQUIRED_CANDIDATE_FREEZE_SEQUENCE,
        physical_run_sequence: S573_REQUIRED_PHYSICAL_RUN_SEQUENCE,
        campaign_id: S573_CAMPAIGN_ID,
        evidence_root: S573_NEW_EVIDENCE_ROOT,
        transaction_lock_path: S573_NEW_TRANSACTION_LOCK_PATH,
        authorization_token: None,
        fresh_candidate_record_required: S573_FRESH_CANDIDATE_RECORD_REQUIRED,
        reference_payload_byte_equal_required: S573_REFERENCE_PAYLOAD_BYTE_EQUAL_REQUIRED,
        fresh_run_identity_required: S573_FRESH_RUN_IDENTITY_REQUIRED,
        fresh_immutable_raw_required: S573_FRESH_IMMUTABLE_RAW_REQUIRED,
        reuse_s571_transaction_lock: false,
        rewrite_s571_evidence: false,
        required_new_independent_physical_repeats: S573_REQUIRED_NEW_INDEPENDENT_PHYSICAL_REPEATS,
        required_total_runtime_baselines_after_campaign:
            S573_REQUIRED_TOTAL_RUNTIME_BASELINES_AFTER_CAMPAIGN,
        required_total_physical_observations_after_campaign:
            S573_REQUIRED_TOTAL_PHYSICAL_OBSERVATIONS_AFTER_CAMPAIGN,
        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_operator_power_transitions: S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS,
        required_future_new_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,
        new_runtime_observations: S573_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS,
        new_physical_observations: S573_NEW_PHYSICAL_OBSERVATIONS,
        new_independent_physical_repeats: S573_NEW_INDEPENDENT_PHYSICAL_REPEATS,
        physical_or_device_operations: S573_PHYSICAL_OR_DEVICE_OPERATIONS,
        repeatability_complete: S573_REPEATABILITY_COMPLETE,
        r2_field_acceptance_complete: S573_R2_FIELD_ACCEPTANCE_COMPLETE,
        runbook_executed: RUNBOOK_EXECUTED_IN_S573,
    }
}

#[test]
fn sequence_profile_and_r2_workstream_are_exact() {
    assert_eq!(S573_SEQUENCE, 573);
    assert_eq!(S573_EXPECTED_PREDECESSOR, 572);
    assert_eq!(S573_R2_TRANSITION_FIRST, 572);
    assert_eq!(S573_R2_TRANSITION_LAST, 707);
    assert_eq!(S573_R2_WORKSTREAM_ORDINAL, 1);
    assert_eq!(
        S573_ACCEPTANCE_DOMAIN,
        "supported_profile_independent_repeat_campaign"
    );
    assert_eq!(S573_GATE_STATUS, "PASS");
    assert_eq!(S573_SUPPORTED_PROFILE, "board-rpi5");
    assert_eq!(S573_TARGET_ARCH, "aarch64");
    assert_eq!(S573_EVIDENCE_TRANSPORT, "uart-115200-8n1");
}

#[test]
fn future_freeze_and_physical_run_have_fresh_separate_identities() {
    assert_eq!(S573_REQUIRED_CANDIDATE_FREEZE_SEQUENCE, 574);
    assert_eq!(S573_REQUIRED_PHYSICAL_RUN_SEQUENCE, 575);
    assert_eq!(S573_CAMPAIGN_ID, "r2-ws01-board-rpi5-repeat-01");
    assert!(S573_NEW_EVIDENCE_ROOT.starts_with("evidence/rpi5/r2/"));
    assert_ne!(
        S573_NEW_TRANSACTION_LOCK_PATH,
        S573_FORBIDDEN_S571_TRANSACTION_LOCK_PATH
    );
    assert_ne!(S573_AUTHORIZATION_TOKEN_TEMPLATE, S571_AUTHORIZATION_TOKEN);
    assert!(S573_AUTHORIZATION_TOKEN_TEMPLATE.contains("{candidate_sha256}"));
    assert!(S573_AUTHORIZATION_TOKEN_TEMPLATE.contains("{campaign_id}"));
}

#[test]
fn contract_requires_byte_equal_payload_but_a_fresh_freeze_record() {
    assert!(S573_FRESH_CANDIDATE_RECORD_REQUIRED);
    assert!(S573_REFERENCE_PAYLOAD_BYTE_EQUAL_REQUIRED);
    assert!(S573_FRESH_RUN_IDENTITY_REQUIRED);
    assert!(S573_FRESH_IMMUTABLE_RAW_REQUIRED);
    assert_eq!(S573_REFERENCE_CANDIDATE_BYTES, 945_920);
    assert_eq!(
        S573_REFERENCE_CANDIDATE_SHA256,
        "a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04"
    );
}

#[test]
fn requested_future_operations_are_not_s573_observations() {
    assert_eq!(S573_REQUIRED_NEW_INDEPENDENT_PHYSICAL_REPEATS, 1);
    assert_eq!(S573_REQUIRED_TOTAL_RUNTIME_BASELINES_AFTER_CAMPAIGN, 2);
    assert_eq!(S573_REQUIRED_TOTAL_PHYSICAL_OBSERVATIONS_AFTER_CAMPAIGN, 2);
    assert_eq!(S573_REQUIRED_FUTURE_SD_WRITES, 4);
    assert_eq!(S573_REQUIRED_FUTURE_SD_READBACKS, 4);
    assert_eq!(S573_REQUIRED_FUTURE_SD_EJECTS, 1);
    assert_eq!(S573_REQUIRED_FUTURE_UART_OPENS, 1);
    assert_eq!(S573_REQUIRED_FUTURE_OPERATOR_POWER_TRANSITIONS, 2);
    assert_eq!(S573_REQUIRED_FUTURE_NEW_RAW_CAPTURES, 1);
    assert_eq!(S573_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert_eq!(S573_NEW_PHYSICAL_OBSERVATIONS, 0);
    assert_eq!(S573_NEW_INDEPENDENT_PHYSICAL_REPEATS, 0);
    assert_eq!(S573_PHYSICAL_OR_DEVICE_OPERATIONS, 0);
    assert!(!S573_AUTHORIZATION_RECEIVED);
    assert!(!S573_CANDIDATE_FREEZE_EXECUTED);
    assert!(!S573_PHYSICAL_RUN_EXECUTED);
    assert!(!RUNBOOK_EXECUTED_IN_S573);
}

#[test]
fn product_boundaries_remain_open() {
    assert!(!S573_REPEATABILITY_COMPLETE);
    assert!(!S573_CROSS_PROFILE_COVERAGE_COMPLETE);
    assert!(!S573_R2_FIELD_ACCEPTANCE_COMPLETE);
    assert!(!S573_AUTOMATIC_PROMOTION);
}

#[test]
fn host_contract_is_simulation_only_and_has_no_device_authority() {
    let module = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract";
    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",
        "TIOCEXCL",
        "tcsetattr",
        "File::create",
        "OpenOptions",
    ] {
        assert!(
            !SOURCE.contains(forbidden),
            "forbidden surface: {forbidden}"
        );
    }
}

#[test]
fn diagnostic_codes_are_unique_and_nonzero() {
    let errors = [
        G8lS573RepeatCampaignError::PredecessorRejected,
        G8lS573RepeatCampaignError::BaselineRejected,
        G8lS573RepeatCampaignError::ProfileDrift,
        G8lS573RepeatCampaignError::ReferenceIdentityDrift,
        G8lS573RepeatCampaignError::SequencePlanDrift,
        G8lS573RepeatCampaignError::CampaignIdentityDrift,
        G8lS573RepeatCampaignError::EvidenceNamespaceDrift,
        G8lS573RepeatCampaignError::LegacyAuthorizationReuseRejected,
        G8lS573RepeatCampaignError::PrematureAuthorizationRejected,
        G8lS573RepeatCampaignError::LegacyLockReuseRejected,
        G8lS573RepeatCampaignError::HistoryRewriteRejected,
        G8lS573RepeatCampaignError::RequirementDrift,
        G8lS573RepeatCampaignError::CurrentObservationOverclaim,
        G8lS573RepeatCampaignError::BoundaryOverclaim,
        G8lS573RepeatCampaignError::PublishedStateDrift,
    ];
    let mut unique = HashSet::new();
    for code in errors
        .into_iter()
        .map(G8lS573RepeatCampaignError::diagnostic_code)
    {
        assert_ne!(code, 0);
        assert!(unique.insert(code));
    }
    assert_eq!(unique.len(), 15);
}

#[test]
fn exact_request_publishes_the_fresh_campaign_contract() {
    let mut state = G8lS573RepeatCampaignState::new();
    let G8lS573RepeatCampaignOutcome::RequestPublished(receipt) =
        service_s573_model_supported_profile_repeat_campaign_request_contract(
            &mut state,
            request(),
        )
        .unwrap()
    else {
        panic!("first exact request must publish")
    };
    assert_eq!(receipt.sequence, 573);
    assert_eq!(receipt.predecessor_sequence, 572);
    assert_eq!(receipt.baseline_record_sequence, 572);
    assert_eq!(receipt.baseline_source_observation_sequence, 571);
    assert_eq!(receipt.profile, "board-rpi5");
    assert_eq!(receipt.candidate_freeze_sequence, 574);
    assert_eq!(receipt.physical_run_sequence, 575);
    assert_eq!(receipt.campaign_id, S573_CAMPAIGN_ID);
    assert_eq!(receipt.evidence_root, S573_NEW_EVIDENCE_ROOT);
    assert_eq!(
        receipt.transaction_lock_path,
        S573_NEW_TRANSACTION_LOCK_PATH
    );
    assert!(!receipt.authorization_received);
    assert!(receipt.s571_history_retained);
    assert!(receipt.s571_lock_reuse_forbidden);
    assert!(receipt.reference_payload_byte_equal_required);
    assert_eq!(receipt.required_new_independent_physical_repeats, 1);
    assert_eq!(receipt.required_total_runtime_baselines_after_campaign, 2);
    assert_eq!(
        receipt.required_total_physical_observations_after_campaign,
        2
    );
    assert_eq!(receipt.new_runtime_observations, 0);
    assert_eq!(receipt.new_physical_observations, 0);
    assert_eq!(receipt.new_independent_physical_repeats, 0);
    assert_eq!(receipt.physical_or_device_operations, 0);
    assert!(!receipt.candidate_freeze_executed);
    assert!(!receipt.physical_run_executed);
    assert!(!receipt.repeatability_complete);
    assert!(!receipt.cross_profile_coverage_complete);
    assert!(!receipt.visible_scanout_observed);
    assert!(!receipt.physical_input_observed);
    assert!(!receipt.r2_field_acceptance_complete);
    assert!(!receipt.automatic_promotion);
    assert!(!receipt.runbook_executed);
    assert_eq!(state.receipt(), Some(receipt));
}

#[test]
fn exact_replay_is_idempotent_and_does_not_issue_authorization() {
    let mut state = G8lS573RepeatCampaignState::new();
    let G8lS573RepeatCampaignOutcome::RequestPublished(receipt) =
        service_s573_model_supported_profile_repeat_campaign_request_contract(
            &mut state,
            request(),
        )
        .unwrap()
    else {
        panic!("first request")
    };
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(
            &mut state,
            request(),
        ),
        Ok(G8lS573RepeatCampaignOutcome::RequestRetained(receipt))
    );
    assert!(!receipt.authorization_received);
    assert_eq!(receipt.new_independent_physical_repeats, 0);
}

#[test]
fn predecessor_and_baseline_drift_fail_closed() {
    for case in 0..4 {
        let mut observed = request();
        let expected = match case {
            0 => {
                observed.predecessor_sequence = 571;
                G8lS573RepeatCampaignError::PredecessorRejected
            }
            1 => {
                observed.predecessor_passed = false;
                G8lS573RepeatCampaignError::PredecessorRejected
            }
            2 => {
                observed.baseline_record_sequence = 571;
                G8lS573RepeatCampaignError::BaselineRejected
            }
            3 => {
                observed.baseline_status = "RED";
                G8lS573RepeatCampaignError::BaselineRejected
            }
            _ => unreachable!(),
        };
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(expected)
        );
        assert_eq!(state.receipt(), None);
    }
}

#[test]
fn profile_and_reference_identity_drift_fail_closed() {
    for case in 0..5 {
        let mut observed = request();
        let expected = match case {
            0 => {
                observed.profile = "board-qemu";
                G8lS573RepeatCampaignError::ProfileDrift
            }
            1 => {
                observed.target_arch = "x86_64";
                G8lS573RepeatCampaignError::ProfileDrift
            }
            2 => {
                observed.transport = "synthetic-host-log";
                G8lS573RepeatCampaignError::ProfileDrift
            }
            3 => {
                observed.reference_candidate.bytes += 1;
                G8lS573RepeatCampaignError::ReferenceIdentityDrift
            }
            4 => {
                observed.reference_candidate.sha256 = "00";
                G8lS573RepeatCampaignError::ReferenceIdentityDrift
            }
            _ => unreachable!(),
        };
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(expected)
        );
    }
}

#[test]
fn freeze_and_run_sequence_drift_fail_closed() {
    for case in 0..4 {
        let mut observed = request();
        match case {
            0 => observed.candidate_freeze_sequence = 573,
            1 => observed.candidate_freeze_sequence = 575,
            2 => observed.physical_run_sequence = 574,
            3 => observed.physical_run_sequence = 576,
            _ => unreachable!(),
        }
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(G8lS573RepeatCampaignError::SequencePlanDrift)
        );
    }
}

#[test]
fn campaign_and_evidence_namespace_drift_fail_closed() {
    let mut campaign = request();
    campaign.campaign_id = "r2-ws01-board-rpi5-repeat-00";
    let mut state = G8lS573RepeatCampaignState::new();
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(&mut state, campaign,),
        Err(G8lS573RepeatCampaignError::CampaignIdentityDrift)
    );

    let mut evidence = request();
    evidence.evidence_root = "evidence/rpi5/r1/sequence-571-physical-boot-uart";
    let mut state = G8lS573RepeatCampaignState::new();
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(&mut state, evidence,),
        Err(G8lS573RepeatCampaignError::EvidenceNamespaceDrift)
    );
}

#[test]
fn s571_authorization_token_reuse_is_explicitly_rejected() {
    let mut observed = request();
    observed.authorization_token = Some(S571_AUTHORIZATION_TOKEN);
    let mut state = G8lS573RepeatCampaignState::new();
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(&mut state, observed,),
        Err(G8lS573RepeatCampaignError::LegacyAuthorizationReuseRejected)
    );
}

#[test]
fn any_new_authorization_is_premature_in_s573() {
    let mut observed = request();
    observed.authorization_token = Some("S575_NOT_YET_AUTHORIZED");
    let mut state = G8lS573RepeatCampaignState::new();
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(&mut state, observed,),
        Err(G8lS573RepeatCampaignError::PrematureAuthorizationRejected)
    );
}

#[test]
fn s571_lock_reuse_and_lock_path_drift_fail_closed() {
    for case in 0..3 {
        let mut observed = request();
        match case {
            0 => observed.reuse_s571_transaction_lock = true,
            1 => observed.transaction_lock_path = S573_FORBIDDEN_S571_TRANSACTION_LOCK_PATH,
            2 => observed.transaction_lock_path = "/private/tmp/aselsanos-r2-shared.lock",
            _ => unreachable!(),
        }
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(G8lS573RepeatCampaignError::LegacyLockReuseRejected)
        );
    }
}

#[test]
fn immutable_s571_history_rewrite_is_rejected() {
    let mut observed = request();
    observed.rewrite_s571_evidence = true;
    let mut state = G8lS573RepeatCampaignState::new();
    assert_eq!(
        service_s573_model_supported_profile_repeat_campaign_request_contract(&mut state, observed,),
        Err(G8lS573RepeatCampaignError::HistoryRewriteRejected)
    );
}

#[test]
fn repeat_and_future_operation_requirement_drift_fail_closed() {
    for case in 0..13 {
        let mut observed = request();
        match case {
            0 => observed.fresh_candidate_record_required = false,
            1 => observed.reference_payload_byte_equal_required = false,
            2 => observed.fresh_run_identity_required = false,
            3 => observed.fresh_immutable_raw_required = false,
            4 => observed.required_new_independent_physical_repeats = 0,
            5 => observed.required_total_runtime_baselines_after_campaign = 1,
            6 => observed.required_total_physical_observations_after_campaign = 1,
            7 => observed.required_future_sd_writes = 3,
            8 => observed.required_future_sd_readbacks = 3,
            9 => observed.required_future_sd_ejects = 0,
            10 => observed.required_future_uart_opens = 0,
            11 => observed.required_future_operator_power_transitions = 1,
            12 => observed.required_future_new_raw_captures = 0,
            _ => unreachable!(),
        }
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(G8lS573RepeatCampaignError::RequirementDrift)
        );
    }
    for case in 0..2 {
        let mut observed = request();
        match case {
            0 => observed.required_future_raw_mode_octal = "0644",
            1 => observed.required_future_raw_link_count = 2,
            _ => unreachable!(),
        }
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(G8lS573RepeatCampaignError::RequirementDrift)
        );
    }
}

#[test]
fn current_observation_and_acceptance_overclaims_fail_closed() {
    for case in 0..7 {
        let mut observed = request();
        let expected = match case {
            0 => {
                observed.new_runtime_observations = 1;
                G8lS573RepeatCampaignError::CurrentObservationOverclaim
            }
            1 => {
                observed.new_physical_observations = 1;
                G8lS573RepeatCampaignError::CurrentObservationOverclaim
            }
            2 => {
                observed.new_independent_physical_repeats = 1;
                G8lS573RepeatCampaignError::CurrentObservationOverclaim
            }
            3 => {
                observed.physical_or_device_operations = 1;
                G8lS573RepeatCampaignError::CurrentObservationOverclaim
            }
            4 => {
                observed.repeatability_complete = true;
                G8lS573RepeatCampaignError::BoundaryOverclaim
            }
            5 => {
                observed.r2_field_acceptance_complete = true;
                G8lS573RepeatCampaignError::BoundaryOverclaim
            }
            6 => {
                observed.runbook_executed = true;
                G8lS573RepeatCampaignError::BoundaryOverclaim
            }
            _ => unreachable!(),
        };
        let mut state = G8lS573RepeatCampaignState::new();
        assert_eq!(
            service_s573_model_supported_profile_repeat_campaign_request_contract(
                &mut state, observed,
            ),
            Err(expected)
        );
    }
}

#[test]
fn reference_candidate_bytes_and_sha_are_real() {
    assert_eq!(REFERENCE_IMAGE.len() as u64, S573_REFERENCE_CANDIDATE_BYTES);
    assert_eq!(sha256(REFERENCE_IMAGE), S573_REFERENCE_CANDIDATE_SHA256);
}

#[test]
fn predecessor_proof_and_s571_archive_pin_the_required_boundary() {
    assert!(S572_PROOF.contains("S573 should publish the fail-closed request"));
    assert!(S572_PROOF.contains("new,"));
    assert!(S572_PROOF.contains("separately authorized supported-profile repeat campaign"));
    assert!(S571_README.contains("RERUN_FORBIDDEN=YES"));
    assert!(S571_README.contains("S571 one-shot transaction must not be rerun"));
    assert!(S571_README.contains("retained lock is part"));
}

  {
    id: "g8l-s573-r2-supported-profile-repeat-campaign-request-contract",
    date: "2026-08-31",
    sequence: 573,
    status: "passed",
    umbrella_status: "partial",
    title: "S573 · R2 bağımsız supported-profile tekrar kampanyası talebi",
    summary:
      "S573 dar kaynak/sözleşme kapısı PASS'tir. İlk bağımsız R2 board-rpi5 tekrar kampanyası fail-closed tanımlandı: S574 yeni freeze kaydı üretirken payload exact S570/S571 referans imajıyla byte-eş kalacak; S575 ise yeni kampanya/evidence/lock/raw kimliği ve o anda verilecek ayrı operatör yetkisi olmadan çalışamayacak. S571 one-shot token'ı, retained lock'ı ve evidence ağacı yeniden kullanılamaz. S573 hiçbir SD/UART/güç işlemi veya yeni runtime/fiziksel gözlem yapmadı; repeatability ve R2 saha kabulü false kalır.",
    evidence: [
      "S573 R1→R2 geçişinin 1. iş alanındaki ikinci kapıdır: acceptance domain=supported_profile_independent_repeat_campaign, profile=board-rpi5, arch=aarch64 ve transport=uart-115200-8n1.",
      "Predecessor S572 PASS ve kaynak fiziksel gözlem S571 PASS'tir; S571 immutable archive ve RERUN_FORBIDDEN=YES sınırı korunur.",
      "Referans payload 945920 B / a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04 olarak byte-eş kalmak zorundadır; buna rağmen S574 ayrı ve yeni bir freeze kaydı üretmelidir.",
      "Kampanya id=r2-ws01-board-rpi5-repeat-01; freeze/run planı S574/S575 ve yeni evidence root evidence/rpi5/r2/sequence-575-supported-profile-repeat-01'dir.",
      "Yeni lock /private/tmp/aselsanos-s575-r2-repeat-01-425001fa.lock'tır; eski /private/tmp/aselsanos-s571-r1-425001fa.lock açıkça reddedilir.",
      "S571 concrete authorization token'ı reddedilir. S573 yalnız placeholder içeren non-executable S575 token template'i yayımlar; authorization_received=false'dur.",
      "Gelecek S575 kabulü 4 write + 4 byte-eş read-back + 1 eject + 1 UART open/pre-arm + 2 operator-reported power transition + 1 fresh raw gerektirir; future raw mode 0444 ve nlink=1 olmalıdır.",
      "Kampanya sonunda hedef yeni bağımsız fiziksel tekrar=1 ve toplam supported-profile runtime/physical observation=2/2'dir; bunlar S573 sonucu değildir.",
      "S573 current new runtime/physical/repeat=0/0/0; physical/device operations=0, candidate freeze/physical run=false/false ve RUNBOOK_EXECUTED_IN_S573=NO'dur.",
      "Focused test 1 grup / 21 passed / 0 failed / 0 ignored / 0 filtered verdi.",
      "Ayrı board-rpi5 compile kontrolü CARGO_INCREMENTAL=0, aarch64-unknown-none, --no-default-features --features board-rpi5 ile exit 0 verdi; 4496 warning başlığı kaydedildi ve zero-warning iddiası yoktur. S573 modülü simulation-only olduğundan bu kernel check runtime invocation değildir.",
      "Implementation 17775 B / 391b6b6ca2b3b557d2f74ea66b60d148f75a8e0b390a8de8d05637f6af3c0509; focused test 21821 B / 78a15089fd83e0da07c19d50a55e7ef3fc4603bea90ae1bf0fbc42da529de0d2; proof 5603 B / 3131461d61f8ff3000fda69965d36b980cbf2299f9469098ab60cfbb6862c9f1 SHA-256'dır.",
      "Repeatability=false, cross-profile coverage=false, visible scanout/input=false/false, R2 field acceptance=false ve automatic promotion=false'dur.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract -- --test-threads=1",
      "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/s573/ && curl -fsS https://aselsan.kerege.net/code/s573/",
    ],
    terminalSessions: [
      {
        id: "s573-focused",
        title: "S573 bağımsız repeat-campaign request focused kabulü",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s573_r2_supported_profile_repeat_campaign_request_contract -- --test-threads=1",
        ],
        outputLines: [
          "test result: ok. 21 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out",
          "new runtime/physical/repeat=0/0/0; physical/device operations=0",
          "S574 fresh freeze required; S575 separate authorization required",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s573-board-rpi5-compile-check",
        title: "S573 sonrası supported board-profile compile kontrolü",
        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",
          "aselsan_kernel warning headings=4496; zero-warning claimed=false",
          "S573 module linked into kernel=false; runtime/physical observation=0/0; device operations=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s573-identity-and-boundary",
        title: "S573 fresh identity ve S571 no-reuse sınırı",
        commandLines: [
          "shasum -a 256 kernel/src/*s573_r2_supported_profile_repeat_campaign_request_contract.rs",
          "shasum -a 256 simulation/tests/*s573_r2_supported_profile_repeat_campaign_request_contract.rs",
          "shasum -a 256 docs/*S573-R2-Supported-Profile-Repeat-Campaign-Request-Contract-Proof.md",
        ],
        outputLines: [
          "implementation=17775 B / 391b6b6ca2b3b557d2f74ea66b60d148f75a8e0b390a8de8d05637f6af3c0509",
          "focused=21821 B / 78a15089fd83e0da07c19d50a55e7ef3fc4603bea90ae1bf0fbc42da529de0d2",
          "proof=5603 B / 3131461d61f8ff3000fda69965d36b980cbf2299f9469098ab60cfbb6862c9f1",
          "S571 token/lock/evidence reuse=REJECTED; authorization_received=false",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s573-status-and-site",
        title: "S573 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",
        ],
        outputLines: [
          "project status renderer: PASS",
          "S573 source + focused test + proof + Operations record: exact identity-bound",
          "Operations /operations/s573 and Code /code/s573: statically generated",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s573-production-deploy",
        title: "S573 Cloudflare Pages production yayını ve canlı okuma",
        commandLines: [
          "cd website && npm run deploy",
          "curl -fsS https://aselsan.kerege.net/operations/s573/",
          "curl -fsS https://aselsan.kerege.net/code/s573/",
        ],
        outputLines: [
          "Cloudflare Pages deploy: exit 0",
          "custom-domain operations/s573: HTTP 200 and S573 content present",
          "custom-domain code/s573: HTTP 200 and S573 source layers present",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    limitations: [
      "S573 bir fiziksel tekrar değildir; yalnız future S574/S575 kabul sözleşmesini yayımlar.",
      "S574 henüz yürütülmedi ve yeni candidate-freeze evidence kaydı yoktur.",
      "S575 için concrete operatör authorization token'ı henüz üretilmedi veya alınmadı.",
      "S571 one-shot token'ı, retained transaction lock'ı ve evidence ağacı yeniden kullanılamaz veya değiştirilemez.",
      "Gelecek operasyon sayıları gereksinimdir; S573'te gerçekleşmiş SD/UART/güç/raw iddiası değildir.",
      "Independent physical repeat, repeatability, cross-profile coverage, visible scanout/input ve R2 saha kabulü tamamlanmamıştır.",
      "RUNBOOK_EXECUTED_IN_S573=NO; physical/device operations=0.",
    ],
  },