G8e runtime host-green oldu; lost-wakeup, deadline ve overflow audit açıkları düzeltildi

pub fn verify_transcript(input: &[u8]) -> Result<G8dEvidence, ValidationError> {
    let mut errors = Vec::new();
    let g8c = match verify_g8c(input) {
        Ok(evidence) => Some(evidence),
        Err(error) => {
            errors.extend(
                error
                    .messages()
                    .iter()
                    .map(|message| format!("G8c 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 boot8c_line = None;
    let mut start_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 pmr = None;
    let mut bpr = 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/BOOT8C") {
            boot8c_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/G8DERR")
            || 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/G8D") || line.starts_with("ASELSAN/BOOT8D"))
            && known.is_none()
        {
            errors.push(format!(
                "line {line_number}: unknown G8d marker present: {line:?}"
            ));
        }
        let Some(marker) = known else {
            continue;
        };
        positions
            .get_mut(marker)
            .expect("known G8d marker")
            .push(line_number);
        let fields = match parse_fields(line, marker) {
            Ok(fields) => fields,
            Err(message) => {
                errors.push(format!("line {line_number}: {message}"));
                continue;
            }
        };

        match marker {
            "ASELSAN/G8D0" => {
                require_exact_keys(
                    &fields,
                    &[
                        "CPU",
                        "SOURCE",
                        "TARGET",
                        "MPIDR",
                        "SGI",
                        "TARGET_LIST",
                        "SENDS",
                        "GICD",
                        "GICC",
                        "SGI_ENABLED",
                        "PMR",
                        "BPR",
                        "POLICY",
                        "MIGRATION",
                        "TLB_SHOOTDOWN",
                        "CPU2_3",
                        "START_TICKS",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("CPU", "0"),
                    ("SOURCE", "CPU0"),
                    ("TARGET", "CPU1"),
                    ("MPIDR", "0x100"),
                    ("SGI", "1"),
                    ("TARGET_LIST", "0x02"),
                    ("SENDS", "1"),
                    ("GICD", "ON"),
                    ("GICC", "ON"),
                    ("SGI_ENABLED", "1"),
                    ("POLICY", "RESCHED_ONLY"),
                    ("MIGRATION", "OFF"),
                    ("TLB_SHOOTDOWN", "OFF"),
                    ("CPU2_3", "OFF"),
                ] {
                    require_field(&fields, key, expected, line_number, &mut errors);
                }
                pmr = parse_hex(&fields, "PMR", line_number, &mut errors);
                bpr = parse_decimal(&fields, "BPR", line_number, &mut errors);
                start_ticks = parse_decimal(&fields, "START_TICKS", line_number, &mut errors);
            }
            "ASELSAN/G8D1" => {
                require_exact_keys(
                    &fields,
                    &[
                        "CPU",
                        "MPIDR",
                        "INTID",
                        "SOURCE_CPU",
                        "DELIVERIES",
                        "ACKS",
                        "EOIS",
                        "ACK_RAW",
                        "EOI_RAW",
                        "RESCHED",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "TICK",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("CPU", "1"),
                    ("MPIDR", "0x100"),
                    ("INTID", "1"),
                    ("SOURCE_CPU", "0"),
                    ("DELIVERIES", "1"),
                    ("ACKS", "1"),
                    ("EOIS", "1"),
                    ("RESCHED", "1"),
                    ("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/G8D2" => {
                require_exact_keys(
                    &fields,
                    &[
                        "CPU",
                        "MPIDR",
                        "TASK",
                        "WAKEUPS",
                        "RUNS",
                        "PROGRESS",
                        "STACK",
                        "STACK_SP",
                        "CANARY",
                        "STACK_RESTORE",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "EL",
                        "TPIDR",
                        "TICK",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("CPU", "1"),
                    ("MPIDR", "0x100"),
                    ("TASK", "PINNED0"),
                    ("WAKEUPS", "1"),
                    ("RUNS", "1"),
                    ("PROGRESS", "3"),
                    ("STACK", "REUSED_STATIC64K"),
                    ("CANARY", "OK"),
                    ("STACK_RESTORE", "OK"),
                    ("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/BOOT8D" => {
                require_exact_keys(
                    &fields,
                    &[
                        "IPI",
                        "CPU0_TO_CPU1",
                        "SENDS",
                        "DELIVERIES",
                        "ACKS",
                        "EOIS",
                        "RESCHED",
                        "TASK_WAKE",
                        "TASK_RUNS",
                        "TASK_PROGRESS",
                        "STACK",
                        "RETURN",
                        "IRQ",
                        "TIMER",
                        "MIGRATION",
                        "TLB_SHOOTDOWN",
                        "CPU2_3",
                        "SCOPE",
                        "BASE_TICKS",
                        "TICKS",
                    ],
                    line_number,
                    &mut errors,
                );
                for (key, expected) in [
                    ("IPI", "SGI1"),
                    ("CPU0_TO_CPU1", "1"),
                    ("SENDS", "1"),
                    ("DELIVERIES", "1"),
                    ("ACKS", "1"),
                    ("EOIS", "1"),
                    ("RESCHED", "1"),
                    ("TASK_WAKE", "1"),
                    ("TASK_RUNS", "1"),
                    ("TASK_PROGRESS", "3"),
                    ("STACK", "REUSED_STATIC64K"),
                    ("RETURN", "IDLE"),
                    ("IRQ", "MASKED"),
                    ("TIMER", "OFF"),
                    ("MIGRATION", "OFF"),
                    ("TLB_SHOOTDOWN", "OFF"),
                    ("CPU2_3", "OFF"),
                    ("SCOPE", "CPU1_RESCHED_WAKE_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!("G8d marker order mismatch: {ordered:?}"));
    }
    if let (Some(boot8c), Some(g8d0)) = (boot8c_line, ordered.first().copied()) {
        if boot8c >= g8d0 {
            errors.push(format!(
                "BOOT8C must precede G8D0: BOOT8C@{boot8c}, G8D0@{g8d0}"
            ));
        }
    }
    if let (Some(g8c), Some(start)) = (&g8c, start_ticks) {
        if start < g8c.boot8c_ticks || start - g8c.boot8c_ticks > MAX_G8C_HANDOFF_TICKS {
            errors.push(format!(
                "G8D0 START_TICKS must be within {MAX_G8C_HANDOFF_TICKS} ticks of BOOT8C: boot8c={}, start={start}",
                g8c.boot8c_ticks,
            ));
        }
    }
    if boot_base != start_ticks {
        errors.push(format!(
            "BOOT8D BASE_TICKS must equal G8D0 START_TICKS: start={start_ticks:?}, base={boot_base:?}"
        ));
    }
    if let (Some(start), Some(irq)) = (start_ticks, irq_tick) {
        if irq < start || irq - start > MAX_STAGE_WAIT_TICKS {
            errors.push(format!(
                "G8D1 TICK must be within the bounded stage window: start={start}, irq={irq}"
            ));
        }
    }
    if let (Some(start), Some(irq), Some(task)) = (start_ticks, irq_tick, task_tick) {
        if task < irq || task < start || task - start > MAX_STAGE_WAIT_TICKS {
            errors.push(format!(
                "G8D2 TICK must follow G8D1 within the bounded stage window: start={start}, 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!(
                "BOOT8D 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!(
                "BOOT8D TICKS must not precede G8D2: G8D2={task_tick:?}, BOOT8D={end}"
            ));
        }
    }
    if task_sp.is_some_and(|sp| sp == 0 || sp & 0xf != 0) {
        errors.push(format!(
            "G8D2 STACK_SP must be non-zero and 16-byte aligned: {task_sp:?}"
        ));
    }
    if ack_raw != eoi_raw {
        errors.push(format!(
            "G8D1 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!(
                "G8D1 ACK_RAW INTID mismatch: expected {SGI_INTID}, raw=0x{raw:x}"
            ));
        }
        if (raw >> 10) & 0x7 != SOURCE_CPU_INDEX {
            errors.push(format!(
                "G8D1 ACK_RAW source mismatch: expected {SOURCE_CPU_INDEX}, raw=0x{raw:x}"
            ));
        }
    }
    if pmr.is_some_and(|value| value <= 0x80 || value > 0xff) {
        errors.push(format!(
            "G8D0 PMR must pass priority 0x80 and fit one byte: {pmr:?}"
        ));
    }
    if bpr.is_some_and(|value| value > 7) {
        errors.push(format!("G8D0 BPR must be in 0..=7: {bpr:?}"));
    }
    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("BOOT8D requires a CPU0 SEC timer sample after G8D2".to_string());
        }
    }
    if TARGET_MPIDR != 0x100
        || TARGET_CPU_INDEX != 1
        || TARGET_LIST != 0x02
        || SGI_INTID != 1
        || EXPECTED_SENDS != 1
        || EXPECTED_DELIVERIES != 1
        || EXPECTED_ACKS != 1
        || EXPECTED_EOIS != 1
        || EXPECTED_RESCHEDULES != 1
        || EXPECTED_WAKEUPS != 1
        || EXPECTED_TASK_RUNS != 1
        || TASK_PROGRESS != 3
        || TASK_STACK_BYTES != 64 * 1024
    {
        errors.push("compiled G8d contract constants are inconsistent".to_string());
    }

    if errors.is_empty() {
        Ok(G8dEvidence {
            g8c: g8c.expect("validated G8c prerequisite"),
            start_ticks: start_ticks.expect("validated G8d start ticks"),
            irq_tick: irq_tick.expect("validated G8d IRQ tick"),
            task_tick: task_tick.expect("validated G8d task tick"),
            boot8d_ticks: boot_ticks.expect("validated BOOT8D ticks"),
            task_sp: task_sp.expect("validated G8d task SP"),
            ack_raw: ack_raw.expect("validated G8d acknowledge"),
        })
    } else {
        Err(ValidationError { messages: errors })
    }
}

#[test]
fn errors_unknown_markers_and_broken_g8c_prerequisite_are_rejected() {
    let with_error = replace_suffix(
        "ASELSAN/G8D1 CPU=1",
        "ASELSAN/G8DERR CODE=IRQ_SOURCE EXPECTED=0x0 ACTUAL=0x1\nASELSAN/G8D1 CPU=1",
    );
    assert!(has(&failures(with_error), "failure evidence present"));

    let unknown = replace_suffix(
        "ASELSAN/G8D1 CPU=1",
        "ASELSAN/G8DX CPU=1\nASELSAN/G8D1 CPU=1",
    );
    assert!(has(&failures(unknown), "unknown G8d marker"));

    let broken = pass().replace("CPU1_TASK=1", "CPU1_TASK=2");
    assert!(has(&failures(broken), "G8c prerequisite"));
}

  {
    id: "rpi5-g8e-runtime-host-green-audit-fixed",
    date: "2026-08-21",
    sequence: 63,
    status: "fixed",
    title:
      "G8e runtime host-green oldu; lost-wakeup, deadline ve overflow audit açıkları düzeltildi",
    summary:
      "Sıra 62'de kasıtlı RED bırakılan G8e runtime artık G8d'nin immutable round-1 prerequisite'inden CPU0 ve CPU1 handoff'larıyla başlıyor; read-only GIC pending/active/EOImode snapshot'ını ve G8e→G8d→G8b interceptor sırasını koruyarak aynı SGI1 kanalına yalnız bir yeni gönderim ekliyor. Hedefli güncel source/UART zinciri G8d 11+7 ve G8e 10+9 olmak üzere 37/37 PASS, board-rpi5 cargo check PASS verdi. Audit üç fail-closed kusuru bulup düzeltti: stage-load→WFI lost-wakeup penceresi WFE+SEV'e çevrildi, beklenen stage kabulünden önce tick örneklenerek late publication reddedildi ve bütün zaman farkları checked_sub ile taşma/panic üretmeyecek hale geldi. Rebuilt ELF üzerinde sınırlı audit panic edge olmadığını, primary'de tek sender BL, secondary'de WFE-only bekleme ve CPU1'de FP/SIMD yokluğunu gözledi. Bu kayıt henüz nihai makine-kodu layout/image kabulü değildir.",
    evidence: [
      "kernel/src/rpi5_g8e.rs runtime'ı main.rs içinde yalnız RPi5 yoluna bağlandı; G8d CPU0 final yolu rpi5_g8e_primary_run'a, CPU1 parked yolu release sonrası rpi5_g8e_secondary_run'a exact handoff verir.",
      "G8d fiziksel round-1 sayaçları ve BOOT8D prerequisite'i immutable kalır; G8e primary canonical rpi5_g8d_send_sgi(SGI1, TARGET_LIST=0x02) yolunu yalnız bir kez çağırır ve aggregate toplamları exact 2'ye çıkarır.",
      "rpi5_g8e_read_secondary_sgi_state yalnız pending, active ve Non-secure EOImodeNS durumunu okur; clear, DIR veya GIC re-init yapmaz. IRQ dispatcher sırası G8e→G8d→G8b olarak source testinde donduruldu.",
      "Güncel hedefli matris rpi5_g8d_source 11/11, rpi5_g8e_source 10/10, rpi5_g8d_uart 7/7 ve rpi5_g8e_uart 9/9 olmak üzere 37/37 PASS verdi.",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5 exit 0 verdi; warning'ler fail'e yükseltilmedi.",
      "Lost-wakeup audit'i stage-load ile WFI arasındaki event kaçırma penceresini buldu. G8d/G8e bounded CPU1 stage wait'leri WFE kullanıyor; handler/state yayınları SEV veriyor ve source testleri bu bounded secondary dilimlerinde WFI'yi yasaklıyor.",
      "Deadline kabul sırası düzeltildi: current tick beklenen stage görüldükten sonra değil, stage kabulünden önce örnekleniyor ve ticks<=deadline koşulu sağlanmadan başarı verilmiyor.",
      "Timing subtraction panic kenarları checked_sub ile fail-closed hale getirildi; G8e source testi boot handoff, inter-wake ve send/IRQ/task delta hesaplarının panic üretmemesini doğruluyor.",
      "Rebuilt production RPi5 ELF'in sınırlı objdump audit'inde primary/secondary/task/handler gövdelerinde panic edge=0, primary canonical sender direct BL=1, bounded secondary wait WFE-only ve CPU1 FP/SIMD=0 gözlendi.",
      "G8e UART parser'ı exact marker field order ve canonical `[SEC  11] ticks=1100 drift=+0 µs (+6 count)` şemasını zorunlu kılıyor; malformed order/us/drift/tick/count varyantlarının adversarial testiyle UART toplamı 9/9 oldu.",
      "Staged proof durumu `RUNTIME IMPLEMENTED — source/host PASS; layout, paket ve fiziksel BOOT8E henüz yok` olarak düzeltildi; kullanılmayan ayrı SGIR state slotu kaldırıldı.",
    ],
    terminalSessionsNote:
      "Bu oturumlar runtime kaynak entegrasyonu, host testleri, board cargo check ve sınırlı ELF audit'idir. Objdump bulguları sonraki nihai layout gate'in yerine geçmez; image/paket/fiziksel iddiası yoktur.",
    terminalSessions: [
      {
        id: "g8e-runtime-targeted-host-matrix",
        title: "G8d prerequisite ve G8e runtime güncel source/UART matrisi",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test rpi5_g8d_source --test rpi5_g8e_source --test rpi5_g8d_uart --test rpi5_g8e_uart",
        ],
        outputLines: [
          "rpi5_g8d_source=11/11 PASS",
          "rpi5_g8e_source=10/10 PASS",
          "rpi5_g8d_uart=7/7 PASS",
          "rpi5_g8e_uart=9/9 PASS",
          "targeted total=37/37 PASS · fail=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8e-runtime-board-rpi5-check",
        title: "Production non-SMP board-rpi5 compile sınırı",
        commandLines: [
          "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
        ],
        outputLines: [
          "aselsan_kernel board-rpi5 cargo_check_exit=0",
          "G8e runtime module resolved and compiled",
          "warnings emitted=166 · warnings not promoted to errors",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "g8e-runtime-race-deadline-overflow-audit",
        title: "Lost-wakeup, late-stage ve panic-edge düzeltme audit'i",
        commandLines: [
          "bounded G8d/G8e stage-wait and publication source audit",
          "targeted source tests for WFE/SEV, pre-accept tick and checked_sub",
        ],
        outputLines: [
          "stage-load -> WFI lost-wakeup window found and removed",
          "bounded secondary waits=WFE · publications=SEV · bounded WFI forbidden",
          "tick sampled before expected-stage acceptance · ticks<=deadline required",
          "timing subtraction=checked_sub · overflow/panic edge rejected",
          "source regression tests=PASS",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "g8e-runtime-bounded-elf-audit",
        title: "Rebuilt ELF üzerinde sınırlı panic/send/wait/FP audit'i",
        commandLines: [
          "llvm-objdump bounded G8e primary/secondary/task/handler bodies",
          "direct-call, wait instruction and FP/SIMD audit",
        ],
        outputLines: [
          "panic edges primary/secondary/task/handler=0/0/0/0",
          "G8e primary canonical sender direct BL=1",
          "bounded secondary wait=WFE-only",
          "CPU1 FP/SIMD instructions=0",
          "result=host audit PASS · final layout gate not claimed",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "g8e-runtime-parser-schema-audit",
        title: "Exact field order ve canonical SEC parser sertleştirmesi",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test rpi5_g8e_uart",
          "adversarial field-order and SEC schema mutations",
        ],
        outputLines: [
          "G8e UART=9/9 PASS",
          "exact marker field order required",
          "canonical SEC schema: [SEC  11] ticks=1100 drift=+0 µs (+6 count)",
          "malformed us/drift/tick/count/order variants rejected",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    limitations: [
      "Bu kayıt runtime source/host-green ve sınırlı audit kanıtıdır; nihai G8e makine-kodu layout gate'i ve image kabulü henüz tamamlanmadı.",
      "Tam workspace/üç-board/QEMU matrisi, reproducibility, kaynak/toolchain manifesti ve staged package kapıları bekliyor.",
      "microSD yazımı, UART capture ve fiziksel BOOT8E yapılmadı; sentetik UART testi fiziksel kanıt değildir.",
      "Generic SMP, migration, TLB shootdown, CPU2/CPU3, hotplug ve EL0-on-CPU1 kapsam dışıdır.",
      "Pi kapalıdır; doğrulanmış G8d kartı güçsüz Pi içinde kalır ve rollback evidence değiştirilmemiştir.",
    ],
  },