S372 · EL0 IPC reply production writer guard integration

/// Basit syscall dispatch + handler.
/// x8 = syscall numarası
/// x0..x5 = argümanlar (yazma için: x0=fd, x1=buf, x2=len)
#[no_mangle]
pub extern "C" fn rust_el0_sync_handler(ctx: &mut ExceptionContext) {
    let esr: u64;
    unsafe { core::arch::asm!("mrs {0}, esr_el1", out(reg) esr, options(nomem, nostack)) };

    // The physical RPi5 G7c gate owns only its explicitly armed two-SVC
    // window.  A handled SVC returns through this vector's ordinary
    // RESTORE_CONTEXT + eret path; none of the legacy noreturn user-return or
    // scheduler/task-exit paths are entered.
    #[cfg(feature = "board-rpi5")]
    if crate::rpi5_g7c::try_handle_sync(ctx, esr) {
        return;
    }

    if crate::percpu::current_cpu_id() != 0 {
        // Generic EL0 scheduling is deliberately CPU0-only until K3 provides
        // per-CPU current-task state and migration-safe run queues.
        crate::arch::aarch64::disable_irqs();
        loop {
            unsafe { core::arch::asm!("wfe", options(nomem, nostack)) }
        }
    }

    let ec = (esr >> 26) & 0x3f;

    if !exception_originated_from_el0(ctx) {
        kprintln!("\n[M4] lower-EL sync vector received a privileged-origin frame");
        kprintln!("  ESR_EL1 = 0x{:016x}", esr);
        dump_context(ctx);
        panic!("non-EL0 frame reached lower-EL synchronous handler");
    }
    if !scheduler_tracks_current_el0_task() {
        kprintln!("\n[M4] EL0 frame has no live user task owner");
        dump_context(ctx);
        panic!("cannot contain lower-EL fault without a live user task");
    }

    if ec != 0x15 {
        // M5.5 + Multi-core: Data Abort handling
        if ec == 0x24 {
            let far: u64;
            unsafe { core::arch::asm!("mrs {0}, far_el1", out(reg) far, options(nomem, nostack)) };

            if handle_el0_data_abort(far, ctx) {
                return;
            }

            let task_id = crate::task::current_task_id()
                .expect("live EL0 fault containment requires the tracked task id");
            kprintln!(
                "[EL0-FAULT-CONTAINMENT] task#{} EC=0x{:02x} FAR_EL1=0x{:016x} ACTION=TERMINATE_CURRENT_EL0_TASK",
                task_id,
                ec,
                far,
            );
        }

        kprintln!("\n[M4] EL0 AArch64 Sync Exception (SVC değil)");
        kprintln!(
            "  ESR_EL1 = 0x{:016x}  (EC=0x{:02x} → {})",
            esr,
            ec,
            decode_ec(esr)
        );
        kprintln!("  ELR_EL1 = 0x{:016x}", ctx.elr_el1);
        dump_context(ctx);
        unsafe {
            crate::task::scheduler::terminate_current_task_due_to_fatal_error(
                lower_el_fault_reason(ec),
                Some(&*ctx),
            );
        }
    }

    // No timer-driven context switch may occur while a syscall holds a
    // capability, endpoint or scheduler lock. Every successful syscall return
    // uses ERET with the saved EL0 SPSR, which restores the caller's IRQ mask.
    crate::arch::aarch64::disable_irqs();

    let syscall_num = ctx.gpr[8];
    let user_sp: u64;
    unsafe {
        core::arch::asm!("mrs {0}, sp_el0", out(reg) user_sp, options(nomem, nostack));
    }

    // Syscall işleyip dönüş değerini x0'a yazacağız
    let ret: u64 = match syscall_num {
        SYS_YIELD => {
            // A yield may resume this same kernel continuation only after an
            // arbitrary peer ran. Check the carrier before that switch; the
            // common return boundary below deliberately does not run a
            // second time after the continuation resumes.
            #[cfg(feature = "board-qemu")]
            unsafe {
                if let Err(error) = crate::task::execute_armed_current_runtime_oom_if_target() {
                    panic!("S137 pre-yield EL0 SVC safe boundary failed: {:?}", error);
                }
            }
            static mut YIELD_COUNT: u64 = 0;
            let count = unsafe {
                YIELD_COUNT = YIELD_COUNT.wrapping_add(1);
                YIELD_COUNT
            };

            if count <= 5 || count % 5000 == 0 {
                kprintln!(
                    "[M4.3-DEBUG] User yield #{} | ELR=0x{:x}",
                    count,
                    ctx.elr_el1
                );
            }

            unsafe {
                crate::task::save_user_context_for_yield(ctx, user_sp);
                crate::task::yield_now();
            }
            0
        }

        SYS_WRITE => {
            // fd, buf, len
            let fd = ctx.gpr[0] as usize;
            let user_address = ctx.gpr[1];
            let len = ctx.gpr[2] as usize;

            if fd != 1 {
                kprintln!(
                    "[M4.3] sys_write: sadece fd=1 (stdout) destekleniyor (fd={})",
                    fd
                );
                u64::MAX
            } else {
                let mut fixed = [0u8; crate::user_copy::MAX_USER_COPY];
                match crate::user_copy::copy_from_current_user(&mut fixed, user_address, len) {
                    Ok(written) => {
                        #[cfg(feature = "board-qemu")]
                        crate::task::observe_qemu_el0_ipc_return_marker(
                            crate::task::current_task_id().unwrap_or(0),
                            &fixed[..written],
                        );
                        #[cfg(feature = "board-qemu")]
                        crate::task::observe_qemu_s134_ipc_marker(
                            crate::task::current_task_id().unwrap_or(0),
                            &fixed[..written],
                        );
                        #[cfg(feature = "board-qemu")]
                        crate::task::observe_qemu_s135_ipc_marker(
                            crate::task::current_task_id().unwrap_or(0),
                            &fixed[..written],
                        );
                        for &byte in &fixed[..written] {
                            if byte == b'\n' {
                                crate::kprint!("\r\n");
                            } else {
                                crate::kprint!("{}", byte as char);
                            }
                        }
                        written as u64
                    }
                    Err(error) => {
                        kprintln!(
                            "[K1-COPYIN] sys_write rejected ptr=0x{:x} len={} error={:?}",
                            user_address,
                            len,
                            error
                        );
                        u64::MAX
                    }
                }
            }
        }

        SYS_EXIT => {
            let status = ctx.gpr[0] as i32;
            kprintln!("[M4.3-DEBUG] === SYS_EXIT called from EL0 ===");
            kprintln!(
                "[M4.3-DEBUG] status={}, ELR=0x{:x}, current_task will be marked Dead",
                status,
                ctx.elr_el1
            );
            unsafe {
                crate::task::task_exit();
            }
            // unreachable
        }

        // M6.3 — Gerçek mesaj kopyalama + Reply Cap + basit Call akışı
        crate::ipc::SYS_MINT_ENDPOINT => {
            let badge = ctx.gpr[0];
            let Some(current_id) = crate::task::current_task_id() else {
                ctx.gpr[0] = 0;
                kprintln!("[K2-MINT] endpoint mint rejected: no current task");
                return;
            };
            match crate::ui::mint_endpoint(current_id, badge) {
                Ok(cap) => {
                    ctx.gpr[0] = cap.id;
                    kprintln!(
                        "[M7.2] User task {} yeni endpoint mint etti: id={}",
                        current_id,
                        cap.id
                    );
                }
                Err(error) => {
                    // CapId zero is permanently invalid and is the frozen
                    // scalar failure result for SYS_MINT_ENDPOINT.
                    ctx.gpr[0] = 0;
                    kprintln!(
                        "[K2-MINT] endpoint mint rejected task={}: {}",
                        current_id,
                        error
                    );
                }
            }
            return;
        }

        crate::ipc::SYS_LIST_ENDPOINTS => {
            let current_id = crate::task::current_task_id().unwrap_or(0);
            let endpoints = crate::ui::endpoints_of_task(current_id);

            // M7 audit fix #7: magic 6 yerine explicit const.
            // SYS_LIST_ENDPOINTS dönüş ABI'si: x0=count, x1..x6=ep ids (en fazla 6).
            const MAX_ENDPOINT_LIST_RETURN: usize = 6;
            let count = endpoints.len().min(MAX_ENDPOINT_LIST_RETURN);
            ctx.gpr[0] = count as u64;

            for i in 0..count {
                ctx.gpr[i + 1] = endpoints[i].id;
            }

            kprintln!(
                "[M7.2] Task {} endpoint listesi istendi ({} tane)",
                current_id,
                count
            );
            return;
        }

        SYS_IPC_CALL_TIMEOUT => {
            handle_ipc_call_timeout(ctx, user_sp);
            return;
        }

        SYS_IPC_RECV_TIMEOUT => {
            handle_ipc_recv_timeout(ctx, user_sp);
            return;
        }

        SYS_NOTIFICATION_SIGNAL => {
            handle_notification_signal(ctx);
            return;
        }

        SYS_NOTIFICATION_WAIT_TIMEOUT => {
            handle_notification_wait_timeout(ctx, user_sp);
            return;
        }

        SYS_IPC_CALL => {
            let target_id = ctx.gpr[0];
            let label = ctx.gpr[1];
            let mr0 = ctx.gpr[2];
            let mr1 = ctx.gpr[3];
            let mr2 = ctx.gpr[4];
            let mr3 = ctx.gpr[5];

            let current_id = crate::task::current_task_id().unwrap_or(0);
            kprintln!(
                "[M7] SYS_IPC_CALL task={} → target={}, label=0x{:x}",
                current_id,
                target_id,
                label
            );

            // Resolve only immutable routing metadata; cloning an endpoint
            // would copy its complete rendezvous state and is never authority.
            let Some(target_is_reply) = crate::ui::capability::ENDPOINT_REGISTRY
                .lock()
                .iter()
                .find(|endpoint| endpoint.id == target_id)
                .map(|endpoint| endpoint.is_reply_cap)
            else {
                set_ipc_error(ctx, IpcError::InvalidCapability);
                return;
            };

            if target_is_reply {
                // S143 production broker commits are derived only from the
                // explicit SYS_IPC_REPLY ABI. The legacy CALL-to-reply alias
                // must not consume an armed one-shot authority behind the
                // bridge's preflight/commit boundary.
                if crate::mm::runtime_oom_reply_cap_is_bound(target_id) {
                    kprintln!(
                        "[K1-MEM2-REPLY-BRIDGE] CALL_ALIAS_REJECTED reply_cap={} task={}",
                        target_id,
                        current_id
                    );
                    set_ipc_error(ctx, IpcError::InvalidCapability);
                    return;
                }
                let reply_message = crate::ui::capability::IpcMessage {
                    label,
                    badge: current_id,
                    data: [mr0, mr1, mr2, mr3],
                };
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                let s375_irq_guard = crate::arch::aarch64::IrqGuard::new();
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                let s375_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s375_el0_ipc_call_reply_alias_writer_guard_integration::acquire_s375_production_scheduler_writer_access()
                    .unwrap_or_else(|error| {
                        panic!(
                            "S375 EL0 IPC-call reply-alias scheduler writer guard failed closed: {:?}",
                            error
                        )
                    });
                let result = unsafe {
                    let scheduler =
                        &mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER);
                    scheduler.ipc_reply_commit(target_id, reply_message)
                };
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                drop(s375_writer_access);
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                drop(s375_irq_guard);
                set_ipc_error(ctx, result);
                return;
            }

            // A raw endpoint id is never EL0 authority. Kernel-shared and
            // task-owned endpoints alike require a live CNode entry.
            let endpoint_cap = crate::task::current_task_cnode()
                .and_then(|cnode| cnode.lookup_capability_by_id(target_id).copied())
                .filter(|capability| {
                    capability.kind == crate::ui::capability::CapabilityKind::Endpoint
                });
            let has_cap = endpoint_cap.is_some();

            if !has_cap {
                kprintln!(
                    "[M6.4] CALL REJECTED task={} target={} (owner mismatch / no cap)",
                    current_id,
                    target_id
                );
                set_ipc_error(ctx, IpcError::InvalidCapability);
                return;
            }
            let endpoint_generation = endpoint_cap
                .expect("validated endpoint capability disappeared")
                .generation;

            // CALL always requires SEND. Receiving has a separate syscall;
            // registry ownership never changes syscall semantics or authority.
            let rights_ok = endpoint_cap.map_or(false, |capability| {
                capability
                    .rights
                    .contains(crate::ui::capability::CapabilityRights::ENDPOINT_SEND)
            });
            if !rights_ok {
                kprintln!(
                    "[M7.5] HAK İHLALİ! task={} target={} (rights eksik)",
                    current_id,
                    target_id
                );
                set_ipc_error(ctx, IpcError::InvalidCapability);
                return;
            }

            // ===================== SEND / CALL PATH (M7 gerçek Call/Reply) =====================
            // Mesaj + reply_cap gönderilir, client reply_cap üzerinde bloke olur.
            // Server reply_cap'e CALL yapınca client uyanır.

            let msg = crate::ui::capability::IpcMessage {
                label,
                badge: current_id,
                data: [mr0, mr1, mr2, mr3],
            };

            let reply_cap = match crate::ui::mint_reply_endpoint_for_call(current_id, target_id) {
                Ok(capability) => capability,
                Err(error) => {
                    kprintln!(
                        "[K2-MINT] reply mint rejected task={}: {}",
                        current_id,
                        error
                    );
                    set_ipc_error(ctx, IpcError::InvalidCapability);
                    return;
                }
            };

            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s374_irq_guard = crate::arch::aarch64::IrqGuard::new();
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s374_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s374_el0_ipc_call_writer_guard_integration::acquire_s374_production_scheduler_writer_access()
                .unwrap_or_else(|error| {
                    panic!(
                        "S374 normal EL0 IPC-call scheduler writer guard failed closed: {:?}",
                        error
                    )
                });

            let commit = unsafe {
                let scheduler = &mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER);
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                let commit = scheduler.ipc_call_commit_and_park(
                    ctx,
                    user_sp,
                    target_id,
                    endpoint_generation,
                    reply_cap.id,
                    msg,
                    s374_irq_guard,
                    s374_writer_access,
                );
                #[cfg(not(all(
                    target_arch = "aarch64",
                    target_os = "none",
                    feature = "board-rpi5"
                )))]
                let commit = scheduler.ipc_call_commit_and_park(
                    ctx,
                    user_sp,
                    target_id,
                    endpoint_generation,
                    reply_cap.id,
                    msg,
                );
                commit
            };
            if let Err(error) = commit {
                let _ = crate::ui::capability::discard_unpublished_reply_endpoint(
                    reply_cap.id,
                    Some(current_id),
                );
                if error == IpcError::QueueFull {
                    kprintln!(
                        "[K2] CALL QueueFull task={} target={} capacity={}",
                        current_id,
                        target_id,
                        IPC_QUEUE_CAPACITY
                    );
                }
                set_ipc_error(ctx, error);
                return;
            }
            // A parked CALL resumes this exact exception continuation. The
            // scheduler copied the durable wake payload back into `ctx`.
            return;
        }

        // M6.4 — Server tarafı: pending mesaj varsa al, yoksa block.
        // Argümanlar: x0 = endpoint_id
        // Dönüş: x0 = IpcError (M7.1)
        //        x1 = label, x2 = badge, x3..x6 = data[0..3]
        //        x7 = reply_cap_id (0 = reply yok, sadece SEND)
        SYS_IPC_RECV => {
            let ep_id = ctx.gpr[0];
            let current_id = crate::task::current_task_id().unwrap_or(0);
            kprintln!("[M6.4] SYS_IPC_RECV task={} ep={}", current_id, ep_id);

            // A raw endpoint id or registry ownership is not receive
            // authority. Revocation takes effect as soon as the CNode entry
            // disappears.
            let endpoint_cap = crate::task::current_task_cnode()
                .and_then(|cnode| cnode.lookup_capability_by_id(ep_id).copied())
                .filter(|capability| {
                    capability.kind == crate::ui::capability::CapabilityKind::Endpoint
                });
            let has_valid_ep = endpoint_cap.is_some();

            if !has_valid_ep {
                kprintln!(
                    "[M6.4] RECV REJECTED task={} ep={} (owner mismatch / no cap)",
                    current_id,
                    ep_id
                );
                set_ipc_error(ctx, IpcError::InvalidCapability);
                return;
            }
            let endpoint_generation = endpoint_cap
                .expect("validated endpoint capability disappeared")
                .generation;

            // M7 audit fix #4: RECV hakkı kontrolü.
            // Eskiden SYS_IPC_RECV hiç rights check etmiyordu — sadece SYS_IPC_CALL.
            let recv_rights_ok = endpoint_cap.map_or(false, |capability| {
                capability
                    .rights
                    .contains(crate::ui::capability::CapabilityRights::ENDPOINT_RECV)
            });
            if !recv_rights_ok {
                kprintln!(
                    "[M7.5] RECV REJECTED task={} ep={} (RECV hakkı yok)",
                    current_id,
                    ep_id
                );
                set_ipc_error(ctx, IpcError::InvalidCapability);
                return;
            }

            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s373_irq_guard = crate::arch::aarch64::IrqGuard::new();
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s373_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s373_el0_ipc_receive_writer_guard_integration::acquire_s373_production_scheduler_writer_access()
                .unwrap_or_else(|error| {
                    panic!(
                        "S373 EL0 IPC-receive scheduler writer guard failed closed: {:?}",
                        error
                    )
                });
            let receive = unsafe {
                let scheduler = &mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER);
                #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
                let receive = scheduler.ipc_recv_or_park(
                    ctx,
                    user_sp,
                    ep_id,
                    endpoint_generation,
                    s373_irq_guard,
                    s373_writer_access,
                );
                #[cfg(not(all(
                    target_arch = "aarch64",
                    target_os = "none",
                    feature = "board-rpi5"
                )))]
                let receive = scheduler.ipc_recv_or_park(ctx, user_sp, ep_id, endpoint_generation);
                receive
            };
            match receive {
                Ok(Some(envelope)) => {
                    set_ipc_message_result(ctx, envelope.message, envelope.reply_cap_id);
                    return;
                }
                // The registered waiter was parked and has now resumed; its
                // wake result was copied from Task.saved_user_gprs into ctx.
                Ok(None) => return,
                Err(error) => {
                    set_ipc_error(ctx, error);
                    return;
                }
            }
        }

        // M6.4 — Server cevap verir + reply cap one-shot revoke.
        // Argümanlar: x0 = reply_cap_id
        //             x1 = label, x2..x5 = data[0..3]
        SYS_IPC_REPLY => {
            let reply_cap_id = ctx.gpr[0];
            let label = ctx.gpr[1];
            let mr0 = ctx.gpr[2];
            let mr1 = ctx.gpr[3];
            let mr2 = ctx.gpr[4];
            let mr3 = ctx.gpr[5];

            let current_id = crate::task::current_task_id().unwrap_or(0);
            kprintln!(
                "[M6.4] SYS_IPC_REPLY task={} reply_cap={} label=0x{:x}",
                current_id,
                reply_cap_id,
                label
            );

            let reply_msg = crate::ui::capability::IpcMessage {
                label,
                badge: current_id,
                data: [mr0, mr1, mr2, mr3],
            };
            let bridge_preflight: Result<
                Option<crate::mm::RuntimeOomReplyPreflight>,
                crate::mm::RuntimeOomReplyBridgeError,
            > = crate::mm::preflight_runtime_oom_supervisor_reply(
                current_id,
                reply_cap_id,
                reply_msg.label,
                reply_msg.data,
            );
            let bridge_preflight = match bridge_preflight {
                Ok(preflight) => preflight,
                Err(error) => {
                    kprintln!(
                        "[K1-MEM2-REPLY-BRIDGE] PREFLIGHT_REJECTED task={} reply_cap={} error={:?}",
                        current_id,
                        reply_cap_id,
                        error
                    );
                    set_ipc_error(ctx, IpcError::InvalidCapability);
                    return;
                }
            };
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s372_irq_guard = crate::arch::aarch64::IrqGuard::new();
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            let s372_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s372_el0_ipc_reply_writer_guard_integration::acquire_s372_production_scheduler_writer_access()
                .unwrap_or_else(|error| {
                    panic!(
                        "S372 EL0 IPC-reply scheduler writer guard failed closed: {:?}",
                        error
                    )
                });
            let result = unsafe {
                let scheduler = &mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER);
                scheduler.ipc_reply_commit(reply_cap_id, reply_msg)
            };
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            drop(s372_writer_access);
            #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
            drop(s372_irq_guard);
            if result == IpcError::Ok {
                if let Some(preflight) = bridge_preflight {
                    let event = crate::mm::commit_runtime_oom_supervisor_reply(
                        preflight,
                        TICKS.load(Ordering::Acquire),
                    )
                    .unwrap_or_else(|error| {
                        panic!(
                            "reply committed but runtime OOM broker bridge failed closed: {:?}",
                            error
                        )
                    });
                    kprintln!(
                        "[K1-MEM2-REPLY-BRIDGE] task={} reply_cap={} sequence={} source_event={} REPLY_DERIVED_BROKER_COMMIT=YES SESSION_CLOSE=AUTOMATIC",
                        current_id,
                        reply_cap_id,
                        event.sequence_id(),
                        event.source_event_id(),
                    );
                }
            }
            kprintln!(
                "[K2.1] REPLY result={:?} reply_cap consumed (registry+CNode+store)",
                result
            );

            set_ipc_error(ctx, result);
            return;
        }

        _ => {
            kprintln!("[M4.3] bilinmeyen syscall: x8={}", syscall_num);
            dump_context(ctx);
            u64::MAX
        }
    };

    // Dönüş değerini x0'a yaz (user koddan okunabilir)
    ctx.gpr[0] = ret;

    // S137 common EL0 SVC safe boundary: an armed current-task teardown is
    // independent of the syscall kind and of SYS_WRITE success. The syscall
    // result is committed to the saved frame before the audited carrier may
    // retire the task and switch to a different kernel stack.
    #[cfg(feature = "board-qemu")]
    if syscall_num != SYS_YIELD {
        unsafe {
            if let Err(error) = crate::task::execute_armed_current_runtime_oom_if_target() {
                panic!("S137 common EL0 SVC safe boundary failed: {:?}", error);
            }
        }
    }

    // Return normally to exceptions.S. It owns the one RESTORE_CONTEXT+eret
    // epilogue for every non-fatal EL0 SVC, including a task that resumed
    // after yield or IPC park. Bypassing that epilogue would leak this trap
    // frame on the task's kernel stack on every syscall.
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn acquire_s372_production_scheduler_writer_access(
) -> Result<G8lS372ProductionSchedulerWriterAccess, G8lS247WholeSchedulerAccessError> {
    let caller_cpu =
        crate::percpu::try_current_cpu_id().ok_or(G8lS247WholeSchedulerAccessError::InvalidCpu)?;
    if caller_cpu != crate::g8l_runtime_contract::CPU0 {
        return Err(G8lS247WholeSchedulerAccessError::InvalidCpu);
    }
    let access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE
        .try_acquire_exclusive_for_valid_cpu(caller_cpu)?;
    Ok(G8lS372ProductionSchedulerWriterAccess { _access: access })
}

#[test]
fn reply_branch_has_exactly_one_s372_acquire_and_release() {
    let boundary = reply_boundary();
    assert_eq!(
        boundary
            .matches("acquire_s372_production_scheduler_writer_access")
            .count(),
        1
    );
    assert_eq!(boundary.matches("drop(s372_writer_access)").count(), 1);
}

  {
    id: "g8l-s372-el0-ipc-reply-writer-guard-integration-partial",
    date: "2026-08-28",
    sequence: 372,
    status: "passed",
    umbrella_status: "partial",
    title: "S372 · EL0 IPC reply production writer guard integration",
    summary:
      "S372, rust_el0_sync_handler içindeki SYS_IPC_REPLY dalının exact ipc_reply_commit(reply_cap_id, reply_msg) mutable scheduler sınırını S371 ve 44 production reader'ın kullandığı aynı statik S247 state word'e bağlar. Current-task identity, immutable reply-message kurulumu ve runtime-OOM reply preflight writer'dan önce tamamlanır. Dedicated IRQ guard ardından kurulur; gerçek per-CPU kimliğiyle yalnız CPU0 için S372 exclusive writer alınır. Exact tek mutable SCHEDULER aliası ordinary one-shot reply commit'ini kapsar ve owned result writer bırakılmadan önce oluşur. Writer ile IRQ guard success-only broker commit, diagnostic ve syscall-result publication'dan önce explicit bırakılır. Guarded writer 45/69, açık writer 24, provider authority 0 ve whole-scheduler exclusion false'dur. Bir direct production caller path vardır; supported-profile runtime observation=0'dır. Kaynak sırasındaki sonraki ayrı kapı S373 EL0 IPC receive writer'ıdır; S375 CALL-to-reply aliası S372'ye katılmaz.",
    evidence: [
      "Focused S372 sözleşmesi production modülü, exceptions.rs membership'i, kernel/simulation registration ve CPU1 coverage service henüz yokken compile RED verdi. Bu ilk kırmızı, eksik modül/source bağını görünür kıldı; ürün kodu yazılmadan GREEN kaydı üretilmedi.",
      "İlk production wiring sonrasında focused hedef 53/55 PASS verdi. Kalan iki red ürün davranışında değil, tarihsel S302 başlığının exact yazımı ile S375 CALL-to-reply alias ayrım cümlesinin kaynak sözleşmesindeydi.",
      "S302'nin tarihsel exact başlığı korundu ve S375'in ayrı alias üyeliği modül dokümantasyonuna açıkça yazıldı. Sonraki koşu 54/55 PASS verdi; kalan tek red satıra bölünmüş dokümantasyon literalinin test parser sınırıydı.",
      "Dokümantasyon exact kaynak sözleşmesi tek doğrulanabilir cümleye hizalandı; product veya coverage assertion'ı gevşetilmedi. Final focused hedef 1 grup / 55/55 PASS verdi.",
      "Final yayın-senkron snapshot focused logu 4053 B / 6ffd4719fa892db1be03a6783589b6b49015015f46ab3645abf9b68c1c84dd58 SHA-256 ile 55/55 PASS verdi. cargo fmt --all -- --check ve git diff --check aynı snapshot'ta 0 B empty-output / e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 olarak exit 0 verdi; artifact /tmp/aselsanos-s372-final-core.DNd54i'dir.",
      "Final envanter module constants, pending-request outcome ve production source katmanlarında birlikte 44 guarded reader + 45/69 guarded writer + 24 open writer'dır.",
      "Exact production sınırı arch/aarch64/exceptions.rs içindeki SYS_IPC_REPLY match dalıdır; S372 başka syscall dalını, helper'ı veya test-only callback'i production membership olarak saymaz.",
      "reply_cap_id, label ve dört message register'ı önce ExceptionContext'ten owned scalar olarak okunur. current_task_id sonucu ve immutable IpcMessage writer acquisition'dan önce kurulur.",
      "preflight_runtime_oom_supervisor_reply current_id, reply_cap_id, label ve data ile writer öncesinde çalışır. Preflight error yolu InvalidCapability yayımlar ve S372 writer edinmeden döner.",
      "Dedicated IrqGuard exact target_arch=aarch64, target_os=none, feature=board-rpi5 cfg kesişiminde writer acquisition'dan önce kurulur. Böylece local interrupt re-entry mutable alias kurulmadan kapatılır.",
      "Production wrapper try_current_cpu_id ile gerçek per-CPU kimliğini türetir; caller-supplied production CPU parametresi yoktur ve CPU0 dışındaki kimlikler fail-closed InvalidCpu verir.",
      "Wrapper exact S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE üzerinde try_acquire_exclusive_for_valid_cpu kullanır. Ayrı state word, reader lease'i veya model-only provider production'a taşınmaz.",
      "SYS_IPC_REPLY dalında exact bir acquire_s372_production_scheduler_writer_access occurrence'ı, exact bir mutable SCHEDULER aliası, exact bir ipc_reply_commit(reply_cap_id, reply_msg) forward'ı ve exact bir drop(s372_writer_access) vardır.",
      "Mutable alias yalnız ordinary one-shot reply commit için oluşturulur. Current identity, message construction, runtime-OOM preflight, broker commit, logging ve set_ipc_error bu aliasın dışında kalır.",
      "ipc_reply_commit dönüşü owned result değişkenine alınır; writer lease bu değer üretildikten hemen sonra explicit bırakılır. Scheduler referansı downstream branch'e taşınmaz.",
      "Writer drop kaynak sırasından sonra IRQ guard explicit bırakılır. Success check, optional runtime-OOM broker commit, diagnostic ve syscall result publication ancak iki guard da kapandıktan sonra çalışır.",
      "Success-only commit_runtime_oom_supervisor_reply S372 membership'ine geriye doğru katılmaz. Broker failure fail-closed panic üretse bile o anda S247 exclusive token aktif değildir.",
      "set_ipc_error(ctx, result) downstream syscall-result publication'dır ve writer/IRQ release sonrasındadır. S372 writer ExceptionContext mutation'ını kendi kapsamı olarak saymaz.",
      "S371 notification-object teardown membership'i ayrı helper ve ayrı sequence olarak kalır. S371→S372 token monotonluğu modelde doğrulanır; iki gate arasında aktif exclusive token taşınmaz.",
      "S373 SYS_IPC_RECV mutable scheduler sınırı sıradaki ayrı kapıdır. Receive branch S372 acquire/drop literalini içermez ve S372 tamamlandı diye guarded sayılmaz.",
      "S375 CALL-to-reply aliası SYS_IPC_CALL branch'inde ayrı mutation sınırıdır. S372 ordinary SYS_IPC_REPLY forward'ı alias writer kapsamını kapattığını iddia etmez.",
      "Host-testable execute_s372_guarded_el0_ipc_reply_commit yalnız CPU0 callback'ini nonzero token ile exact-once çalıştırır ve owned output receipt'i taşır.",
      "Non-CPU0, active reader veya active writer yolları callback başlamadan fail-closed olur. Live writer yeni reader'ı, live reader writer'ı aynı S247 state word üzerinde engeller.",
      "Host callback success ve error yolları membership'i exact-once bırakır. Callback error sonrasında active token kalmaz ve gate yeni writer tarafından tekrar edinilebilir.",
      "S372 preflight S371'in 44 reader / 44 guarded writer / 25 open snapshot'ını exact doğrular; doğru zincir 45/69 guarded ve 24 open üretir. Drift ayrı InventoryDrift error'ıdır.",
      "Pending S245 request yalnız non-consuming view ile incelenir. Request id korunur, take edilmez, S244 admission yayınlanmaz ve provider authority oluşturulmaz.",
      "CPU1 coverage service S371 service'inden sonra ve tarihsel S242 consumer'dan önce bağlıdır. Service S247 writer edinmez, SYS_IPC_REPLY çalıştırmaz ve runtime observation üretmez.",
      "Direct production caller envanteri exact SYS_IPC_REPLY branch'i için 1 path'tir. Bu statik source wiring sayısıdır; supported-profile S372 invocation veya cihaz gözlemi değildir.",
      "Focused 55-test matrisinde sabit envanter, idle/pending/drift preflight, request non-consumption, CPU0 admission, non-CPU0 fail-closed, reader↔writer karşılıklı exclusion, exact-once callback, success/error release ve S371→S372 token monotonluğu birbirinden ayrı testlerdir.",
      "Focused source assertions kernel main ve simulation module registration'ını, CPU1 service sırasını, exact board-rpi5 cfg kesişimini, production wrapper'ın gerçek per-CPU identity türetmesini ve shared S247 static gate kullanımını ayrı ayrı sabitler.",
      "Reply-branch assertions current-task identity, immutable IpcMessage ve runtime-OOM preflight'in writer öncesinde; exact alias/forward'ın writer altında; owned result, writer drop, IRQ drop, broker commit, diagnostic ve set_ipc_error sırasının downstream'de olduğunu bağımsız indeks karşılaştırmalarıyla doğrular.",
      "Adjacent-boundary assertions SYS_IPC_RECV dalında S372 acquire bulunmadığını ve SYS_IPC_CALL reply aliasının S375 olarak ayrı kaldığını doğrular. Böylece tam handler bağlamını göstermek, komşu writer'ları S372 coverage'ına katmaz.",
      "Exact yedi workspace dışlaması wiring_does_not_mutate_timer_gic_boot_or_expand_runtime_scope, clean_bridge_literal_include_closure_is_manifest_complete, clean_image_make_recipe_inputs_are_exact_and_manifested, s99_and_s98_are_narrowly_historically_versioned, s97_runtime_and_layout_identities_are_unchanged, s97_s98_inputs_and_make_history_are_narrowly_versioned ve historical_s90_and_s100_inputs_remain_exact'tir.",
      "Dışlama listesi isimle sabittir; wildcard, S372 testi veya yeni üretim assertion'ı filtrelemez. Filtresiz RED ile filtered acceptance aynı anda kaydedilerek tarihsel S96 drift'i gizlenmez.",
      "Dört profil artifact dizini sırasıyla /tmp/aselsanos-s372-board-qemu.mrSU3w, /tmp/aselsanos-s372-board-rpi4.8RR0De, /tmp/aselsanos-s372-board-rpi5.GJl33i ve /tmp/aselsanos-s372-board-rpi5-smp.K7Vmct'dir; her build fresh target dizininde çalıştı.",
      "Cargo final satırları qemu/rpi4/rpi5/rpi5+smp için 292/390/1383/1383 warning bildirir; literal warning header envanteri 293/391/1384/1384'tür. Bu ölçümler sıfır-warning veya warning regression kabulü olarak sunulmaz.",
      "Final seçili regresyon 17 grup / 402/402 PASS'tir: S372 55, S371 48, S370 50, S302–S305 dört grup 60, S316 15, S252 11, S290 15, S367 51, S369 49, ipc_queue_source 18, return witness 10, strict EL0 transport 5, multi-event 7 ve reply bridge 8.",
      "Seçili regresyon özeti 1612 B / 20b421080573bbfbc37864d3e5d2dd80ea565d77c03fc8f3127809b7982514c0 olarak /tmp/aselsanos-s372-selected.AuwJAR altında ölçüldü.",
      "S238–S372 dependency matrisi S240'ın iki distinct grubuyla 136 gruptur; iki bağımsız seri koşunun her biri 2966/2966 PASS verdi.",
      "Dependency raw özetleri 32389 B olup 2a0bee8b035749592f161b4ce6b437aeaafe82395470f30dea31dbccdd40c3fa ve 94a0645a89a37e58eb599264ee09f3f64db412708a7109014297e936563272a0 SHA-256 ile timing alanlarında ayrıştı.",
      "Süre-normalize dependency özetleri 32525 B / c3996a11e50c289506babe090fcf7c756d2cb6a1989defb9e53068466bc33cea SHA-256 ile byte-eşittir. Artifact /tmp/aselsanos-s372-dependency.9WuSFb'dir.",
      "Exact yedi frozen G8h assertion dışındaki seri workspace 335 grup / 4829 PASS / 0 fail / 7 filtered verdi; 31707 B summary SHA-256 2ea414d3b3ebbb0a3b6758602fda6ecc243df03b3d3d7f39385b56f1929507b'dir.",
      "Filtresiz workspace exit 101 ile yalnız frozen S96 wiring_does_not_mutate_timer_gic_boot_or_expand_runtime_scope source-identity reddinde durdu; 288 grup / 4574 PASS / 1 fail, 27288 B / ea8c083dd4878efc75e9f1a647112d46bb4d3f43a514484725a4f06d297357. Global workspace GREEN iddia edilmez.",
      "Workspace artifact dizini /tmp/aselsanos-s372-workspace.zxfdm0'dır. Filtre listesine S372 testi eklenmedi; yalnız adı sabit yedi tarihsel assertion dışlandı.",
      "Fresh izole dev/debug AArch64 profilleri 4/4 exit 0 verdi. Build logları board-qemu 112195 B / 885422c35c74de9c7eb7fad632ac6284cab96c8fe41d61c9db02c277446d7ad4; board-rpi4 150995 B / 7f7c017a421a94d52662f89e18878fadee0d8c4a4abda458ffaf18f0d53a4541; board-rpi5 610452 B / bee12634bcc799e7c673d8983ac2231e91391b45135e0a6bfecd9707056f5cf2 ve board-rpi5+smp 610127 B / 680c460af1ce88156cdcb735f8f518e474ae7313ef74770f8e05bc4c4d022008 olarak ölçüldü. Zero-warning iddiası yoktur.",
      "Literal warning header sayıları qemu/rpi4/rpi5/rpi5+smp için 293/391/1384/1384'tür. Cargo final warning sayıları ayrıca loglardan doğrulanır ve header sayılarıyla karıştırılmaz.",
      "Fresh ELF'ler qemu 17324408 B / 87fe7ef5ad30238513e2d8395be1974564c9233b200fa4637a26ac7bee0cdca6; rpi4 12330224 B / 85d5a768d03aa970887bdabd293a9a29e9140a12316faba5279c8d0418f3d362; rpi5 18860688 B / debbb8a16ba81f545245a9c2406390dcca035320161ed1e2006494ab40151b2c ve rpi5+smp 18848152 B / 696534d2ce629a3a22fd90a2e0cfa632158217d81acaea4816ccca1076aea836 olarak loglardan ayrı ölçüldü.",
      "make verify-qemu 116354 B / f3c330e0a3a67be9eb88557d7f188a6c0838ae9823f136d8476daef236595a59 ile W^X 31/31, S130–S154+S271, RuntimePmm, EL0x4096, IPC 20/20 ve SEC5 PASS verdi.",
      "QEMU artifact dizini /tmp/aselsanos-s372-qemu.tZ3RRM'dir. Bu board-qemu ortak regresyonudur; RPi5-only S372 runtime invocation kanıtı değildir ve runtime observations=0 alanını değiştirmez.",
      "S1–S327 tarihsel Kod kataloğu 327/327 ayrı kimlik olarak korunur. S372 source-bound hedefi S1–S372 372/372 ayrı kapı, pre-S328 327/327, missing=none ve duplicate=0'dır.",
      "S372 production Code paneli rust_el0_sync_handler içindeki SYS_IPC_REPLY dalını tam bağlamıyla taşır; nested exact focus acquire_s372→mutable scheduler alias→ipc_reply_commit→drop writer aralığıdır. Upstream preflight ve downstream broker/result kodu tam bağlamda görünür ama focus dışında kalır.",
      "İlk publication source registry'si S1–S372 aralığında 372/372 ayrı kapı, 1051 exact excerpt, pre-S328 327/327, missing=none ve duplicate=0 üretti. JSON payload 7285003 B / 68e64af2d304bd5444f25131417c4ae57ecea6270ba52ed0c580fd6824cd25a6; registry content SHA-256 733d0f547c97ed784fa63be7040b28007d921e32a1ed77ba8b1f345f2b260c3c'dir.",
      "İlk website kabulü 650/650 PASS, lint PASS, TypeScript boş çıktılı exit 0 ve 24/24 static page verdi. Test 60102 B / c160f99bff4339dbece96ad15f9a9af292f6eb74e2434842c04ee636c2d63275; lint 218 B / 79c084453e339ceb2efe76ed96d1d68be8ac51442957a7a048fd17dba3067ba2; TypeScript 0 B / e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ve build 1213 B / 87defbfa4694768b33d71616be02126d66c1f219ffc93bf15ea7b87a1281c71a'dır.",
      "S372 production/main deployment fbb4e1a1 ile https://fbb4e1a1.aselsan-microkernel.pages.dev adresine 116 upload + 84 existing = 200 asset olarak tamamlandı; deploy log 1800 B / 9ee540740a18ec3e9a387919bf0261bd0c48bbb43b4f02d7402877339030f340'dır.",
      "İlk cache-busted custom-domain doğrulamasında /code/ 21203823 B / 1375d4ed9e05e8b6ed8d97e781742dc62d3e394eafb1d4b41e2372a4da882139, /operations/ 12888937 B / f8f2693cc229155ed08eca8fd07873cacc59791da65119cc8906f3bcc3d853f8, /timeline/ 4907594 B / 14fd255233c41f5e80eca88fab18ae27f588336f79e17727f57619df2c3840a6 ve /yol-haritasi/ 4907342 B / e820d73ed844c7f1915c96d94691b5254f8d3f37399e85f8403abd98be3121a4 ile HTTP 200 ve yerel out'a raw byte-exact PASS verdi.",
      "/code/ Cache-Control public, max-age=0, must-revalidate, no-transform taşıdı; canlı data-code-gate envanteri 372/372 unique, pre-S328 327/327, S372=1, S373=0 ve duplicate=0'dır. Immutable fbb4e1a1 hostname probe'u curl exit 28 / HTTP 000 verdi; custom-domain PASS bunun yerine geçirilmez.",
      "İlk publication artifact dizini /tmp/aselsanos-s372-publication.P8Z2wr, website kabul artifact dizini /tmp/aselsanos-s372-web-initial.JVrMFK'dir. Sonraki evidence-sync registry hash'i self-reference oluşturmamak için bu ilk snapshot hash'inden ayrı tutulur.",
      "Operations, Timeline/Yol Haritası, Phone OS konumlandırma ve Code S372'yi S371'den ayrı kartta gösterir. S335–S400 toplu tamamlama etiketi veya tek birleşik kod kutusu üretilmez.",
      "S372 sırasında güç, SD kart, Mac kart erişimi, UART capture, raw validation, archive veya promotion yapılmadı: physical/device operations=0 ve RUNBOOK_EXECUTED_IN_S372=NO.",
      "S372 bazlı bağlayıcı olmayan planlama görünümü R1 S372–S402, R2 S427–S477, R3 S556+, kaba S532–S582 ve risk paylı merkez yaklaşık S557'dir. Bu projeksiyon yeni sıra veya ürün taahhüdü değildir.",
    ],
    commands: [
      "cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s372_el0_ipc_reply_writer_guard_integration -- --test-threads=1",
      "run 17 exact S372/S371/S370/S302-S305/S316/S252/S290/S367/S369/IPC source and runtime groups serially",
      "run four fresh AArch64 dev/debug profile builds; run S238-S372 dependency list twice; run filtered and unfiltered serial workspace audits; make verify-qemu",
      "npm run code:generate && npm test && npm run lint && npx tsc --noEmit && npm run build",
      "npm run deploy",
      "cache-busted curl + cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
    ],
    terminalSessions: [
      {
        id: "g8l-s372-focused-source-contract",
        title: "S372 focused EL0 IPC reply writer membership",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s372_el0_ipc_reply_writer_guard_integration -- --test-threads=1",
        ],
        outputLines: [
          "initial result: compile RED; S372 module/source registration absent",
          "first production result: 53 passed; 2 exact source-contract assertions failed",
          "intermediate result: 54 passed; 1 documentation-boundary assertion failed",
          "final result: ok; S372 focused 1 group / 55 passed / 0 failed",
          "shared S247 gate: 44 guarded readers + 45/69 guarded writers; 24 writers open",
          "identity/message/preflight < IRQ < S372 writer < owned reply result < writer/IRQ release < broker/diagnostic/result",
          "direct production caller paths=1; runtime observations=0; provider authority=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s372-selected-regression",
        title: "S372 selected reply/lifecycle/source regression",
        commandLines: [
          "run 17 exact S372/S371/S370/S302-S305/S316/S252/S290/S367/S369/IPC groups serially",
        ],
        outputLines: [
          "final result: 17 groups / 402 passed / 0 failed",
          "S372=55; S371=48; S370=50; S302-S305=60; S316=15; S252=11; S290=15; S367=51; S369=49",
          "IPC source/return/transport/multi-event/reply-bridge groups=48/48",
          "summary 1612 bytes; SHA-256 20b421080573bbfbc37864d3e5d2dd80ea565d77c03fc8f3127809b7982514c0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s372-core-acceptance",
        title: "S372 profiles, dependency, workspace and QEMU acceptance",
        commandLines: [
          "run four fresh AArch64 dev/debug profile builds",
          "run S238-S372 dependency list twice and normalize timing fields",
          "run filtered and unfiltered serial workspace audits",
          "make verify-qemu",
        ],
        outputLines: [
          "four profiles 4/4 exit 0; build logs and ELF byte/hash values measured separately",
          "dependency 136 groups / 2966/2966 twice; normalized 32525-byte summaries byte-identical",
          "filtered workspace 335 groups / 4829 PASS / 7 historical filtered",
          "unfiltered workspace exit 101: only frozen-S96 source identity; global GREEN not claimed",
          "QEMU W^X 31/31 + S130-S154 + S271 + IPC 20/20 + SEC5 PASS; not an S372 runtime observation",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s372-production-publication",
        title: "S372 Operations/Timeline/Code production publication",
        commandLines: [
          "npm run code:generate && npm test && npm run lint && npx tsc --noEmit && npm run build",
          "npm run deploy",
          "cache-busted curl + cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
        ],
        outputLines: [
          "source registry S1-S372: 372/372 gates; 1051 exact excerpts; pre-S328 327/327; missing none; duplicate 0",
          "website tests 650/650 PASS; lint PASS; TypeScript empty-output PASS; static pages 24/24",
          "deployment fbb4e1a1; 116 uploaded + 84 existing = 200 assets",
          "four custom-domain routes HTTP 200 and byte-exact with local out; /code no-transform",
          "live code labels 372/372 unique; pre-S328 327/327; S372=1; S373=0; duplicate=0",
          "immutable fbb4e1a1 hostname curl exit 28 / HTTP 000; not substituted by custom-domain PASS",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
    ],
    terminalSessionsNote:
      "Terminal blokları kapıya göre ayrıdır: focused membership, seçili regresyon, çekirdek matris ve canlı yayın kabulü tek kutuda birleştirilmez. İlk production publication tamamlandı; evidence-sync ölçümü ayrı tutulur.",
    limitations: [
      "S372 yalnız ordinary SYS_IPC_REPLY ipc_reply_commit mutable scheduler membership'ini kapatır; S373 receive ve S375 CALL-to-reply aliası açık ayrı kapılardır.",
      "Production provider authority=0, whole-scheduler exclusion=false, S245 request take=false ve S244 admission publication=false olarak kalır.",
      "Bir direct source path runtime invocation değildir; supported-profile S372 observation=0 ve physical/device operations=0'dır.",
      "Filtresiz global workspace frozen S96 source-identity assertion'ı nedeniyle RED'dir; Generic SMP, liveness/soak ve fiziksel kabul açık kalır.",
    ],
  },