S567 · R1 uygulama/recovery/update kabul matrisi

//! S567 models the R1 stage-4 acceptance matrix aggregator for the
//! application, recovery and update demonstration gates S561 through S566.
//!
//! The matrix has one row per stage-4 gate (S561 permissioned launch, S562
//! kill/restart supervision, S563 bounded recovery containment, S564 update
//! manifest hash chain, S565 staged A/B apply and rollback, S566 lab update
//! runbook contract) and one column per acceptance criterion.  A pure
//! reconciliation function derives the stage status from the rows: it is
//! `ModelComplete` only when every row is model-complete and no row claims a
//! hardware or physical observation; it is never `Accepted`, because product
//! acceptance requires physical evidence that no source/host gate can supply.
//! The matrix is rendered as a fixed-width text table with an FNV-1a checksum
//! so the focused test can pin the exact rendering.
//!
//! S567 is a source/host model gate.  It claims no hardware: no panel, modem,
//! touch controller, SD card, UART, power transition or board observation
//! exists for it (`physical observations = 0`, `RUNBOOK_EXECUTED_IN_S567=NO`,
//! `Boot-to-UI physically observed = false`, `R1 acceptance complete = false`).
//! It is not wired into any boot, IRQ, scheduler or driver path, performs no
//! MMIO or inline assembly, does not rerun S540 or S543 and cannot promote
//! their immutable RED verdicts.  Predecessor: S566.  Next gate: S568 (R1
//! evidence matrix stage).

use alloc::string::String;
use alloc::vec::Vec;

pub const S567_SEQUENCE: usize = 567;
pub const S567_EXPECTED_PREDECESSOR: usize = 566;
pub const S567_R1_STAGE: u8 = 4;
pub const S567_R1_RANGE_FIRST: usize = 536;
pub const S567_R1_RANGE_LAST: usize = 568;
pub const S567_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S567_PHYSICAL_OBSERVATIONS: usize = 0;
pub const S567_PHYSICAL_OR_DEVICE_OPERATIONS: usize = 0;
pub const S567_SD_WRITES: usize = 0;
pub const S567_UART_OPENS: usize = 0;
pub const S567_POWER_TRANSITIONS: usize = 0;
pub const S567_NEW_IMMUTABLE_RAW_CAPTURES: usize = 0;
pub const S567_S540_PHYSICAL_VERDICT_RETAINED_RED: bool = true;
pub const S567_S543_PHYSICAL_VERDICT_RETAINED_RED: bool = true;
pub const S567_AUTOMATIC_PROMOTION: bool = false;
pub const S567_BOOT_TO_UI_PHYSICALLY_OBSERVED: bool = false;
pub const S567_HARDWARE_PRESENT: bool = false;
pub const S567_R1_ACCEPTANCE_COMPLETE: bool = false;
pub const RUNBOOK_EXECUTED_IN_S567: bool = false;

/// First and last stage-4 gate aggregated by the matrix.
pub const S567_MATRIX_FIRST_ROW_SEQUENCE: usize = 561;
pub const S567_MATRIX_LAST_ROW_SEQUENCE: usize = 566;
pub const S567_MATRIX_ROW_COUNT: usize =
    S567_MATRIX_LAST_ROW_SEQUENCE - S567_MATRIX_FIRST_ROW_SEQUENCE + 1;
pub const S567_MATRIX_COLUMN_COUNT: usize = 6;
/// Upper bound for a single row's focused-test count; larger values are
/// treated as malformed input rather than evidence.
pub const S567_MAX_FOCUSED_PASSED_PER_ROW: u32 = 4096;
/// Width of the title column and of every rendered line.
pub const S567_RENDER_TITLE_WIDTH: usize = 32;
pub const S567_RENDER_LINE_WIDTH: usize = 97;
pub const S567_RENDER_LINE_COUNT: usize = 4 + S567_MATRIX_ROW_COUNT;
pub const S567_FNV1A_OFFSET_BASIS: u32 = 0x811c_9dc5;
pub const S567_FNV1A_PRIME: u32 = 0x0100_0193;

/// Acceptance criteria columns; each is owned by exactly one stage-4 gate.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS567AcceptanceCriterion {
    PermissionedLaunch,
    KillRestart,
    Containment,
    ManifestChain,
    AbRollback,
    RunbookContract,
}

impl G8lS567AcceptanceCriterion {
    pub const ALL: [Self; S567_MATRIX_COLUMN_COUNT] = [
        Self::PermissionedLaunch,
        Self::KillRestart,
        Self::Containment,
        Self::ManifestChain,
        Self::AbRollback,
        Self::RunbookContract,
    ];

    pub const fn column_index(self) -> usize {
        match self {
            Self::PermissionedLaunch => 0,
            Self::KillRestart => 1,
            Self::Containment => 2,
            Self::ManifestChain => 3,
            Self::AbRollback => 4,
            Self::RunbookContract => 5,
        }
    }

    /// The gate whose model satisfies this criterion.
    pub const fn owning_row_sequence(self) -> usize {
        S567_MATRIX_FIRST_ROW_SEQUENCE + self.column_index()
    }

    pub const fn short_label(self) -> &'static str {
        match self {
            Self::PermissionedLaunch => "PL",
            Self::KillRestart => "KR",
            Self::Containment => "CT",
            Self::ManifestChain => "MC",
            Self::AbRollback => "AB",
            Self::RunbookContract => "RC",
        }
    }

    pub const fn long_label(self) -> &'static str {
        match self {
            Self::PermissionedLaunch => "permissioned launch",
            Self::KillRestart => "kill/restart",
            Self::Containment => "containment",
            Self::ManifestChain => "manifest chain",
            Self::AbRollback => "A/B rollback",
            Self::RunbookContract => "runbook contract",
        }
    }
}

/// Canonical row title for a stage-4 gate; `None` outside 561..=566.
pub const fn canonical_s567_row_title(sequence: usize) -> Option<&'static str> {
    match sequence {
        561 => Some("permissioned application launch"),
        562 => Some("service kill/restart supervision"),
        563 => Some("bounded recovery containment"),
        564 => Some("update manifest hash chain"),
        565 => Some("staged A/B apply and rollback"),
        566 => Some("lab update runbook contract"),
        _ => None,
    }
}

/// One matrix row as supplied by the caller.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS567MatrixRow {
    pub sequence: usize,
    pub title: &'static str,
    pub model_complete: bool,
    pub hardware_present: bool,
    pub physical_observed: bool,
    pub focused_passed: u32,
}

/// Canonical model-complete row for a stage-4 gate with the given focused
/// count; the caller supplies the count, S567 never invents it.
pub const fn canonical_s567_row(sequence: usize, focused_passed: u32) -> Option<G8lS567MatrixRow> {
    match canonical_s567_row_title(sequence) {
        Some(title) => Some(G8lS567MatrixRow {
            sequence,
            title,
            model_complete: true,
            hardware_present: false,
            physical_observed: false,
            focused_passed,
        }),
        None => None,
    }
}

/// Value of one matrix cell.  `PhysicallyAccepted` exists to name the state
/// the product needs; S567 has no path that produces it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS567CellMark {
    NotApplicable,
    ModelPending,
    ModelComplete,
    PhysicallyAccepted,
}

impl G8lS567CellMark {
    pub const fn glyph(self) -> &'static str {
        match self {
            Self::NotApplicable => "-",
            Self::ModelPending => "p",
            Self::ModelComplete => "M",
            Self::PhysicallyAccepted => "A",
        }
    }
}

/// Cell mark for a row under a criterion column.
pub const fn s567_cell_mark(
    row: G8lS567MatrixRow,
    criterion: G8lS567AcceptanceCriterion,
) -> G8lS567CellMark {
    if row.sequence != criterion.owning_row_sequence() {
        G8lS567CellMark::NotApplicable
    } else if row.model_complete {
        G8lS567CellMark::ModelComplete
    } else {
        G8lS567CellMark::ModelPending
    }
}

/// Stage-level verdict.  `Accepted` is unreachable from S567 inputs.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS567StageStatus {
    ModelIncomplete,
    ModelComplete,
    Accepted,
}

impl G8lS567StageStatus {
    pub const fn label(self) -> &'static str {
        match self {
            Self::ModelIncomplete => "ModelIncomplete",
            Self::ModelComplete => "ModelComplete",
            Self::Accepted => "Accepted",
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS567AcceptanceMatrixReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub r1_stage: u8,
    pub first_row_sequence: usize,
    pub last_row_sequence: usize,
    pub row_count: usize,
    pub column_count: usize,
    pub model_complete_rows: usize,
    pub hardware_rows: usize,
    pub physical_rows: usize,
    pub focused_passed_total: u32,
    pub stage_status: G8lS567StageStatus,
    pub product_accepted: bool,
    pub render_bytes: usize,
    pub render_line_count: usize,
    pub render_checksum: u32,
    pub hardware_present: bool,
    pub s540_physical_verdict_retained_red: bool,
    pub s543_physical_verdict_retained_red: bool,
    pub automatic_promotion: bool,
    pub supported_profile_runtime_observations: usize,
    pub physical_observations: usize,
    pub boot_to_ui_physically_observed: bool,
    pub r1_acceptance_complete: bool,
    pub runbook_executed: bool,
}

#[derive(Debug)]
pub struct G8lS567AcceptanceMatrixState {
    receipt: Option<G8lS567AcceptanceMatrixReceipt>,
}

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

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

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS567AcceptanceMatrixOutcome {
    MatrixPublished(G8lS567AcceptanceMatrixReceipt),
    MatrixRetained(G8lS567AcceptanceMatrixReceipt),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS567AcceptanceMatrixError {
    RowCountMismatch,
    RowSequenceOutOfRange,
    DuplicateRowSequence,
    MissingRowSequence,
    RowTitleDrift,
    HardwareClaimRejected,
    PhysicalClaimRejected,
    FocusedCountMissing,
    FocusedCountOverflow,
    FocusedTotalOverflow,
    StageModelIncomplete,
    RenderWidthDrift,
    PublishedStateDrift,
}

impl G8lS567AcceptanceMatrixError {
    pub const fn diagnostic_code(self) -> u64 {
        match self {
            Self::RowCountMismatch => 0x5671,
            Self::RowSequenceOutOfRange => 0x5672,
            Self::DuplicateRowSequence => 0x5673,
            Self::MissingRowSequence => 0x5674,
            Self::RowTitleDrift => 0x5675,
            Self::HardwareClaimRejected => 0x5676,
            Self::PhysicalClaimRejected => 0x5677,
            Self::FocusedCountMissing => 0x5678,
            Self::FocusedCountOverflow => 0x5679,
            Self::FocusedTotalOverflow => 0x567a,
            Self::StageModelIncomplete => 0x567b,
            Self::RenderWidthDrift => 0x567c,
            Self::PublishedStateDrift => 0x567d,
        }
    }
}

/// Structural validation shared by reconciliation and rendering: exactly one
/// row per stage-4 gate, canonical titles, no hardware/physical claim and a
/// bounded, nonzero focused count on every model-complete row.  Returns the
/// rows in canonical ascending order.
pub fn validate_s567_rows(
    rows: &[G8lS567MatrixRow],
) -> Result<[G8lS567MatrixRow; S567_MATRIX_ROW_COUNT], G8lS567AcceptanceMatrixError> {
    if rows.len() != S567_MATRIX_ROW_COUNT {
        return Err(G8lS567AcceptanceMatrixError::RowCountMismatch);
    }
    let mut seen: u8 = 0;
    for row in rows {
        if row.sequence < S567_MATRIX_FIRST_ROW_SEQUENCE
            || row.sequence > S567_MATRIX_LAST_ROW_SEQUENCE
        {
            return Err(G8lS567AcceptanceMatrixError::RowSequenceOutOfRange);
        }
        let bit = 1u8 << (row.sequence - S567_MATRIX_FIRST_ROW_SEQUENCE);
        if seen & bit != 0 {
            return Err(G8lS567AcceptanceMatrixError::DuplicateRowSequence);
        }
        seen |= bit;
    }
    if seen != (1u8 << S567_MATRIX_ROW_COUNT) - 1 {
        return Err(G8lS567AcceptanceMatrixError::MissingRowSequence);
    }
    let mut ordered = [G8lS567MatrixRow {
        sequence: 0,
        title: "",
        model_complete: false,
        hardware_present: false,
        physical_observed: false,
        focused_passed: 0,
    }; S567_MATRIX_ROW_COUNT];
    for row in rows {
        let canonical_title = canonical_s567_row_title(row.sequence)
            .ok_or(G8lS567AcceptanceMatrixError::RowSequenceOutOfRange)?;
        if row.title != canonical_title {
            return Err(G8lS567AcceptanceMatrixError::RowTitleDrift);
        }
        if row.hardware_present {
            return Err(G8lS567AcceptanceMatrixError::HardwareClaimRejected);
        }
        if row.physical_observed {
            return Err(G8lS567AcceptanceMatrixError::PhysicalClaimRejected);
        }
        if row.focused_passed > S567_MAX_FOCUSED_PASSED_PER_ROW {
            return Err(G8lS567AcceptanceMatrixError::FocusedCountOverflow);
        }
        if row.model_complete && row.focused_passed == 0 {
            return Err(G8lS567AcceptanceMatrixError::FocusedCountMissing);
        }
        ordered[row.sequence - S567_MATRIX_FIRST_ROW_SEQUENCE] = *row;
    }
    Ok(ordered)
}

/// Sum of the rows' focused counts with checked arithmetic.
pub fn s567_focused_passed_total(
    rows: &[G8lS567MatrixRow],
) -> Result<u32, G8lS567AcceptanceMatrixError> {
    let mut total: u32 = 0;
    for row in rows {
        total = total
            .checked_add(row.focused_passed)
            .ok_or(G8lS567AcceptanceMatrixError::FocusedTotalOverflow)?;
    }
    Ok(total)
}

/// Stage status from validated rows.  `ModelComplete` requires every row to
/// be model-complete with no hardware or physical claim; the function has no
/// branch that yields `Accepted`.
pub fn reconcile_s567_stage_status(
    rows: &[G8lS567MatrixRow],
) -> Result<G8lS567StageStatus, G8lS567AcceptanceMatrixError> {
    let ordered = validate_s567_rows(rows)?;
    let all_model_complete = ordered.iter().all(|row| row.model_complete);
    let any_claim = ordered
        .iter()
        .any(|row| row.hardware_present || row.physical_observed);
    if all_model_complete && !any_claim {
        Ok(G8lS567StageStatus::ModelComplete)
    } else {
        Ok(G8lS567StageStatus::ModelIncomplete)
    }
}

/// FNV-1a 32-bit checksum of the rendered table bytes.
pub fn s567_render_checksum(rendered: &str) -> u32 {
    let mut hash = S567_FNV1A_OFFSET_BASIS;
    for byte in rendered.bytes() {
        hash ^= u32::from(byte);
        hash = hash.wrapping_mul(S567_FNV1A_PRIME);
    }
    hash
}

fn push_left(out: &mut String, text: &str, width: usize) {
    let mut used = 0;
    for ch in text.chars().take(width) {
        out.push(ch);
        used += 1;
    }
    while used < width {
        out.push(' ');
        used += 1;
    }
}

fn push_right(out: &mut String, text: &str, width: usize) {
    let len = text.chars().count().min(width);
    for _ in len..width {
        out.push(' ');
    }
    for ch in text.chars().take(width) {
        out.push(ch);
    }
}

fn push_fixed_line(out: &mut String, line: &str) -> Result<(), G8lS567AcceptanceMatrixError> {
    if line.chars().count() > S567_RENDER_LINE_WIDTH {
        return Err(G8lS567AcceptanceMatrixError::RenderWidthDrift);
    }
    push_left(out, line, S567_RENDER_LINE_WIDTH);
    out.push('\n');
    Ok(())
}

fn yes_no(flag: bool) -> &'static str {
    if flag {
        "yes"
    } else {
        "no"
    }
}

/// Fixed-width text rendering of the matrix.  Every line is exactly
/// `S567_RENDER_LINE_WIDTH` characters plus a newline; the row order is
/// canonical regardless of the caller's order.
pub fn render_s567_acceptance_matrix(
    rows: &[G8lS567MatrixRow],
) -> Result<String, G8lS567AcceptanceMatrixError> {
    let ordered = validate_s567_rows(rows)?;
    let stage_status = reconcile_s567_stage_status(rows)?;
    let total = s567_focused_passed_total(&ordered)?;
    let model_complete_rows = ordered.iter().filter(|row| row.model_complete).count();
    let mut out = String::new();

    push_fixed_line(
        &mut out,
        "S567 R1 stage-4 acceptance matrix (model only; hardware=none; physical=0; runbook=NO)",
    )?;

    let mut header = String::new();
    push_left(&mut header, "gate", 4);
    header.push_str(" | ");
    push_left(&mut header, "title", S567_RENDER_TITLE_WIDTH);
    header.push_str(" | mdl | hw  | phy | focused");
    for criterion in G8lS567AcceptanceCriterion::ALL {
        header.push_str(" | ");
        push_left(&mut header, criterion.short_label(), 2);
    }
    push_fixed_line(&mut out, &header)?;

    let rule: String = header
        .chars()
        .map(|ch| if ch == '|' { '+' } else { '-' })
        .collect();
    push_fixed_line(&mut out, &rule)?;

    for row in ordered {
        let mut line = String::new();
        line.push_str(&alloc::format!("S{}", row.sequence));
        line.push_str(" | ");
        push_left(&mut line, row.title, S567_RENDER_TITLE_WIDTH);
        line.push_str(" | ");
        push_left(&mut line, yes_no(row.model_complete), 3);
        line.push_str(" | ");
        push_left(&mut line, yes_no(row.hardware_present), 3);
        line.push_str(" | ");
        push_left(&mut line, yes_no(row.physical_observed), 3);
        line.push_str(" | ");
        push_right(&mut line, &alloc::format!("{}", row.focused_passed), 7);
        for criterion in G8lS567AcceptanceCriterion::ALL {
            line.push_str(" | ");
            push_left(&mut line, s567_cell_mark(row, criterion).glyph(), 2);
        }
        push_fixed_line(&mut out, &line)?;
    }

    let footer = alloc::format!(
        "stage={} accepted=false rows={}/{} focused={} S540=RED S543=RED promotion=false",
        stage_status.label(),
        model_complete_rows,
        S567_MATRIX_ROW_COUNT,
        total
    );
    push_fixed_line(&mut out, &footer)?;
    Ok(out)
}

/// Column legend as separate short lines (not part of the checksummed table).
pub fn s567_column_legend() -> Vec<String> {
    G8lS567AcceptanceCriterion::ALL
        .iter()
        .map(|criterion| {
            alloc::format!(
                "{} = {} (S{})",
                criterion.short_label(),
                criterion.long_label(),
                criterion.owning_row_sequence()
            )
        })
        .collect()
}

/// Reconcile and publish the stage-4 matrix receipt.  Publication requires a
/// `ModelComplete` stage; exact replay retains the same receipt and any
/// divergent row set after publication fails closed.
pub fn service_s567_model_reconcile_acceptance_matrix(
    state: &mut G8lS567AcceptanceMatrixState,
    rows: &[G8lS567MatrixRow],
) -> Result<G8lS567AcceptanceMatrixOutcome, G8lS567AcceptanceMatrixError> {
    let ordered = validate_s567_rows(rows)?;
    let stage_status = reconcile_s567_stage_status(rows)?;
    if stage_status != G8lS567StageStatus::ModelComplete {
        return Err(G8lS567AcceptanceMatrixError::StageModelIncomplete);
    }
    let total = s567_focused_passed_total(&ordered)?;
    let rendered = render_s567_acceptance_matrix(rows)?;
    let line_count = rendered.lines().count();
    if line_count != S567_RENDER_LINE_COUNT
        || rendered.len() != S567_RENDER_LINE_COUNT * (S567_RENDER_LINE_WIDTH + 1)
    {
        return Err(G8lS567AcceptanceMatrixError::RenderWidthDrift);
    }
    let receipt = G8lS567AcceptanceMatrixReceipt {
        sequence: S567_SEQUENCE,
        predecessor_sequence: S567_EXPECTED_PREDECESSOR,
        r1_stage: S567_R1_STAGE,
        first_row_sequence: S567_MATRIX_FIRST_ROW_SEQUENCE,
        last_row_sequence: S567_MATRIX_LAST_ROW_SEQUENCE,
        row_count: S567_MATRIX_ROW_COUNT,
        column_count: S567_MATRIX_COLUMN_COUNT,
        model_complete_rows: ordered.iter().filter(|row| row.model_complete).count(),
        hardware_rows: ordered.iter().filter(|row| row.hardware_present).count(),
        physical_rows: ordered.iter().filter(|row| row.physical_observed).count(),
        focused_passed_total: total,
        stage_status,
        product_accepted: false,
        render_bytes: rendered.len(),
        render_line_count: line_count,
        render_checksum: s567_render_checksum(&rendered),
        hardware_present: S567_HARDWARE_PRESENT,
        s540_physical_verdict_retained_red: S567_S540_PHYSICAL_VERDICT_RETAINED_RED,
        s543_physical_verdict_retained_red: S567_S543_PHYSICAL_VERDICT_RETAINED_RED,
        automatic_promotion: S567_AUTOMATIC_PROMOTION,
        supported_profile_runtime_observations: S567_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS,
        physical_observations: S567_PHYSICAL_OBSERVATIONS,
        boot_to_ui_physically_observed: S567_BOOT_TO_UI_PHYSICALLY_OBSERVED,
        r1_acceptance_complete: S567_R1_ACCEPTANCE_COMPLETE,
        runbook_executed: RUNBOOK_EXECUTED_IN_S567,
    };
    if let Some(published) = state.receipt {
        if published != receipt {
            return Err(G8lS567AcceptanceMatrixError::PublishedStateDrift);
        }
        return Ok(G8lS567AcceptanceMatrixOutcome::MatrixRetained(published));
    }
    state.receipt = Some(receipt);
    Ok(G8lS567AcceptanceMatrixOutcome::MatrixPublished(receipt))
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s567_r1_application_recovery_update_acceptance_matrix::*;
use std::collections::BTreeSet;

const SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s567_r1_application_recovery_update_acceptance_matrix.rs"
);
const MAIN: &str = include_str!("../../kernel/src/main.rs");
const SIMULATION_LIB: &str = include_str!("../src/lib.rs");

/// Focused counts supplied by the caller for S561..=S566 (model fixture; the
/// aggregator never invents them).
const FIXTURE_FOCUSED: [u32; 6] = [16, 17, 18, 19, 20, 21];
const FIXTURE_TOTAL: u32 = 16 + 17 + 18 + 19 + 20 + 21;
const FIXTURE_RENDER_CHECKSUM: u32 = 0xd3f2_08f9;

fn canonical_rows() -> Vec<G8lS567MatrixRow> {
    (S567_MATRIX_FIRST_ROW_SEQUENCE..=S567_MATRIX_LAST_ROW_SEQUENCE)
        .map(|sequence| {
            canonical_s567_row(
                sequence,
                FIXTURE_FOCUSED[sequence - S567_MATRIX_FIRST_ROW_SEQUENCE],
            )
            .unwrap()
        })
        .collect()
}

fn publish(
    state: &mut G8lS567AcceptanceMatrixState,
    rows: &[G8lS567MatrixRow],
) -> Result<G8lS567AcceptanceMatrixOutcome, G8lS567AcceptanceMatrixError> {
    service_s567_model_reconcile_acceptance_matrix(state, rows)
}

#[test]
fn sequence_scope_and_nonpromotion_are_exact() {
    assert_eq!(S567_SEQUENCE, 567);
    assert_eq!(S567_EXPECTED_PREDECESSOR, 566);
    assert_eq!(S567_R1_STAGE, 4);
    assert_eq!(S567_R1_RANGE_FIRST, 536);
    assert_eq!(S567_R1_RANGE_LAST, 568);
    assert_eq!(S567_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert_eq!(S567_PHYSICAL_OBSERVATIONS, 0);
    assert_eq!(S567_PHYSICAL_OR_DEVICE_OPERATIONS, 0);
    assert_eq!(S567_SD_WRITES, 0);
    assert_eq!(S567_UART_OPENS, 0);
    assert_eq!(S567_POWER_TRANSITIONS, 0);
    assert_eq!(S567_NEW_IMMUTABLE_RAW_CAPTURES, 0);
    assert!(S567_S540_PHYSICAL_VERDICT_RETAINED_RED);
    assert!(S567_S543_PHYSICAL_VERDICT_RETAINED_RED);
    assert!(!S567_AUTOMATIC_PROMOTION);
    assert!(!S567_BOOT_TO_UI_PHYSICALLY_OBSERVED);
    assert!(!S567_HARDWARE_PRESENT);
    assert!(!S567_R1_ACCEPTANCE_COMPLETE);
    assert!(!RUNBOOK_EXECUTED_IN_S567);
    assert_eq!(S567_MATRIX_FIRST_ROW_SEQUENCE, 561);
    assert_eq!(S567_MATRIX_LAST_ROW_SEQUENCE, 566);
    assert_eq!(S567_MATRIX_ROW_COUNT, 6);
    assert_eq!(S567_MATRIX_COLUMN_COUNT, 6);
    assert_eq!(S567_RENDER_LINE_COUNT, 10);
}

#[test]
fn module_is_registered_in_kernel_and_simulation() {
    let module = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s567_r1_application_recovery_update_acceptance_matrix";
    assert!(MAIN.contains(&format!("mod {module};")));
    assert!(SIMULATION_LIB.contains(&format!("pub mod {module};")));
}

#[test]
fn source_has_no_device_execution_or_uart_emission_surface() {
    for forbidden in [
        "unsafe",
        "asm!",
        "write_volatile",
        "crate::uart",
        "crate::arch",
        "#[no_mangle]",
        "spin::",
        "std::",
    ] {
        assert!(!SOURCE.contains(forbidden), "forbidden token: {forbidden}");
    }
    assert!(SOURCE.contains("S567_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0"));
    assert!(SOURCE.contains("S567_PHYSICAL_OBSERVATIONS: usize = 0"));
    assert!(SOURCE.contains("S567_PHYSICAL_OR_DEVICE_OPERATIONS: usize = 0"));
    assert!(SOURCE.contains("S567_HARDWARE_PRESENT: bool = false"));
    assert!(SOURCE.contains("S567_R1_ACCEPTANCE_COMPLETE: bool = false"));
    assert!(SOURCE.contains("RUNBOOK_EXECUTED_IN_S567: bool = false"));
}

#[test]
fn diagnostic_codes_are_nonzero_and_unique() {
    let errors = [
        G8lS567AcceptanceMatrixError::RowCountMismatch,
        G8lS567AcceptanceMatrixError::RowSequenceOutOfRange,
        G8lS567AcceptanceMatrixError::DuplicateRowSequence,
        G8lS567AcceptanceMatrixError::MissingRowSequence,
        G8lS567AcceptanceMatrixError::RowTitleDrift,
        G8lS567AcceptanceMatrixError::HardwareClaimRejected,
        G8lS567AcceptanceMatrixError::PhysicalClaimRejected,
        G8lS567AcceptanceMatrixError::FocusedCountMissing,
        G8lS567AcceptanceMatrixError::FocusedCountOverflow,
        G8lS567AcceptanceMatrixError::FocusedTotalOverflow,
        G8lS567AcceptanceMatrixError::StageModelIncomplete,
        G8lS567AcceptanceMatrixError::RenderWidthDrift,
        G8lS567AcceptanceMatrixError::PublishedStateDrift,
    ];
    let codes: BTreeSet<_> = errors
        .into_iter()
        .map(G8lS567AcceptanceMatrixError::diagnostic_code)
        .collect();
    assert_eq!(codes.len(), errors.len());
    assert!(!codes.contains(&0));
}

#[test]
fn canonical_rows_publish_model_complete_matrix() {
    let mut state = G8lS567AcceptanceMatrixState::new();
    assert_eq!(state.receipt(), None);
    let G8lS567AcceptanceMatrixOutcome::MatrixPublished(receipt) =
        publish(&mut state, &canonical_rows()).unwrap()
    else {
        panic!("first S567 publication missing")
    };
    assert_eq!(state.receipt(), Some(receipt));
    assert_eq!(receipt.sequence, S567_SEQUENCE);
    assert_eq!(receipt.predecessor_sequence, S567_EXPECTED_PREDECESSOR);
    assert_eq!(receipt.r1_stage, 4);
    assert_eq!(receipt.first_row_sequence, 561);
    assert_eq!(receipt.last_row_sequence, 566);
    assert_eq!(receipt.row_count, 6);
    assert_eq!(receipt.column_count, 6);
    assert_eq!(receipt.model_complete_rows, 6);
    assert_eq!(receipt.hardware_rows, 0);
    assert_eq!(receipt.physical_rows, 0);
    assert_eq!(receipt.focused_passed_total, FIXTURE_TOTAL);
    assert_eq!(receipt.stage_status, G8lS567StageStatus::ModelComplete);
    assert!(!receipt.product_accepted);
    assert_eq!(receipt.render_line_count, S567_RENDER_LINE_COUNT);
    assert_eq!(
        receipt.render_bytes,
        S567_RENDER_LINE_COUNT * (S567_RENDER_LINE_WIDTH + 1)
    );
    assert_eq!(receipt.render_checksum, FIXTURE_RENDER_CHECKSUM);
    assert!(!receipt.hardware_present);
    assert!(receipt.s540_physical_verdict_retained_red);
    assert!(receipt.s543_physical_verdict_retained_red);
    assert!(!receipt.automatic_promotion);
    assert_eq!(receipt.supported_profile_runtime_observations, 0);
    assert_eq!(receipt.physical_observations, 0);
    assert!(!receipt.boot_to_ui_physically_observed);
    assert!(!receipt.r1_acceptance_complete);
    assert!(!receipt.runbook_executed);
}

#[test]
fn exact_replay_retains_the_same_receipt() {
    let mut state = G8lS567AcceptanceMatrixState::new();
    let G8lS567AcceptanceMatrixOutcome::MatrixPublished(receipt) =
        publish(&mut state, &canonical_rows()).unwrap()
    else {
        panic!("first publication missing")
    };
    assert_eq!(
        publish(&mut state, &canonical_rows()),
        Ok(G8lS567AcceptanceMatrixOutcome::MatrixRetained(receipt))
    );
    let mut reversed = canonical_rows();
    reversed.reverse();
    assert_eq!(
        publish(&mut state, &reversed),
        Ok(G8lS567AcceptanceMatrixOutcome::MatrixRetained(receipt))
    );
}

#[test]
fn divergent_input_after_publication_fails_closed() {
    let mut state = G8lS567AcceptanceMatrixState::new();
    let published = publish(&mut state, &canonical_rows()).unwrap();
    let mut rows = canonical_rows();
    rows[2].focused_passed += 1;
    assert_eq!(
        publish(&mut state, &rows),
        Err(G8lS567AcceptanceMatrixError::PublishedStateDrift)
    );
    let G8lS567AcceptanceMatrixOutcome::MatrixPublished(receipt) = published else {
        panic!("publication missing")
    };
    assert_eq!(state.receipt(), Some(receipt));
}

#[test]
fn reconcile_reports_model_incomplete_when_any_row_pending() {
    assert_eq!(
        reconcile_s567_stage_status(&canonical_rows()),
        Ok(G8lS567StageStatus::ModelComplete)
    );
    for index in 0..S567_MATRIX_ROW_COUNT {
        let mut rows = canonical_rows();
        rows[index].model_complete = false;
        assert_eq!(
            reconcile_s567_stage_status(&rows),
            Ok(G8lS567StageStatus::ModelIncomplete)
        );
        let mut state = G8lS567AcceptanceMatrixState::new();
        assert_eq!(
            publish(&mut state, &rows),
            Err(G8lS567AcceptanceMatrixError::StageModelIncomplete)
        );
        assert_eq!(state.receipt(), None);
        let rendered = render_s567_acceptance_matrix(&rows).unwrap();
        assert!(rendered.contains("stage=ModelIncomplete accepted=false rows=5/6"));
        assert!(rendered.contains("| p "));
    }
}

#[test]
fn missing_row_fails_closed() {
    let rows = canonical_rows();
    assert_eq!(
        reconcile_s567_stage_status(&rows[..5]),
        Err(G8lS567AcceptanceMatrixError::RowCountMismatch)
    );
    assert_eq!(
        reconcile_s567_stage_status(&[]),
        Err(G8lS567AcceptanceMatrixError::RowCountMismatch)
    );
    let mut seven = rows.clone();
    seven.push(rows[0]);
    assert_eq!(
        reconcile_s567_stage_status(&seven),
        Err(G8lS567AcceptanceMatrixError::RowCountMismatch)
    );
}

#[test]
fn duplicate_row_id_fails_closed() {
    let mut rows = canonical_rows();
    rows[5] = rows[0];
    assert_eq!(
        validate_s567_rows(&rows),
        Err(G8lS567AcceptanceMatrixError::DuplicateRowSequence)
    );
    let mut state = G8lS567AcceptanceMatrixState::new();
    assert_eq!(
        publish(&mut state, &rows),
        Err(G8lS567AcceptanceMatrixError::DuplicateRowSequence)
    );
    assert_eq!(state.receipt(), None);
}

#[test]
fn sequence_outside_561_566_fails_closed() {
    for out_of_range in [0usize, 536, 560, 567, 568, usize::MAX] {
        let mut rows = canonical_rows();
        rows[3].sequence = out_of_range;
        assert_eq!(
            validate_s567_rows(&rows),
            Err(G8lS567AcceptanceMatrixError::RowSequenceOutOfRange),
            "sequence {out_of_range}"
        );
        assert_eq!(canonical_s567_row(out_of_range, 1), None);
        assert_eq!(canonical_s567_row_title(out_of_range), None);
    }
}

#[test]
fn hardware_or_physical_claim_fails_closed() {
    let mut hardware = canonical_rows();
    hardware[1].hardware_present = true;
    assert_eq!(
        reconcile_s567_stage_status(&hardware),
        Err(G8lS567AcceptanceMatrixError::HardwareClaimRejected)
    );
    let mut physical = canonical_rows();
    physical[4].physical_observed = true;
    assert_eq!(
        reconcile_s567_stage_status(&physical),
        Err(G8lS567AcceptanceMatrixError::PhysicalClaimRejected)
    );
    let mut state = G8lS567AcceptanceMatrixState::new();
    assert_eq!(
        publish(&mut state, &hardware),
        Err(G8lS567AcceptanceMatrixError::HardwareClaimRejected)
    );
    assert_eq!(
        publish(&mut state, &physical),
        Err(G8lS567AcceptanceMatrixError::PhysicalClaimRejected)
    );
    assert_eq!(state.receipt(), None);
}

#[test]
fn title_drift_fails_closed() {
    let mut rows = canonical_rows();
    rows[0].title = "Permissioned application launch";
    assert_eq!(
        validate_s567_rows(&rows),
        Err(G8lS567AcceptanceMatrixError::RowTitleDrift)
    );
    let mut swapped = canonical_rows();
    swapped[1].title = canonical_s567_row_title(563).unwrap();
    assert_eq!(
        validate_s567_rows(&swapped),
        Err(G8lS567AcceptanceMatrixError::RowTitleDrift)
    );
    for sequence in 561..=566 {
        assert!(canonical_s567_row_title(sequence).unwrap().len() <= S567_RENDER_TITLE_WIDTH);
    }
}

#[test]
fn focused_count_zero_or_overflow_fails_closed() {
    let mut zero = canonical_rows();
    zero[2].focused_passed = 0;
    assert_eq!(
        validate_s567_rows(&zero),
        Err(G8lS567AcceptanceMatrixError::FocusedCountMissing)
    );
    let mut pending_zero = canonical_rows();
    pending_zero[2].focused_passed = 0;
    pending_zero[2].model_complete = false;
    assert_eq!(
        reconcile_s567_stage_status(&pending_zero),
        Ok(G8lS567StageStatus::ModelIncomplete)
    );
    let mut over = canonical_rows();
    over[5].focused_passed = S567_MAX_FOCUSED_PASSED_PER_ROW + 1;
    assert_eq!(
        validate_s567_rows(&over),
        Err(G8lS567AcceptanceMatrixError::FocusedCountOverflow)
    );
    let mut max = canonical_rows();
    for row in &mut max {
        row.focused_passed = S567_MAX_FOCUSED_PASSED_PER_ROW;
    }
    let mut state = G8lS567AcceptanceMatrixState::new();
    let G8lS567AcceptanceMatrixOutcome::MatrixPublished(receipt) =
        publish(&mut state, &max).unwrap()
    else {
        panic!("boundary publication missing")
    };
    assert_eq!(receipt.focused_passed_total, 6 * S567_MAX_FOCUSED_PASSED_PER_ROW);
}

#[test]
fn focused_total_uses_checked_arithmetic() {
    let mut rows = canonical_rows();
    rows[0].focused_passed = u32::MAX;
    rows[1].focused_passed = 1;
    assert_eq!(
        s567_focused_passed_total(&rows),
        Err(G8lS567AcceptanceMatrixError::FocusedTotalOverflow)
    );
    assert_eq!(
        s567_focused_passed_total(&canonical_rows()),
        Ok(FIXTURE_TOTAL)
    );
    assert_eq!(s567_focused_passed_total(&[]), Ok(0));
}

#[test]
fn rendering_is_fixed_width_and_checksum_stable() {
    let rendered = render_s567_acceptance_matrix(&canonical_rows()).unwrap();
    let lines: Vec<&str> = rendered.lines().collect();
    assert_eq!(lines.len(), S567_RENDER_LINE_COUNT);
    for line in &lines {
        assert_eq!(line.chars().count(), S567_RENDER_LINE_WIDTH, "{line:?}");
    }
    assert!(rendered.ends_with('\n'));
    assert!(lines[0].starts_with("S567 R1 stage-4 acceptance matrix (model only; hardware=none; physical=0; runbook=NO)"));
    assert!(lines[1].starts_with("gate | title"));
    assert!(lines[1].contains("| PL | KR | CT | MC | AB | RC"));
    assert_eq!(lines[2].matches('+').count(), lines[1].matches('|').count());
    assert!(lines[3].starts_with("S561 | permissioned application launch  | yes | no  | no  |      16 | M  | -  | -  | -  | -  | - "));
    assert!(lines[8].starts_with("S566 | lab update runbook contract      | yes | no  | no  |      21 | -  | -  | -  | -  | -  | M "));
    assert!(lines[9].starts_with(&format!(
        "stage=ModelComplete accepted=false rows=6/6 focused={FIXTURE_TOTAL} S540=RED S543=RED promotion=false"
    )));
    assert_eq!(s567_render_checksum(&rendered), FIXTURE_RENDER_CHECKSUM);
    assert_eq!(s567_render_checksum(""), S567_FNV1A_OFFSET_BASIS);
    assert_eq!(s567_render_checksum("a"), 0xe40c_292c);
    assert_eq!(s567_column_legend().len(), 6);
    assert_eq!(s567_column_legend()[4], "AB = A/B rollback (S565)");
}

#[test]
fn rows_in_any_order_render_canonically() {
    let canonical = render_s567_acceptance_matrix(&canonical_rows()).unwrap();
    let mut shuffled = canonical_rows();
    shuffled.swap(0, 5);
    shuffled.swap(1, 3);
    shuffled.swap(2, 4);
    let rendered = render_s567_acceptance_matrix(&shuffled).unwrap();
    assert_eq!(rendered, canonical);
    let ordered = validate_s567_rows(&shuffled).unwrap();
    for (index, row) in ordered.iter().enumerate() {
        assert_eq!(row.sequence, S567_MATRIX_FIRST_ROW_SEQUENCE + index);
    }
}

#[test]
fn stage_status_is_never_accepted() {
    for row in canonical_rows() {
        for criterion in G8lS567AcceptanceCriterion::ALL {
            let mark = s567_cell_mark(row, criterion);
            assert_ne!(mark, G8lS567CellMark::PhysicallyAccepted);
            let expected = if criterion.owning_row_sequence() == row.sequence {
                G8lS567CellMark::ModelComplete
            } else {
                G8lS567CellMark::NotApplicable
            };
            assert_eq!(mark, expected);
        }
    }
    for mask in 0u8..64 {
        let mut rows = canonical_rows();
        for (index, row) in rows.iter_mut().enumerate() {
            row.model_complete = mask & (1 << index) != 0;
        }
        let status = reconcile_s567_stage_status(&rows).unwrap();
        assert_ne!(status, G8lS567StageStatus::Accepted);
        assert_eq!(
            status == G8lS567StageStatus::ModelComplete,
            mask == 0b11_1111
        );
    }
    let rendered = render_s567_acceptance_matrix(&canonical_rows()).unwrap();
    assert!(!rendered.contains("| A "));
    assert!(!rendered.contains("accepted=true"));
    assert_eq!(G8lS567StageStatus::Accepted.label(), "Accepted");
    assert_eq!(G8lS567CellMark::PhysicallyAccepted.glyph(), "A");
}

#[test]
fn criterion_columns_are_bijective_with_rows() {
    let owners: BTreeSet<usize> = G8lS567AcceptanceCriterion::ALL
        .iter()
        .map(|criterion| criterion.owning_row_sequence())
        .collect();
    assert_eq!(
        owners,
        (S567_MATRIX_FIRST_ROW_SEQUENCE..=S567_MATRIX_LAST_ROW_SEQUENCE).collect()
    );
    for (index, criterion) in G8lS567AcceptanceCriterion::ALL.iter().enumerate() {
        assert_eq!(criterion.column_index(), index);
        assert_eq!(criterion.short_label().len(), 2);
    }
    let labels: BTreeSet<&str> = G8lS567AcceptanceCriterion::ALL
        .iter()
        .map(|criterion| criterion.short_label())
        .collect();
    assert_eq!(labels.len(), S567_MATRIX_COLUMN_COUNT);
    assert_eq!(
        G8lS567AcceptanceCriterion::RunbookContract.owning_row_sequence(),
        566
    );
}

  {
    id: "g8l-s567-r1-application-recovery-update-acceptance-matrix",
    date: "2026-08-30",
    sequence: 567,
    status: "passed",
    umbrella_status: "partial",
    title: "S567 · R1 uygulama/recovery/update kabul matrisi",
    summary:
      "S567 kaynak/host model kapısı PASS'tir: R1 4. aşamanın (uygulama, recovery ve update gösterimi) S561–S566 kapılarını satır, altı kabul kriterini (permissioned launch, kill/restart, containment, manifest chain, A/B rollback, runbook contract) sütun olarak toplayan kabul matrisi aggregator'ı modellenmiştir. Reconciliation fonksiyonu aşama durumunu yalnız tüm satırlar model-complete ve hiçbiri donanım/fiziksel iddia taşımıyorsa ModelComplete olarak hesaplar; Accepted durumu hiçbir koddan üretilemez, çünkü ürün kabulü fiziksel kanıt gerektirir. Sabit genişlikli 10 satır × 97 karakter tablo render'ı FNV-1a checksum 0xd3f208f9 ile sabitlenmiştir; eksik satır, tekrar eden id, 561–566 dışı sıra, başlık sapması, donanım/fiziksel iddia ve focused sayısı taşması fail-closed reddedilir. Focused 19/19 PASS'tir. S540 ve S543 fiziksel raw/verdict değişmez RED, runtime/physical observation=0/0, SD/UART/power/new-raw=0/0/0/0, Boot-to-UI=false, R1 acceptance=false ve RUNBOOK_EXECUTED_IN_S567=NO'dur. S568 aşama 1–4 model sonuçlarını tek kanıt matrisinde toplayan host-only kapıdır.",
    evidence: [
      "S567, S566'dan ayrı source model module, 19-test focused binary, proof, status manifest, Operations kaydı ve complete Code kartına sahiptir.",
      "Dar S567 source/host status=PASS; R1 umbrella=PARTIAL ve S540/S543 physical gate status=RED olarak ayrı tutulur.",
      "Matris satırları S561 permissioned application launch, S562 service kill/restart supervision, S563 bounded recovery containment, S564 update manifest hash chain, S565 staged A/B apply and rollback ve S566 lab update runbook contract'tır; her satır id, canonical başlık, model_complete, hardware_present=false, physical_observed=false ve çağıranın verdiği focused_passed (u32) alanlarını taşır.",
      "Sütunlar altı kabul kriteridir ve satırlarla birebir eşleşir: kriter i'nin sahibi kapı 561+i'dir; hücre işaretleri M (model complete), p (model pending), - (not applicable) ve hiçbir kod yolundan üretilmeyen A (physically accepted)'dır.",
      "reconcile_s567_stage_status yalnız tüm satırlar model-complete ve hiçbiri donanım/fiziksel iddia taşımıyorsa ModelComplete döner; 64 model-complete maskesinin tamamı taranmış, yalnız all-ones maskesi ModelComplete vermiş ve hiçbiri Accepted üretmemiştir.",
      "render_s567_acceptance_matrix 10 satır (başlık, header, rule, altı satır, footer) × exact 97 karakter (980 B) üretir; satır sırası çağıran sırasından bağımsız canonical'dır ve fixture (16/17/18/19/20/21, toplam 111) FNV-1a checksum'ı 0xd3f208f9 modül dışında bağımsız hesapla doğrulanmıştır.",
      "Fail-closed koşulları: satır sayısı 6 dışı, 561–566 dışı sıra, tekrar eden veya eksik sıra, canonical başlıktan sapma, hardware_present=true, physical_observed=true, model-complete satırda focused_passed=0, 4096 üstü focused sayısı, checked_add taşması, ModelIncomplete aşamanın publish edilmesi, 97 karakteri aşan render satırı ve publish sonrası sapan replay.",
      "On üç hata kodu sıfırdan farklı ve benzersizdir (0x5671–0x567d); exact replay ve permütasyonlu satır sırası aynı receipt'i MatrixRetained ile korur, publish sonrası tek bir focused sayısı sapması PublishedStateDrift verir.",
      "Receipt product_accepted=false, hardware_rows=0, physical_rows=0, hardware_present=false, s540/s543 retained RED, automatic_promotion=false, physical_observations=0 ve runbook_executed=false alanlarını sabit taşır.",
      "Modül hiçbir boot, IRQ, scheduler veya driver yoluna bağlanmamıştır; MMIO, inline assembly, raw bellek erişimi, statik kilit veya export edilmiş sembol içermez; tek çağıranı focused testtir.",
      "Focused target 1 grup / 19 passed / 0 failed / 0 ignored / 0 filtered verdi.",
      "Implementation 20959 B / efcaa9aa900e09ea254bd4757f1eb6d92dbdea0588f38f87a34f9dbcf4401459; focused test 17305 B / a4045837a43775ce3ed0af1b880405960973fbf00d7b80f066edce3d25a63583 SHA-256'dır.",
      "Proof 5743 B'dır.",
      "S540 immutable raw 20525 B / fc3f934543ab5d829ad8a16e2b332dd2bdc35a81c6c0f6423256101448e45114 ve S543 immutable raw 20509 B / 1f1111a1a39ab6263b505b0889d025df19d5c48bb2f84e30708412b0da47dc11 physical verdict RED olarak byte-exact korunur; automatic promotion=false ve rerun=false'dur.",
      "S567 sırasında panel, modem, touch controller, SD write/read-back/eject, UART open/capture, power transition, board gözlemi veya yeni immutable raw üretimi yapılmadı.",
      "RUNBOOK_EXECUTED_IN_S567=NO; supported-profile runtime observations=0, physical observations=0, hardware present=false, Boot-to-UI physically observed=false ve R1 acceptance=false'dur.",
      "S568 aşama 1–4 model sonuçlarını tek R1 kanıt matrisinde toplayan host-only kapıdır; aygıt, UART, power veya fiziksel koşu yetkisi değildir.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s567_r1_application_recovery_update_acceptance_matrix -- --test-threads=1",
    ],
    terminalSessions: [
      {
        id: "s567-focused",
        title: "S567 kabul matrisi aggregator focused acceptance",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s567_r1_application_recovery_update_acceptance_matrix -- --test-threads=1",
        ],
        outputLines: [
          "test result: ok. 19 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s",
          "S567 focused=1 group / 19 passed / 0 failed",
          "hardware=none physical=0 runbook=NO",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "S567 kaynak/host model PASS'tir; supported-profile runtime veya fiziksel PASS değildir. Aşama durumu en fazla ModelComplete'tir, Accepted değildir.",
    limitations: [
      "S567 yalnız kaynak/host modelidir; matris satırlarının focused sayıları çağıran tarafından verilir ve fixture değerleridir, aggregator hiçbir sayı üretmez veya doğrulamaz.",
      "Aşama durumu ModelComplete'tir; ürün kabulü (Accepted) fiziksel kanıt olmadan hesaplanamaz ve S567'de hiçbir kod yolu bunu üretmez.",
      "S540 ve S543 fiziksel RED immutable kalır; otomatik yükseltme veya yeniden yazma yoktur.",
      "S567 için hiçbir donanım/panel/modem/board gözlemi yoktur; SD/UART/power işlemi ve yeni immutable raw üretimi sıfırdır.",
      "Boot-to-UI gerçek UART'ta görülmedi; Boot-to-UI ve R1 acceptance false kalır.",
      "S568 aşama 1–4 model sonuçlarını tek R1 kanıt matrisinde toplayan host-only kapıdır; aygıt veya fiziksel koşu yetkisi değildir.",
    ],
  },