G8f runtime yarış audit'iyle GO; layout ve BOOT8F image staged

pub fn verify_transcript(input: &[u8]) -> Result<G8eEvidence, ValidationError> {
    let mut errors = Vec::new();
    // Older validators deliberately reject unknown future milestone markers.
    // Validate the immutable prerequisite only over the prefix that ends after
    // BOOT8D, then validate the complete G8e suffix below.
    let g8e_start = [b"ASELSAN/G8E".as_slice(), b"ASELSAN/BOOT8E".as_slice()]
        .into_iter()
        .filter_map(|needle| find_bytes(input, needle))
        .min()
        .unwrap_or(input.len());
    let g8d = match verify_g8d(&input[..g8e_start]) {
        Ok(evidence) => Some(evidence),
        Err(error) => {
            errors.extend(
                error
                    .messages()
                    .iter()
                    .map(|message| format!("G8d prerequisite: {message}")),
            );
            None
        }
    };

    let leading_nuls = input.iter().take_while(|&&byte| byte == 0).count();
    let transcript = match std::str::from_utf8(&input[leading_nuls..]) {
        Ok(value) => value,
        Err(error) => {
            errors.push(format!("transcript is not UTF-8: {error}"));
            return Err(ValidationError { messages: errors });
        }
    };

    let mut positions: BTreeMap<&'static str, Vec<usize>> = MARKERS
        .iter()
        .copied()
        .map(|marker| (marker, Vec::new()))
        .collect();
    let mut boot8d_line = None;
    let mut start_ticks = None;
    let mut send_tick = None;
    let mut gap_ticks = None;
    let mut irq_tick = None;
    let mut task_tick = None;
    let mut boot_base = None;
    let mut boot_ticks = None;
    let mut task_sp = None;
    let mut ack_raw = None;
    let mut eoi_raw = None;
    let mut sec_samples = Vec::new();

    for (index, raw_line) in transcript.lines().enumerate() {
        let line_number = index + 1;
        let line = raw_line.trim_end_matches('\r').trim();
        if has_marker_tag(line, "ASELSAN/BOOT8D") {
            boot8d_line = Some(line_number);
        }
        if line.starts_with("[SEC") {
            if let Some(ticks) = parse_sec_ticks(line) {
                sec_samples.push((line_number, ticks));
            }
        }
        if line.contains("ASELSAN/G8EERR")
            || line.contains("panicked at")
            || line.contains("Kernel panic")
            || line.contains("Unknown IRQ")
            || line.contains("Bilinmeyen IRQ")
        {
            errors.push(format!(
                "line {line_number}: failure evidence present: {line:?}"
            ));
        }

        let known = MARKERS
            .iter()
            .copied()
            .find(|marker| has_marker_tag(line, marker));
        if (line.starts_with("ASELSAN/G8E") || line.starts_with("ASELSAN/BOOT8E"))
            && known.is_none()
        {
            errors.push(format!(
                "line {line_number}: unknown G8e marker present: {line:?}"
            ));
        }
        let Some(marker) = known else {
            continue;
        };
        positions
            .get_mut(marker)
            .expect("known G8e marker")
            .push(line_number);
        let (fields, field_order) = match parse_fields(line, marker) {
            Ok(parsed) => parsed,
            Err(message) => {
                errors.push(format!("line {line_number}: {message}"));
                continue;
            }
        };

        match marker {
            "ASELSAN/G8E0" => {
                require_exact_keys(
                    &fields,
                    &field_order,
                    &[
                        "CPU",
                        "ROUND1",
                        "ROUND2",
                        "SOURCE",
                        "TARGET",
                        "MPIDR",
                        "SGI",
                        "TARGET_LIST",
                        "SGIR",
                        "PRIOR_SENDS",
                        "NEW_SENDS",
                        "TOTAL_SENDS",
                        "REUSE",
                        "PRIOR_PENDING",
                        "PRIOR_ACTIVE",
                        "EOIMODE",
                        "GAP_TICKS",
                        "START_TICKS",
                        "SEND_TICK",
                        "MIGRATION",
                        "TLB_SHOOTDOWN",
                        "CPU2_3",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("CPU", "0"),
                    ("ROUND1", "G8D"),
                    ("ROUND2", "G8E"),
                    ("SOURCE", "CPU0"),
                    ("TARGET", "CPU1"),
                    ("MPIDR", "0x100"),
                    ("SGI", "1"),
                    ("TARGET_LIST", "0x02"),
                    ("SGIR", "0x00020001"),
                    ("PRIOR_SENDS", "1"),
                    ("NEW_SENDS", "1"),
                    ("TOTAL_SENDS", "2"),
                    ("REUSE", "WITHOUT_REINIT"),
                    ("PRIOR_PENDING", "0"),
                    ("PRIOR_ACTIVE", "0"),
                    ("EOIMODE", "DROP_DEACTIVATE"),
                    ("MIGRATION", "OFF"),
                    ("TLB_SHOOTDOWN", "OFF"),
                    ("CPU2_3", "OFF"),
                ] {
                    require_field(&fields, key, expected, line_number, &mut errors);
                }
                gap_ticks = parse_decimal(&fields, "GAP_TICKS", line_number, &mut errors);
                start_ticks = parse_decimal(&fields, "START_TICKS", line_number, &mut errors);
                send_tick = parse_decimal(&fields, "SEND_TICK", line_number, &mut errors);
            }
            "ASELSAN/G8E1" => {
                require_exact_keys(
                    &fields,
                    &field_order,
                    &[
                        "ROUND",
                        "CPU",
                        "MPIDR",
                        "INTID",
                        "SOURCE_CPU",
                        "PRIOR_DELIVERIES",
                        "NEW_DELIVERIES",
                        "TOTAL_DELIVERIES",
                        "PRIOR_ACKS",
                        "NEW_ACKS",
                        "TOTAL_ACKS",
                        "PRIOR_EOIS",
                        "NEW_EOIS",
                        "TOTAL_EOIS",
                        "ACK_RAW",
                        "EOI_RAW",
                        "PRIOR_RESCHED",
                        "NEW_RESCHED",
                        "TOTAL_RESCHED",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "TICK",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("ROUND", "2"),
                    ("CPU", "1"),
                    ("MPIDR", "0x100"),
                    ("INTID", "1"),
                    ("SOURCE_CPU", "0"),
                    ("PRIOR_DELIVERIES", "1"),
                    ("NEW_DELIVERIES", "1"),
                    ("TOTAL_DELIVERIES", "2"),
                    ("PRIOR_ACKS", "1"),
                    ("NEW_ACKS", "1"),
                    ("TOTAL_ACKS", "2"),
                    ("PRIOR_EOIS", "1"),
                    ("NEW_EOIS", "1"),
                    ("TOTAL_EOIS", "2"),
                    ("PRIOR_RESCHED", "1"),
                    ("NEW_RESCHED", "1"),
                    ("TOTAL_RESCHED", "2"),
                    ("RETURN", "EL1H"),
                    ("IRQ", "MASKED"),
                    ("TIMER", "OFF"),
                ] {
                    require_field(&fields, key, expected, line_number, &mut errors);
                }
                ack_raw = parse_hex(&fields, "ACK_RAW", line_number, &mut errors);
                eoi_raw = parse_hex(&fields, "EOI_RAW", line_number, &mut errors);
                irq_tick = parse_decimal(&fields, "TICK", line_number, &mut errors);
            }
            "ASELSAN/G8E2" => {
                require_exact_keys(
                    &fields,
                    &field_order,
                    &[
                        "ROUND",
                        "CPU",
                        "MPIDR",
                        "TASK",
                        "PRIOR_WAKEUPS",
                        "NEW_WAKEUPS",
                        "TOTAL_WAKEUPS",
                        "PRIOR_RUNS",
                        "NEW_RUNS",
                        "TOTAL_RUNS",
                        "PROGRESS",
                        "STACK",
                        "STACK_SP",
                        "SAME_STACK_REGION",
                        "CANARY",
                        "STACK_RESTORE",
                        "FINAL_PENDING",
                        "FINAL_ACTIVE",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "EL",
                        "TPIDR",
                        "TICK",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("ROUND", "2"),
                    ("CPU", "1"),
                    ("MPIDR", "0x100"),
                    ("TASK", "PINNED0"),
                    ("PRIOR_WAKEUPS", "1"),
                    ("NEW_WAKEUPS", "1"),
                    ("TOTAL_WAKEUPS", "2"),
                    ("PRIOR_RUNS", "1"),
                    ("NEW_RUNS", "1"),
                    ("TOTAL_RUNS", "2"),
                    ("PROGRESS", "3"),
                    ("STACK", "REUSED_STATIC64K"),
                    ("SAME_STACK_REGION", "YES"),
                    ("CANARY", "OK"),
                    ("STACK_RESTORE", "OK"),
                    ("FINAL_PENDING", "0"),
                    ("FINAL_ACTIVE", "0"),
                    ("RETURN", "LOCAL_IDLE"),
                    ("IRQ", "MASKED"),
                    ("TIMER", "OFF"),
                    ("EL", "1"),
                    ("TPIDR", "1"),
                ] {
                    require_field(&fields, key, expected, line_number, &mut errors);
                }
                task_sp = parse_hex(&fields, "STACK_SP", line_number, &mut errors);
                task_tick = parse_decimal(&fields, "TICK", line_number, &mut errors);
            }
            "ASELSAN/BOOT8E" => {
                require_exact_keys(
                    &fields,
                    &field_order,
                    &[
                        "IPI",
                        "CPU0_TO_CPU1",
                        "ROUNDS",
                        "SAME_CHANNEL",
                        "SGIR",
                        "SENDS",
                        "DELIVERIES",
                        "ACKS",
                        "EOIS",
                        "RESCHED",
                        "TASK_WAKE",
                        "TASK_RUNS",
                        "PROGRESS_R1",
                        "PROGRESS_R2",
                        "STACK",
                        "SAME_STACK_REGION",
                        "QUIESCENT_BETWEEN",
                        "FINAL_PENDING",
                        "FINAL_ACTIVE",
                        "EOIMODE",
                        "GIC_REINIT",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "GENERIC_SMP",
                        "MIGRATION",
                        "TLB_SHOOTDOWN",
                        "CPU2_3",
                        "SCOPE",
                        "BASE_TICKS",
                        "TICKS",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("IPI", "SGI1"),
                    ("CPU0_TO_CPU1", "2"),
                    ("ROUNDS", "2"),
                    ("SAME_CHANNEL", "YES"),
                    ("SGIR", "0x00020001"),
                    ("SENDS", "2"),
                    ("DELIVERIES", "2"),
                    ("ACKS", "2"),
                    ("EOIS", "2"),
                    ("RESCHED", "2"),
                    ("TASK_WAKE", "2"),
                    ("TASK_RUNS", "2"),
                    ("PROGRESS_R1", "3"),
                    ("PROGRESS_R2", "3"),
                    ("STACK", "REUSED_STATIC64K"),
                    ("SAME_STACK_REGION", "YES"),
                    ("QUIESCENT_BETWEEN", "YES"),
                    ("FINAL_PENDING", "0"),
                    ("FINAL_ACTIVE", "0"),
                    ("EOIMODE", "DROP_DEACTIVATE"),
                    ("GIC_REINIT", "OFF"),
                    ("RETURN", "IDLE"),
                    ("IRQ", "MASKED"),
                    ("TIMER", "OFF"),
                    ("GENERIC_SMP", "OFF"),
                    ("MIGRATION", "OFF"),
                    ("TLB_SHOOTDOWN", "OFF"),
                    ("CPU2_3", "OFF"),
                    ("SCOPE", "CPU1_TWO_REMOTE_WAKES_ONLY"),
                ] {
                    require_field(&fields, key, expected, line_number, &mut errors);
                }
                boot_base = parse_decimal(&fields, "BASE_TICKS", line_number, &mut errors);
                boot_ticks = parse_decimal(&fields, "TICKS", line_number, &mut errors);
            }
            _ => unreachable!(),
        }
    }

    for marker in MARKERS {
        let observed = positions.get(marker).expect("known marker").len();
        if observed != 1 {
            errors.push(format!(
                "{marker} must occur exactly once, observed {observed}"
            ));
        }
    }
    let ordered = MARKERS
        .iter()
        .filter_map(|marker| positions.get(marker)?.first().copied())
        .collect::<Vec<_>>();
    if ordered.len() == MARKERS.len() && !ordered.windows(2).all(|pair| pair[0] < pair[1]) {
        errors.push(format!("G8e marker order mismatch: {ordered:?}"));
    }
    if let (Some(boot8d), Some(g8e0)) = (boot8d_line, ordered.first().copied()) {
        if boot8d >= g8e0 {
            errors.push(format!(
                "BOOT8D must precede G8E0: BOOT8D@{boot8d}, G8E0@{g8e0}"
            ));
        }
    }
    if let (Some(g8d), Some(start)) = (&g8d, start_ticks) {
        if start < g8d.boot8d_ticks || start - g8d.boot8d_ticks > MAX_G8D_HANDOFF_TICKS {
            errors.push(format!(
                "G8E0 START_TICKS must be within {MAX_G8D_HANDOFF_TICKS} ticks of BOOT8D: boot8d={}, start={start}",
                g8d.boot8d_ticks,
            ));
        }
        let observed_gap = start.saturating_sub(g8d.task_tick);
        if gap_ticks != Some(observed_gap) {
            errors.push(format!(
                "G8E0 GAP_TICKS must equal START_TICKS minus G8d round-1 task tick: task={}, start={start}, gap={gap_ticks:?}",
                g8d.task_tick,
            ));
        }
        if observed_gap < MIN_INTER_WAKE_TICKS || observed_gap > MAX_INTER_WAKE_TICKS {
            errors.push(format!(
                "G8E0 inter-wake gap must be in {MIN_INTER_WAKE_TICKS}..={MAX_INTER_WAKE_TICKS}: {observed_gap}"
            ));
        }
    }
    if boot_base != start_ticks {
        errors.push(format!(
            "BOOT8E BASE_TICKS must equal G8E0 START_TICKS: start={start_ticks:?}, base={boot_base:?}"
        ));
    }
    if let (Some(start), Some(send)) = (start_ticks, send_tick) {
        if send < start || send - start > MAX_STAGE_WAIT_TICKS {
            errors.push(format!(
                "G8E0 SEND_TICK must be within the bounded stage window: start={start}, send={send}"
            ));
        }
    }
    if let (Some(send), Some(irq)) = (send_tick, irq_tick) {
        if irq < send || irq - send > MAX_STAGE_WAIT_TICKS {
            errors.push(format!(
                "G8E1 TICK must follow SEND_TICK within the bounded stage window: send={send}, irq={irq}"
            ));
        }
    }
    if let (Some(send), Some(irq), Some(task)) = (send_tick, irq_tick, task_tick) {
        if task < irq || task < send || task - send > MAX_STAGE_WAIT_TICKS {
            errors.push(format!(
                "G8E2 TICK must follow G8E1 within the bounded stage window: send={send}, irq={irq}, task={task}"
            ));
        }
    }
    if let (Some(base), Some(end)) = (boot_base, boot_ticks) {
        if end < base || end - base < MIN_PRIMARY_PROOF_TICKS {
            errors.push(format!(
                "BOOT8E timer delta must be at least {MIN_PRIMARY_PROOF_TICKS}: base={base}, end={end}"
            ));
        }
        if task_tick.is_some_and(|tick| end < tick) {
            errors.push(format!(
                "BOOT8E TICKS must not precede G8E2: G8E2={task_tick:?}, BOOT8E={end}"
            ));
        }
    }
    if task_sp.is_some_and(|sp| sp == 0 || sp & 0xf != 0) {
        errors.push(format!(
            "G8E2 STACK_SP must be non-zero and 16-byte aligned: {task_sp:?}"
        ));
    }
    if ack_raw != eoi_raw {
        errors.push(format!(
            "G8E1 raw EOI must exactly equal raw acknowledge: ack={ack_raw:?}, eoi={eoi_raw:?}"
        ));
    }
    if let Some(raw) = ack_raw {
        if raw & 0x3ff != SGI_INTID as u64 {
            errors.push(format!(
                "G8E1 ACK_RAW INTID mismatch: expected {SGI_INTID}, raw=0x{raw:x}"
            ));
        }
        if (raw >> 10) & 0x7 != SOURCE_CPU_INDEX {
            errors.push(format!(
                "G8E1 ACK_RAW source mismatch: expected {SOURCE_CPU_INDEX}, raw=0x{raw:x}"
            ));
        }
    }
    if ordered.len() == MARKERS.len() {
        let task_line = ordered[2];
        let boot_line = ordered[3];
        let correlated = sec_samples.iter().any(|(line, ticks)| {
            *line > task_line
                && *line < boot_line
                && task_tick.is_some_and(|start| *ticks >= start)
                && boot_ticks.is_some_and(|end| *ticks <= end)
        });
        if !correlated {
            errors.push("BOOT8E requires a CPU0 SEC timer sample after G8E2".to_string());
        }
    }
    if TARGET_MPIDR != 0x100
        || TARGET_CPU_INDEX != 1
        || TARGET_LIST != 0x02
        || SGI_INTID != 1
        || SGIR_COMMAND != 0x0002_0001
        || PRIOR_ROUNDS != 1
        || NEW_ROUNDS != 1
        || TOTAL_ROUNDS != 2
        || EXPECTED_NEW_SENDS != 1
        || EXPECTED_NEW_DELIVERIES != 1
        || EXPECTED_NEW_ACKS != 1
        || EXPECTED_NEW_EOIS != 1
        || EXPECTED_NEW_RESCHEDULES != 1
        || EXPECTED_NEW_WAKEUPS != 1
        || EXPECTED_NEW_TASK_RUNS != 1
        || EXPECTED_TOTAL_SENDS != 2
        || EXPECTED_TOTAL_DELIVERIES != 2
        || EXPECTED_TOTAL_ACKS != 2
        || EXPECTED_TOTAL_EOIS != 2
        || EXPECTED_TOTAL_RESCHEDULES != 2
        || EXPECTED_TOTAL_WAKEUPS != 2
        || EXPECTED_TOTAL_TASK_RUNS != 2
        || TASK_PROGRESS != 3
        || TASK_STACK_BYTES != 64 * 1024
    {
        errors.push("compiled G8e contract constants are inconsistent".to_string());
    }

    if errors.is_empty() {
        Ok(G8eEvidence {
            g8d: g8d.expect("validated G8d prerequisite"),
            start_ticks: start_ticks.expect("validated G8e start ticks"),
            send_tick: send_tick.expect("validated G8e send tick"),
            irq_tick: irq_tick.expect("validated G8e IRQ tick"),
            task_tick: task_tick.expect("validated G8e task tick"),
            boot8e_ticks: boot_ticks.expect("validated BOOT8E ticks"),
            inter_wake_ticks: gap_ticks.expect("validated inter-wake gap"),
            task_sp: task_sp.expect("validated G8e task SP"),
            ack_raw: ack_raw.expect("validated G8e acknowledge"),
        })
    } else {
        Err(ValidationError { messages: errors })
    }
}

#[test]
fn order_handoff_gap_and_cpu0_timer_correlation_are_bounded() {
    let duplicate = format!("{}{}", pass(), G8E_SUFFIX);
    assert!(has(&failures(duplicate), "must occur exactly once"));

    let first = G8E_SUFFIX.lines().next().expect("G8E0");
    let second = G8E_SUFFIX.lines().nth(1).expect("G8E1");
    let reordered = replace_suffix(
        &format!("{first}\n{second}\n"),
        &format!("{second}\n{first}\n"),
    );
    assert!(has(&failures(reordered), "marker order mismatch"));

    assert!(has(
        &failures(replace_suffix("START_TICKS=1000", "START_TICKS=1006")),
        "within 5 ticks of BOOT8D"
    ));
    assert!(has(
        &failures(replace_suffix("GAP_TICKS=99", "GAP_TICKS=98")),
        "must equal START_TICKS minus"
    ));
    assert!(has(
        &failures(replace_suffix("SEND_TICK=1000", "SEND_TICK=1101")),
        "bounded stage window"
    ));
    assert!(has(
        &failures(replace_suffix("TICK=1001", "TICK=1101")),
        "bounded stage window"
    ));
    assert!(has(
        &failures(replace_suffix(
            "BASE_TICKS=1000 TICKS=1100",
            "BASE_TICKS=1000 TICKS=1009"
        )),
        "timer delta must be at least"
    ));
    assert!(has(
        &failures(replace_suffix(
            "[SEC  11] ticks=1100 drift=+0 µs (+6 count)\n",
            ""
        )),
        "requires a CPU0 SEC timer sample"
    ));
}

  {
    id: "rpi5-g8f-runtime-layout-image-staged",
    date: "2026-08-21",
    sequence: 73,
    status: "verified",
    title: "G8f runtime yarış audit'iyle GO; layout ve BOOT8F image staged",
    summary:
      "Sıra 72'nin intentional RED source sözleşmesi gerçek RPi5-only G8f runtime ve iki G8e→G8f handoff seam'iyle tamamlandı. Bağımsız audit ilk runtime taslağında exact deadline anındaki geçerli ACK'in eski stage örneği yüzünden yanlış timeout/rejection'a düşebildiği sınır yarışını kesin STOP olarak buldu; invalid ACK kabulü söz konusu değildi. ACK wait tick-first olacak, `ticks > deadline` kontrolü stage kabulünden önce çalışacak ve deadline anında son fresh Acquire fırsatı verilecek şekilde düzeltildi; ACK kabulünde yeniden örneklenen tick de deadline'a karşı doğrulandı ve audit GO verdi. G8f source 7/7, UART 9/9; immutable G8e source 10/10, UART 9/9 geçti. G8a–G8f unique host toplamı 100/100, image zincirindeki unique host toplamı 132/132 ve G8e regresyon tekrarı dahil gerçek test yürütümü 151/151 oldu. Pre-MMU, G7c, G7d ve production ELF üzerindeki G8–G8f altı layout gate'i PASS verdi. Exact 279.936 bayt BOOT8F image ve üç dosyalı manifest üretildi; bu host/layout/image staged doğrulamasıdır, microSD veya fiziksel BOOT8F PASS değildir.",
    evidence: [
      "G8f runtime `kernel/src/rpi5_g8f.rs` exact 22.747 B / 0630390806ec8b61449ebd9e43ce537995647b2ff2a5e610edb32bbea742a621; G8e primary BOOT8E sonrasında CPU0 handoff'u, parked CPU1 yolu release poll ve secondary handoff'u exact bounded seam olarak taşır.",
      "Bağımsız machine/source audit ilk draftta exact-deadline valid-ACK false-timeout/rejection yarışını STOP buldu; düzeltme tick-first örnekleme, strict `ticks > deadline`, bundan sonra fresh `STAGE.load(Ordering::Acquire)` ve kabul anında yeniden örneklenen `ack_tick <= deadline` sırasını kurdu; final audit GO verdi.",
      "Hardened G8f source TDD exact 14.618 B / da693d729214e72d9c608e467f1c0b65fc302573b9f325ab55cb102fa88b1ba5; inclusive deadline valid-ACK false-timeout/rejection adversarial source sırasını fail-closed dondurur.",
      "Targeted host G8f source 7/7 + UART 9/9 ve G8e source 10/10 + UART 9/9 = 35/35 PASS verdi.",
      "G8a–G8f unique host testleri 100/100; image prerequisite zincirindeki bütün unique G7c–G8f host testleri 132/132; G8f hedefindeki kasıtlı G8e regresyon tekrarı dahil gerçek yürütüm 151/151 PASS oldu.",
      "Pre-MMU atomics, G7c trusted ELF, G7d frame ve production AArch64 G8/G8b/G8c/G8d/G8e/G8f layout kapıları PASS; G8–G8f layout toplamı 6/6'dır.",
      "G8e layout gate exact 24.610 B / 242c91b3ab90e27bc8c984ba6773e5fb83bdfe62efdbe470d4ba616c2eaa58c5; G8f layout gate exact 28.547 B / fc5f6d49e7ff72128e631f6c70d20c4f92777f64c981ce9ae1eefb1f8bfd2133.",
      "Production RPi5 ELF exact 7.505.752 B / 4cfd92a35dd38a40e5a14c9bc75b1db6e9e8fe09483cff92a60cc33c348f0291.",
      "Raw RPi5 image exact 279.936 B / 316be86f1d11c3522b550abd90c04beb77f0d12f01625e8e6d3bc014672c0f21; G8F0/G8F1/BOOT8F package marker sayıları 1/1/1'dir.",
      "Paket DTB exact 78.703 B / 40a2fbe9c29e8b9a4912cf726a943068defb779fc052ec38e457a79c58abca00 ve config exact 501 B / 1248275cdc6f6ce951ce0ff2183471d194c5b9bb58c3dc3f66efa9156f91d76b.",
      "SHA256SUMS exact 248 B / 73874fad8eaebe46b4ac20fe25b579ef32545a1457358178be2bf0045fa8769c; image/DTB/config manifest doğrulaması 3/3 PASS verdi.",
      "G8f staged proof exact 14.302 B / 93d327e8cdb73a09e22b907d259fe1943d885d7f14e7deb915e1d770d368c8a4; mevcut fiziksel G8e temelini immutable tutup G8f'i host/layout/image-staged olarak sınırlar.",
    ],
    terminalSessionsNote:
      "Oturumlar gerçek audit, hedefli test ve final image üretim çıktılarının seçilmiş satırlarını taşır. Başarılı build çıktısı fiziksel UART veya microSD kanıtı değildir.",
    terminalSessions: [
      {
        id: "g8f-boundary-race-audit-go",
        title:
          "Exact deadline valid-ACK false-timeout STOP ve tick-first GO düzeltmesi",
        commandLines: [
          "inspect G8f ACK wait machine/source order at the exact deadline boundary",
          "rg -n 'let ticks|ticks > deadline|STAGE.load\\(Ordering::Acquire\\)|ack_tick <= deadline' kernel/src/rpi5_g8f.rs simulation/tests/rpi5_g8f_source.rs",
          "cargo test -p aselsan_microkernel_simulation --test rpi5_g8e_source --test rpi5_g8e_uart --test rpi5_g8f_source --test rpi5_g8f_uart",
        ],
        outputLines: [
          "first independent audit=STOP · exact-deadline valid-ACK false-timeout/rejection race",
          "fix=tick-first · strict ticks > deadline · final fresh Acquire · ack_tick <= deadline",
          "final independent audit=GO",
          "G8e source/UART=10/10+9/9 · G8f source/UART=7/7+9/9 · total=35/35 PASS",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "g8f-host-layout-image-final",
        title: "Host toplamları, production layout ve final image zinciri",
        commandLines: [
          "make verify-rpi5-g8f-host",
          "make verify-rpi5-g8-host verify-rpi5-g8b-host verify-rpi5-g8c-host verify-rpi5-g8d-host verify-rpi5-g8e-host",
          "make image-rpi5",
        ],
        outputLines: [
          "G8f target=35/35 PASS · G8a–G8f unique=100/100 PASS",
          "all unique image host=132/132 · actual executions with G8e regression repeat=151/151",
          "pre-MMU/G7c/G7d=PASS · G8/G8b/G8c/G8d/G8e/G8f layout=6/6 PASS",
          "make image-rpi5 exit=0 · package manifest=3/3 OK",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8f-package-hash-freeze",
        title: "ELF, BOOT8F image ve üçlü paket manifesti",
        commandLines: [
          "wc -c target/rpi5/aarch64-unknown-none/debug/aselsan_kernel build/rpi5/{aselsanos-rpi5.img,bcm2712-rpi-5-b.dtb,config.txt,SHA256SUMS}",
          "shasum -a 256 target/rpi5/aarch64-unknown-none/debug/aselsan_kernel build/rpi5/{aselsanos-rpi5.img,bcm2712-rpi-5-b.dtb,config.txt,SHA256SUMS}",
          "count G8F0/G8F1/BOOT8F strings in packaged raw image",
        ],
        outputLines: [
          "ELF=7505752 B · 4cfd92a35dd38a40e5a14c9bc75b1db6e9e8fe09483cff92a60cc33c348f0291",
          "image=279936 B · 316be86f1d11c3522b550abd90c04beb77f0d12f01625e8e6d3bc014672c0f21",
          "DTB=78703 B · 40a2fbe9…abca00 · config=501 B · 1248275c…1d76b",
          "SHA256SUMS=248 B · 73874fad…69c · G8F0/G8F1/BOOT8F=1/1/1",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    limitations: [
      "Bu kayıt host/source/parser, production machine-code layout ve image/package staged doğrulamasıdır; yeni microSD yazımı, UART10 capture veya fiziksel G8F0/G8F1/BOOT8F boot kanıtı yoktur.",
      "Üç-board/QEMU tam matrisi, web birleşik matrisi ve temiz-workspace reproducibility Sıra 73 anında hâlâ ayrı ve devam eden kapılardır; bu kayıt onları PASS saymaz.",
      "Generic SMP, per-CPU periodic timer, local preemption/runqueue, migration, ASID/TLBI shootdown, CPU2/CPU3, soak ve hotplug kapalıdır.",
      "Website yayını yalnız canonical custom domain üzerinden doğrulanır; bu ortamda reset veren pages.dev direct smoke için başarı iddia edilmez.",
      "Wrangler yayını dirty/untracked workspace'ten ve stale 47d22c9 source etiketiyle yapılır; canlı artifact hash'i doğrulansa da Git-provider provenance kurulmuş sayılmaz.",
    ],
  },