K1/MEM2: exact-once OOM effect transaction ve supervisor ACK

impl RuntimeOomCoordinator {
    pub fn try_new(monitor: &RuntimePressureMonitor) -> Result<Self, RuntimeOomCoordinatorError> {
        let coordinator_epoch = mint_coordinator_epoch()?;
        Ok(Self {
            coordinator_epoch,
            instance_epoch: monitor.instance_epoch(),
            last_started_epoch: 0,
            last_acknowledged_epoch: 0,
            last_rearmed_epoch: 0,
            next_event_id: 1,
            active: None,
            events: [None; MAX_RUNTIME_OOM_EVENTS],
            event_head: 0,
            event_count: 0,
        })
    }

    pub const fn snapshot(&self) -> RuntimeOomCoordinatorSnapshot {
        RuntimeOomCoordinatorSnapshot {
            coordinator_epoch: self.coordinator_epoch,
            instance_epoch: self.instance_epoch,
            last_started_epoch: self.last_started_epoch,
            last_acknowledged_epoch: self.last_acknowledged_epoch,
            last_rearmed_epoch: self.last_rearmed_epoch,
            active: self.active.is_some(),
            queued_events: self.event_count,
            next_event_id: self.next_event_id,
        }
    }

    /// Consume one S128 decision only after every check and event-capacity
    /// preflight succeeds. A no-victim selection is itself a supervisor event;
    /// it never manufactures a teardown target.
    pub fn begin(
        &mut self,
        decision: RuntimePressureDecision,
    ) -> Result<RuntimeOomBegin, RuntimeOomCoordinatorError> {
        if !decision.is_consistent()
            || decision.observation.current != PressureLevel::Critical
            || decision.observation.oom_epoch == 0
        {
            return Err(RuntimeOomCoordinatorError::InvalidDecision);
        }
        if decision.observation.action != PressureAction::SelectOomVictim {
            return Err(RuntimeOomCoordinatorError::NotVictimSelection);
        }
        if decision.instance_epoch != self.instance_epoch {
            return Err(RuntimeOomCoordinatorError::ForeignMemoryInstance {
                expected: self.instance_epoch,
                observed: decision.instance_epoch,
            });
        }
        if self.active.is_some() {
            return Err(RuntimeOomCoordinatorError::AttemptInFlight);
        }
        if self.event_count == MAX_RUNTIME_OOM_EVENTS {
            return Err(RuntimeOomCoordinatorError::EventQueueFull);
        }
        if decision.observation.oom_epoch <= self.last_started_epoch {
            return Err(RuntimeOomCoordinatorError::EpochNotIncreasing {
                last_started: self.last_started_epoch,
                provided: decision.observation.oom_epoch,
            });
        }
        let event_id = self.next_event_id;
        let next_event_id = event_id
            .checked_add(1)
            .ok_or(RuntimeOomCoordinatorError::EventIdExhausted)?;
        let reclaimable_frames = decision
            .victim
            .map_or(0, |victim| victim.reclaimable_frames);
        let expected_free_frames = decision
            .observation
            .free_frames
            .checked_add(reclaimable_frames)
            .ok_or(RuntimeOomCoordinatorError::ArithmeticOverflow)?;
        let mut active = ActiveRuntimeOomAttempt {
            coordinator_epoch: self.coordinator_epoch,
            event_id,
            oom_epoch: decision.observation.oom_epoch,
            victim: decision.victim,
            baseline_free_frames: decision.observation.free_frames,
            expected_free_frames,
            phase: RuntimeOomAttemptPhase::Executing,
        };

        let result = match decision.victim {
            Some(victim) => RuntimeOomBegin::Teardown(RuntimeOomTeardownTicket {
                coordinator_epoch: self.coordinator_epoch,
                event_id,
                oom_epoch: decision.observation.oom_epoch,
                victim,
                expected_free_frames,
                consumed: false,
            }),
            None => {
                let event = RuntimeOomEvent {
                    id: event_id,
                    kind: RuntimeOomEventKind::NoEligibleVictim,
                    instance_epoch: self.instance_epoch,
                    oom_epoch: decision.observation.oom_epoch,
                    domain: None,
                    task_id: None,
                    expected_reclaimable_frames: 0,
                    observed_domain_frames: 0,
                    baseline_free_frames: decision.observation.free_frames,
                    observed_free_frames: decision.observation.free_frames,
                    ipc_lifecycle_closed: false,
                    address_space_quiesced: false,
                    page_tables_released: false,
                    asid_released: false,
                };
                self.enqueue_preflighted(event);
                active.phase = RuntimeOomAttemptPhase::AwaitingAcknowledgement;
                RuntimeOomBegin::EscalationQueued { event_id }
            }
        };

        self.active = Some(active);
        self.last_started_epoch = decision.observation.oom_epoch;
        self.next_event_id = next_event_id;
        Ok(result)
    }

    /// Re-audit a live ticket immediately before scheduler/IPC mutation.
    ///
    /// This method is read-only: a stale ticket, changed victim inventory, or
    /// foreign RuntimeMemory instance leaves coordinator state untouched.
    pub fn preflight_teardown(
        &self,
        ticket: &RuntimeOomTeardownTicket,
        memory: &RuntimeMemoryState<'_>,
    ) -> Result<RuntimeOomTeardownPreflight, RuntimeOomCoordinatorError> {
        let (active, victim) = self.validate_live_ticket(ticket)?;
        let snapshot = memory.audited_snapshot()?;
        if snapshot.instance_epoch != self.instance_epoch {
            return Err(RuntimeOomCoordinatorError::ForeignMemoryInstance {
                expected: self.instance_epoch,
                observed: snapshot.instance_epoch,
            });
        }
        let quota = memory.audited_domain_quota(victim.domain)?;
        if snapshot.pmm.free_frames != active.baseline_free_frames
            || quota.allocated_frames != victim.allocated_frames
            || quota.retired_frames != victim.retired_frames
            || quota.pinned_frames != victim.pinned_frames
            || quota.pin_references != victim.pin_references
            || victim.reclaimable_frames != ticket.expected_reclaimable_frames()
        {
            return Err(RuntimeOomCoordinatorError::InventoryChanged);
        }
        Ok(RuntimeOomTeardownPreflight {
            domain: victim.domain,
            oom_epoch: active.oom_epoch,
            expected_reclaimable_frames: victim.reclaimable_frames,
            baseline_free_frames: active.baseline_free_frames,
        })
    }

    /// Finish a ticket only after rebuilding the victim-domain and global PMM
    /// state from the authoritative memory ledger. The caller cannot report a
    /// reclaimed-frame count.
    pub fn complete_teardown(
        &mut self,
        ticket: &mut RuntimeOomTeardownTicket,
        memory: &RuntimeMemoryState<'_>,
        witness: RuntimeOomTeardownWitness,
    ) -> Result<u64, RuntimeOomCoordinatorError> {
        let (active, victim) = self.validate_live_ticket(ticket)?;
        if !witness.is_structurally_valid() || witness.domain != victim.domain {
            return Err(RuntimeOomCoordinatorError::WitnessMismatch);
        }
        if self.event_count == MAX_RUNTIME_OOM_EVENTS {
            return Err(RuntimeOomCoordinatorError::EventQueueFull);
        }

        let snapshot = memory.audited_snapshot()?;
        if snapshot.instance_epoch != self.instance_epoch {
            return Err(RuntimeOomCoordinatorError::ForeignMemoryInstance {
                expected: self.instance_epoch,
                observed: snapshot.instance_epoch,
            });
        }
        let quota = memory.audited_domain_quota(victim.domain)?;
        let complete = witness.lifecycle_complete()
            && quota.allocated_frames == 0
            && quota.retired_frames == 0
            && quota.pinned_frames == 0
            && quota.pin_references == 0
            && snapshot.pmm.free_frames == active.expected_free_frames;
        let event = RuntimeOomEvent {
            id: active.event_id,
            kind: if complete {
                RuntimeOomEventKind::TeardownComplete
            } else {
                RuntimeOomEventKind::TeardownIncomplete
            },
            instance_epoch: self.instance_epoch,
            oom_epoch: active.oom_epoch,
            domain: Some(victim.domain),
            task_id: Some(witness.task_id),
            expected_reclaimable_frames: victim.reclaimable_frames,
            observed_domain_frames: quota.allocated_frames,
            baseline_free_frames: active.baseline_free_frames,
            observed_free_frames: snapshot.pmm.free_frames,
            ipc_lifecycle_closed: witness.ipc_lifecycle_closed,
            address_space_quiesced: witness.address_space_quiesced,
            page_tables_released: witness.page_tables_released,
            asid_released: witness.asid_released,
        };

        self.enqueue_preflighted(event);
        self.active = Some(ActiveRuntimeOomAttempt {
            phase: RuntimeOomAttemptPhase::AwaitingAcknowledgement,
            ..active
        });
        ticket.consumed = true;
        Ok(event.id)
    }

    fn validate_live_ticket(
        &self,
        ticket: &RuntimeOomTeardownTicket,
    ) -> Result<(ActiveRuntimeOomAttempt, RuntimeOomVictim), RuntimeOomCoordinatorError> {
        if ticket.consumed {
            return Err(RuntimeOomCoordinatorError::TicketConsumed);
        }
        let active = self
            .active
            .ok_or(RuntimeOomCoordinatorError::TicketMismatch)?;
        let Some(victim) = active.victim else {
            return Err(RuntimeOomCoordinatorError::TicketMismatch);
        };
        if active.phase != RuntimeOomAttemptPhase::Executing
            || active.coordinator_epoch != self.coordinator_epoch
            || ticket.coordinator_epoch != self.coordinator_epoch
            || ticket.event_id != active.event_id
            || ticket.oom_epoch != active.oom_epoch
            || ticket.victim != victim
            || ticket.expected_free_frames != active.expected_free_frames
        {
            return Err(RuntimeOomCoordinatorError::TicketMismatch);
        }
        Ok((active, victim))
    }

    /// Deliver the oldest event once. Until its exact id is acknowledged the
    /// event remains resident and the OOM epoch cannot be rearmed.
    pub fn deliver_next_event(&mut self) -> Result<RuntimeOomEvent, RuntimeOomCoordinatorError> {
        let queued = self.events[self.event_head]
            .as_mut()
            .ok_or(RuntimeOomCoordinatorError::EventUnavailable)?;
        if queued.delivered {
            return Err(RuntimeOomCoordinatorError::EventAlreadyDelivered {
                event_id: queued.event.id,
            });
        }
        queued.delivered = true;
        Ok(queued.event)
    }

    pub fn acknowledge(
        &mut self,
        event_id: u64,
    ) -> Result<RuntimeOomEvent, RuntimeOomCoordinatorError> {
        let active = self
            .active
            .ok_or(RuntimeOomCoordinatorError::EventUnavailable)?;
        if active.phase != RuntimeOomAttemptPhase::AwaitingAcknowledgement {
            return Err(RuntimeOomCoordinatorError::AttemptInFlight);
        }
        let queued =
            self.events[self.event_head].ok_or(RuntimeOomCoordinatorError::EventUnavailable)?;
        if queued.event.id != event_id {
            return Err(RuntimeOomCoordinatorError::AckMismatch {
                expected: queued.event.id,
                provided: event_id,
            });
        }
        if !queued.delivered {
            return Err(RuntimeOomCoordinatorError::AckBeforeDelivery { event_id });
        }

        self.events[self.event_head] = None;
        self.event_head = (self.event_head + 1) % MAX_RUNTIME_OOM_EVENTS;
        self.event_count -= 1;
        self.active = None;
        self.last_acknowledged_epoch = queued.event.oom_epoch;
        Ok(queued.event)
    }

    /// Rearm the S128 monitor only after the corresponding supervisor event
    /// was delivered and acknowledged. A recovered/non-critical monitor
    /// rejects rearm without mutating coordinator state.
    pub fn rearm_monitor(
        &mut self,
        monitor: &mut RuntimePressureMonitor,
    ) -> Result<u64, RuntimeOomCoordinatorError> {
        if self.active.is_some() || self.event_count != 0 {
            return Err(RuntimeOomCoordinatorError::AttemptInFlight);
        }
        if self.last_acknowledged_epoch == 0 {
            return Err(RuntimeOomCoordinatorError::RearmBeforeAcknowledgement);
        }
        if self.last_rearmed_epoch == self.last_acknowledged_epoch {
            return Err(RuntimeOomCoordinatorError::RearmAlreadyIssued {
                oom_epoch: self.last_acknowledged_epoch,
            });
        }
        if monitor.instance_epoch() != self.instance_epoch {
            return Err(RuntimeOomCoordinatorError::ForeignMemoryInstance {
                expected: self.instance_epoch,
                observed: monitor.instance_epoch(),
            });
        }
        if monitor.oom_epoch() != self.last_acknowledged_epoch {
            return Err(RuntimeOomCoordinatorError::MonitorEpochMismatch {
                expected: self.last_acknowledged_epoch,
                observed: monitor.oom_epoch(),
            });
        }
        let rearmed = monitor.rearm_oom_selection()?;
        self.last_rearmed_epoch = self.last_acknowledged_epoch;
        Ok(rearmed)
    }

    fn enqueue_preflighted(&mut self, event: RuntimeOomEvent) {
        debug_assert!(self.event_count < MAX_RUNTIME_OOM_EVENTS);
        let tail = (self.event_head + self.event_count) % MAX_RUNTIME_OOM_EVENTS;
        debug_assert!(self.events[tail].is_none());
        self.events[tail] = Some(QueuedRuntimeOomEvent {
            event,
            delivered: false,
        });
        self.event_count += 1;
    }
}

#[test]
fn audited_victim_becomes_one_linear_ticket_and_complete_ack_event() {
    let mut metadata = [0; 16];
    let mut memory = state(&mut metadata);
    let victim_domain = memory.register_domain_with_quota(10, 12).unwrap();
    let mut victim_frames = memory
        .allocate_classified(victim_domain, RuntimeMemoryClass::TaskData, 12)
        .unwrap();
    let policies = [RuntimeOomPolicy::new(victim_domain, 10, false)];
    let mut monitor = RuntimePressureMonitor::try_new(&memory, 6, 3, 2).unwrap();
    let (_, decision) = critical_decision(&memory, &mut monitor, &policies);
    let victim = decision.victim.expect("audited victim");

    let mut coordinator = RuntimeOomCoordinator::try_new(&monitor).unwrap();
    let mut ticket = match coordinator.begin(decision).unwrap() {
        RuntimeOomBegin::Teardown(ticket) => ticket,
        RuntimeOomBegin::EscalationQueued { .. } => panic!("victim unexpectedly absent"),
    };
    assert_eq!(ticket.domain(), victim_domain);
    assert_eq!(ticket.oom_epoch(), decision.observation.oom_epoch);
    assert_eq!(ticket.expected_reclaimable_frames(), 12);

    scrub(&mut memory, victim_domain, &victim_frames);
    memory.free(victim_domain, &mut victim_frames).unwrap();
    let event_id = coordinator
        .complete_teardown(&mut ticket, &memory, complete_witness(victim_domain))
        .unwrap();
    assert!(ticket.is_consumed());
    assert_eq!(
        coordinator.complete_teardown(&mut ticket, &memory, complete_witness(victim_domain)),
        Err(RuntimeOomCoordinatorError::TicketConsumed)
    );

    let event = coordinator.deliver_next_event().unwrap();
    assert_eq!(event.id, event_id);
    assert_eq!(event.kind, RuntimeOomEventKind::TeardownComplete);
    assert_eq!(event.domain, Some(victim.domain));
    assert_eq!(event.expected_reclaimable_frames, 12);
    assert_eq!(event.observed_domain_frames, 0);
    assert_eq!(event.baseline_free_frames, 3);
    assert_eq!(event.observed_free_frames, 15);
    assert_eq!(
        coordinator.deliver_next_event(),
        Err(RuntimeOomCoordinatorError::EventAlreadyDelivered { event_id })
    );
    assert_eq!(coordinator.acknowledge(event_id).unwrap(), event);
    let snapshot = coordinator.snapshot();
    assert!(!snapshot.active);
    assert_eq!(snapshot.queued_events, 0);
    assert_eq!(
        snapshot.last_acknowledged_epoch,
        decision.observation.oom_epoch
    );

    // The audited reclaim recovered memory. Once the monitor observes that
    // recovery, an OOM retry cannot be rearmed outside CRITICAL.
    let recovered = monitor.observe(&memory, &policies).unwrap();
    assert_eq!(recovered.observation.current, PressureLevel::Normal);
    let before = coordinator.snapshot();
    assert!(matches!(
        coordinator.rearm_monitor(&mut monitor),
        Err(RuntimeOomCoordinatorError::Pressure(_))
    ));
    assert_eq!(coordinator.snapshot(), before);
}

  {
    id: "k1-mem2-oom-effect-transaction-partial",
    date: "2026-08-23",
    sequence: 129,
    status: "passed",
    umbrella_status: "partial",
    title: "K1/MEM2: exact-once OOM effect transaction ve supervisor ACK",
    summary:
      "S128'in audited pressure/OOM kararı üzerinde S129, current RuntimeMemory instance'ına bağlı tekil coordinator epoch'u, lineer teardown ticket'ı ve sabit kapasiteli supervisor event/ACK kuyruğu kurar. Completion sonucu çağıranın bildirdiği frame sayısından değil authoritative RuntimeMemory/RuntimePmm audit'inden türetilir; eksik reclaim TeardownIncomplete kalır, uygun kurban yoksa hedef uydurmadan NoEligibleVictim olayı üretilir. Event yalnız bir kez teslim edilir, exact ACK gelmeden monitor rearm edilmez. Gerçek scheduler task termination, IPC/address-space teardown ve reaper yürütücüsü henüz bu ticket'a bağlı değildir; K1/MEM1/MEM2 PARTIAL kalır.",
    evidence: [
      "RED kapısı beklendiği gibi compile-failed oldu: `kernel/src/mm/runtime_oom.rs` yoktu ve `runtime_oom_effect` testi unresolved module ile durdu.",
      "GREEN S129 host kapısı 5/5 PASS: audited complete, caller'ın reclaim uyduramaması, foreign/nonselection/duplicate/stale girdilerin mutasyonsuz reddi, no-eligible-victim olayı ve allocation-free kaynak sınırı.",
      "S128+S129 focused serialized authority matrisi 51/51 PASS: runtime_oom_effect 5/5, runtime_pressure_authority 4/4, memory_pressure 4/4, runtime_domain_quota 3/3, runtime_memory_reconciliation 5/5, runtime_allocation_token 18/18, memory_accounting 9/9 ve runtime_boot_authority family 3/3.",
      "Completion authority `audited_snapshot()` ve `audited_domain_quota()` ile baseline/current free-frame ve victim-domain frame sayılarını yeniden okur; API'de `reported_reclaimed_frames` yoktur.",
      "Supervisor kuyruğu heap kullanmaz: `[Option<QueuedRuntimeOomEvent>; 8]`; teslim edilmiş olay duplicate delivery'yi, yanlış/erken ACK ise state mutasyonunu fail-closed reddeder.",
      "AArch64 board-qemu, board-rpi4, board-rpi5 ve board-rpi5+smp compile applicability 4/4 PASS.",
      "QEMU smoke mevcut strict ELF MEM0 ledger/reclaim, hello x4096, IPC 3/3 ve scheduler SEC5 regresyonunu geçti; S129 coordinator boot/scheduler yolunda çağrılmadığı için bu gerçek OOM runtime-effect kanıtı değildir.",
      "Tam workspace koşusu S129 dışındaki frozen S96 exceptions.S SHA-256 uyuşmazlığında durdu: observed f7b47672…04fd, expected c0eed3e2…cb89. Frozen test gevşetilmedi ve full-workspace GREEN iddia edilmedi.",
      "Kalıcı kapsam ve açık S130 sınırı: `docs/K1-S129-OOM-Effect-Transaction-Proof.md`.",
    ],
    commands: [
      "cargo test -p aselsan_microkernel_simulation --test runtime_oom_effect -- --test-threads=1",
      "cargo test -p aselsan_microkernel_simulation --test runtime_oom_effect --test runtime_pressure_authority --test memory_pressure --test runtime_domain_quota --test runtime_memory_reconciliation --test runtime_allocation_token --test memory_accounting --test runtime_boot_authority --test runtime_boot_authority_fail_closed --test runtime_boot_authority_no_alloc -- --test-threads=1",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-qemu",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi4",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5,smp",
      "make verify-qemu",
      "cargo test --workspace -- --test-threads=1",
    ],
    terminalSessions: [
      {
        id: "s129-red-missing-effect-module",
        title: "S129 RED: OOM effect modülü henüz yok",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test runtime_oom_effect -- --test-threads=1",
        ],
        outputLines: [
          "error: couldn't read simulation/tests/../../kernel/src/mm/runtime_oom.rs",
          "RED gate: compile_failed_missing_runtime_oom_module",
        ],
        exitCode: 101,
        outputMode: "selected",
        outputNote:
          "RED, production modülü eklenmeden önce yeni kabul testinin gerçekten kapalı olduğunu gösterir.",
      },
      {
        id: "s129-green-and-focused-authority",
        title: "OOM effect transaction ve birleşik authority host kapıları",
        commandLines: [
          "cargo test -p aselsan_microkernel_simulation --test runtime_oom_effect -- --test-threads=1",
          "cargo test -p aselsan_microkernel_simulation --test runtime_oom_effect --test runtime_pressure_authority --test memory_pressure --test runtime_domain_quota --test runtime_memory_reconciliation --test runtime_allocation_token --test memory_accounting --test runtime_boot_authority --test runtime_boot_authority_fail_closed --test runtime_boot_authority_no_alloc -- --test-threads=1",
        ],
        outputLines: [
          "runtime_oom_effect: 5/5 PASS",
          "S128+S129 focused authority matrix: 51/51 PASS",
          "caller-supplied reclaimed-frame counter: ABSENT",
          "fixed supervisor queue capacity: 8",
          "delivery/ACK/rearm protocol: PASS",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "s129-aarch64-and-qemu-regression",
        title: "Dört AArch64 profil ve mevcut QEMU regresyonu",
        commandLines: [
          "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-qemu",
          "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi4",
          "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
          "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5,smp",
          "make verify-qemu",
        ],
        outputLines: [
          "AArch64 compile profiles: 4/4 PASS",
          "QEMU smoke PASS: strict ELF MEM0 ledger/reclaim baseline + hello x4096 + IPC reply 3/3 + scheduler SEC 5",
          "S129 RuntimeOomCoordinator invocation: NOT_WIRED",
        ],
        exitCode: 0,
        outputMode: "selected",
      },
      {
        id: "s129-workspace-independent-history-red",
        title: "Tam workspace: S129 dışı frozen S96 identity kırmızısı",
        commandLines: ["cargo test --workspace -- --test-threads=1"],
        outputLines: [
          "rpi5_g8h_integration_source::wiring_does_not_mutate_timer_gic_boot_or_expand_runtime_scope: FAILED",
          "S96 exceptions.S SHA-256: observed f7b47672...04fd, frozen expected c0eed3e2...cb89",
          "run stopped at the first independent historical failure",
          "full-workspace GREEN is not claimed",
        ],
        exitCode: 101,
        outputMode: "selected",
        outputNote:
          "S129 frozen S96 dosyasını, identity sabitini veya testi değiştirmedi ya da gevşetmedi.",
      },
    ],
    terminalSessionsNote:
      "S129 host effect-protocol, compile ve mevcut QEMU regresyon kaydıdır. Scheduler üzerinde gerçek task öldürme/reaper yürütülmedi; fiziksel veya device işlemi yapılmadı.",
    limitations: [
      "S129 scheduler task seçimi/termination, capability-endpoint/IPC kapanışı, address-space quiesce, frame scrub/reclaim ve ASID-last reaper zincirini yürütmez; bu S130 kabulidir.",
      "K1, MEM1 ve MEM2 COMPLETE değildir. Teardown witness bitleri S129'da yürütücünün kendisi tarafından üretilmez; yalnız authoritative memory audit çağıranın frame-reclaim iddiasını geçersiz kılabilir.",
      "Supervisor event kuyruğu fixed capacity 8'dir; gerçek endpoint transportu ve supervisor recovery politikası bağlı değildir.",
      "Repeated spawn/fault/exit soak ile injected malformed-ELF/page-fault/OOM runtime matrisi açıktır.",
      "S124 archive/promotion STOP kalır. Son fiziksel boot/runtime PASS S92 BOOT8G / CPU1_PER_CPU_TIMER_ONLY; S123 PHYSICAL_BOOT8H=REJECTED_NO_PASS.",
      "CARD_WRITE=0, PHYSICAL_CARD_READBACK=0, SYNC=0, EJECT=0, UART=STOP, POWER=STOP ve PHYSICAL_BOOT8H=STOP.",
    ],
  },