S383 · QEMU S148 first-signal Wake production writer guard integration

/// S148 runtime acceptance: three strict EL0 waiters publish independent
/// notification waits, then the existing global IPC transaction is forced
/// through each possible terminal winner. Signal commits Delivered, exact
/// grant revoke commits Cancelled, and the ordinary deadline service commits
/// TimedOut. Every losing operation is retried before the tasks may run and
/// must observe an already-retired waiter/deadline rather than wake twice.
/// This is a deterministic CPU0 transaction matrix; cross-CPU IPI wake and a
/// generic SMP scheduler remain explicitly outside this narrow admission.
#[cfg(feature = "board-qemu")]
unsafe fn run_qemu_s148_notification_race_arbitration(
    baseline_free_frames: u64,
    baseline_active_allocations: usize,
) {
    use crate::elf::load_and_spawn_user_elf_from_boot_runtime_with_arg;
    use crate::elf_plan::{AddressRange, ElfLoadPolicy};
    use crate::ipc::IpcDeadlineCancellation;
    use crate::ipc_notification::{NotificationSignalOutcome, NotificationWaiter};
    use crate::ui::capability::{CapabilityRights, NotificationAuthorityError};
    use crate::userspace_binaries::NOTIFICATION_RACE_WAITER_BINARY;

    let controller_task = crate::task::current_task_id().expect("S148 controller task");
    let before_deadlines = crate::ipc::ipc_call_deadline_snapshot();
    assert_eq!(before_deadlines.active, 0);

    let signal_domain = crate::mm::with_boot_runtime_memory(|memory| {
        memory.register_domain(QEMU_NOTIFICATION_SIGNAL_RACE_RUNTIME_DOMAIN_ID)
    })
    .expect("S148 signal-winner RuntimeMemory authority")
    .expect("S148 signal-winner domain registration");
    let revoke_domain = crate::mm::with_boot_runtime_memory(|memory| {
        memory.register_domain(QEMU_NOTIFICATION_REVOKE_RACE_RUNTIME_DOMAIN_ID)
    })
    .expect("S148 revoke-winner RuntimeMemory authority")
    .expect("S148 revoke-winner domain registration");
    let timeout_domain = crate::mm::with_boot_runtime_memory(|memory| {
        memory.register_domain(QEMU_NOTIFICATION_TIMEOUT_RACE_RUNTIME_DOMAIN_ID)
    })
    .expect("S148 timeout-winner RuntimeMemory authority")
    .expect("S148 timeout-winner domain registration");

    let signal_notification = crate::ui::capability::mint_notification(controller_task)
        .expect("S148 signal-winner notification root");
    let revoke_notification = crate::ui::capability::mint_notification(controller_task)
        .expect("S148 revoke-winner notification root");
    let timeout_notification = crate::ui::capability::mint_notification(controller_task)
        .expect("S148 timeout-winner notification root");
    let no_forbidden_ranges: [AddressRange; 0] = [];

    // Keep timer delivery disabled until all three CNodes and address spaces
    // exist. Once released, each strict task executes the real v1.3 WAIT SVC.
    let spawn_guard = crate::arch::aarch64::IrqGuard::new();
    let signal_waiter = load_and_spawn_user_elf_from_boot_runtime_with_arg(
        "notification-race-signal-strict-el0-waiter-elf",
        NOTIFICATION_RACE_WAITER_BINARY,
        ElfLoadPolicy::new(
            AddressRange::new(0x0431_0000, 0x0432_0000),
            &no_forbidden_ranges,
            16,
        ),
        0x80d0_0000,
        4,
        0,
        8,
        signal_domain,
        signal_notification.id,
    )
    .expect("S148 strict signal-winner waiter spawn");
    let signal_grant = crate::ui::capability::grant_task_notification_to_task(
        signal_notification,
        controller_task,
        signal_waiter.task_id,
        CapabilityRights::NOTIFICATION_WAIT,
    )
    .expect("S148 exact signal-winner WAIT grant");

    let revoke_waiter = load_and_spawn_user_elf_from_boot_runtime_with_arg(
        "notification-race-revoke-strict-el0-waiter-elf",
        NOTIFICATION_RACE_WAITER_BINARY,
        ElfLoadPolicy::new(
            AddressRange::new(0x0431_0000, 0x0432_0000),
            &no_forbidden_ranges,
            16,
        ),
        0x80d1_0000,
        4,
        0,
        8,
        revoke_domain,
        revoke_notification.id,
    )
    .expect("S148 strict revoke-winner waiter spawn");
    let revoke_grant = crate::ui::capability::grant_task_notification_to_task(
        revoke_notification,
        controller_task,
        revoke_waiter.task_id,
        CapabilityRights::NOTIFICATION_WAIT,
    )
    .expect("S148 exact revoke-winner WAIT grant");

    let timeout_waiter = load_and_spawn_user_elf_from_boot_runtime_with_arg(
        "notification-race-timeout-strict-el0-waiter-elf",
        NOTIFICATION_RACE_WAITER_BINARY,
        ElfLoadPolicy::new(
            AddressRange::new(0x0431_0000, 0x0432_0000),
            &no_forbidden_ranges,
            16,
        ),
        0x80d2_0000,
        4,
        0,
        8,
        timeout_domain,
        timeout_notification.id,
    )
    .expect("S148 strict timeout-winner waiter spawn");
    let timeout_grant = crate::ui::capability::grant_task_notification_to_task(
        timeout_notification,
        controller_task,
        timeout_waiter.task_id,
        CapabilityRights::NOTIFICATION_WAIT,
    )
    .expect("S148 exact timeout-winner WAIT grant");
    let spawned = crate::mm::with_boot_runtime_memory(|memory| memory.audited_snapshot())
        .expect("S148 spawned RuntimeMemory authority")
        .expect("S148 spawned RuntimeMemory audit");
    assert_eq!(spawned.pmm.free_frames, baseline_free_frames - 15);
    assert_eq!(spawned.active_allocations, baseline_active_allocations + 15);
    drop(spawn_guard);

    kprintln!(
        "[K2-S148] signal waiter strict spawn PASS id={} pages={} domain={} notification={} INITIAL_X0=YES W^X=YES",
        signal_waiter.task_id,
        signal_waiter.page_count,
        signal_domain.id(),
        signal_notification.id,
    );
    kprintln!(
        "[K2-S148] revoke waiter strict spawn PASS id={} pages={} domain={} notification={} INITIAL_X0=YES W^X=YES",
        revoke_waiter.task_id,
        revoke_waiter.page_count,
        revoke_domain.id(),
        revoke_notification.id,
    );
    kprintln!(
        "[K2-S148] timeout waiter strict spawn PASS id={} pages={} domain={} notification={} INITIAL_X0=YES W^X=YES",
        timeout_waiter.task_id,
        timeout_waiter.page_count,
        timeout_domain.id(),
        timeout_notification.id,
    );

    let mut all_parked = false;
    for _ in 0..4096 {
        let deadline = crate::ipc::ipc_call_deadline_snapshot();
        let registry = crate::ui::capability::NOTIFICATION_REGISTRY.lock();
        let signal_matches = registry
            .iter()
            .find(|object| object.id() == signal_notification.id)
            .and_then(|object| object.waiter_snapshot())
            == Some(
                NotificationWaiter::try_new(signal_waiter.task_id, signal_grant.generation, 0x3)
                    .expect("S148 exact signal waiter identity"),
            );
        let revoke_matches = registry
            .iter()
            .find(|object| object.id() == revoke_notification.id)
            .and_then(|object| object.waiter_snapshot())
            == Some(
                NotificationWaiter::try_new(revoke_waiter.task_id, revoke_grant.generation, 0x3)
                    .expect("S148 exact revoke waiter identity"),
            );
        let timeout_matches = registry
            .iter()
            .find(|object| object.id() == timeout_notification.id)
            .and_then(|object| object.waiter_snapshot())
            == Some(
                NotificationWaiter::try_new(timeout_waiter.task_id, timeout_grant.generation, 0x3)
                    .expect("S148 exact timeout waiter identity"),
            );
        drop(registry);
        let blocked_counts = {
            #[cfg(feature = "board-rpi5")]
            let s261_scheduler_read_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s260_qemu_acceptance_poll_read_access_guard_expansion::acquire_s261_production_scheduler_read_access()
                .unwrap_or_else(|error| panic!("S261 S148 three-waiter poll scheduler read guard failed closed: {:?}", error));
            let scheduler = &*core::ptr::addr_of!(crate::task::scheduler::SCHEDULER);
            let blocked_counts = [
                scheduler.notification_blocked_task_count_on(
                    signal_waiter.task_id,
                    signal_notification.id,
                ),
                scheduler.notification_blocked_task_count_on(
                    revoke_waiter.task_id,
                    revoke_notification.id,
                ),
                scheduler.notification_blocked_task_count_on(
                    timeout_waiter.task_id,
                    timeout_notification.id,
                ),
            ];
            #[cfg(feature = "board-rpi5")]
            drop(s261_scheduler_read_access);
            blocked_counts
        };
        if deadline.active == 3
            && deadline.registered == before_deadlines.registered + 3
            && signal_matches
            && revoke_matches
            && timeout_matches
            && blocked_counts == [1, 1, 1]
        {
            all_parked = true;
            break;
        }
        crate::task::yield_now();
    }
    assert!(
        all_parked,
        "S148 three notification waits were not admitted"
    );

    let signal_record = crate::ipc::IPC_CALL_DEADLINES
        .lock()
        .object_snapshot(signal_notification.id)
        .expect("S148 signal exact deadline");
    let revoke_record = crate::ipc::IPC_CALL_DEADLINES
        .lock()
        .object_snapshot(revoke_notification.id)
        .expect("S148 revoke exact deadline");
    let timeout_record = crate::ipc::IPC_CALL_DEADLINES
        .lock()
        .object_snapshot(timeout_notification.id)
        .expect("S148 timeout exact deadline");

    // No timer IRQ may interleave between the three controlled first commits
    // and their loser probes. Each operation still takes the production IPC
    // transaction lock internally, exactly as an ordinary SVC/IRQ would.
    let arbitration_guard = crate::arch::aarch64::IrqGuard::new();
    #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
    let s383_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s383_qemu_s148_first_signal_wake_writer_guard_integration::acquire_s383_production_scheduler_writer_access()
        .unwrap_or_else(|error| {
            panic!(
                "S383 QEMU S148 first-signal Wake scheduler writer guard failed closed: {:?}",
                error
            )
        });
    let signal_outcome = (&mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER))
        .notification_signal(signal_notification.id, signal_notification.generation, 0x2);
    #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
    drop(s383_writer_access);
    assert!(matches!(
        signal_outcome,
        Ok(NotificationSignalOutcome::Wake {
            waiter,
            observed: 0x2,
            pending: 0,
        }) if waiter.task_id() == signal_waiter.task_id
    ));

    assert_eq!(
        crate::ui::capability::revoke_notification_grant(revoke_grant, revoke_waiter.task_id,),
        Ok(true)
    );

    let timeout_outcome =
        crate::ipc::service_expired_ipc_call_deadlines(timeout_record.deadline().tick())
            .expect("S148 exact timeout service")
            .expect("S148 timeout-first record was not serviced");
    assert!(matches!(
        timeout_outcome,
        IpcDeadlineCancellation::Notification(cancellation)
            if cancellation.waiter_task == timeout_waiter.task_id
                && cancellation.notification_id == timeout_notification.id
                && cancellation.mask == 0x3
    ));

    // The other two exact deadline records have already been retired by
    // Delivered/Cancelled. Re-offering all three stored deadline ticks cannot
    // select a stale waiter or create a second terminal completion.
    for stale_tick in [
        signal_record.deadline().tick(),
        revoke_record.deadline().tick(),
        timeout_record.deadline().tick(),
    ] {
        assert!(matches!(
            crate::ipc::service_expired_ipc_call_deadlines(stale_tick),
            Ok(None)
        ));
    }
    assert_eq!(
        crate::ui::capability::revoke_notification_grant(signal_grant, signal_waiter.task_id,),
        Ok(false)
    );
    assert_eq!(
        crate::ui::capability::revoke_notification_grant(timeout_grant, timeout_waiter.task_id,),
        Ok(false)
    );
    assert_eq!(
        crate::ui::capability::revoke_notification_grant(revoke_grant, revoke_waiter.task_id,),
        Err(NotificationAuthorityError::StaleAuthority)
    );

    for notification in [
        signal_notification,
        revoke_notification,
        timeout_notification,
    ] {
        #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
        let s382_writer_access = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s382_qemu_s148_post_arbitration_signal_writer_guard_integration::acquire_s382_production_scheduler_writer_access()
            .unwrap_or_else(|error| {
                panic!(
                    "S382 QEMU S148 post-arbitration signal scheduler writer guard failed closed: {:?}",
                    error
                )
            });
        assert_eq!(
            (&mut *core::ptr::addr_of_mut!(crate::task::scheduler::SCHEDULER)).notification_signal(
                notification.id,
                notification.generation,
                0x8
            ),
            Ok(NotificationSignalOutcome::Coalesced { pending: 0x8 })
        );
        #[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
        drop(s382_writer_access);
        assert_eq!(
            crate::ui::capability::destroy_notification_object(notification, controller_task),
            Ok(1)
        );
    }

    let after_arbitration = crate::ipc::ipc_call_deadline_snapshot();
    assert_eq!(after_arbitration.active, 0);
    assert_eq!(
        after_arbitration.registered - before_deadlines.registered,
        3
    );
    assert_eq!(after_arbitration.delivered - before_deadlines.delivered, 1);
    assert_eq!(after_arbitration.cancelled - before_deadlines.cancelled, 1);
    assert_eq!(after_arbitration.timed_out - before_deadlines.timed_out, 1);
    assert_eq!(after_arbitration.peer_closed, before_deadlines.peer_closed);
    assert_eq!(after_arbitration.replied, before_deadlines.replied);
    drop(arbitration_guard);

    let mut peers_reclaimed = false;
    for _ in 0..4096 {
        let signal_quota = crate::mm::with_boot_runtime_memory(|memory| {
            memory.audited_domain_quota(signal_domain)
        })
        .expect("S148 signal-domain quota authority")
        .expect("S148 signal-domain quota audit");
        let revoke_quota = crate::mm::with_boot_runtime_memory(|memory| {
            memory.audited_domain_quota(revoke_domain)
        })
        .expect("S148 revoke-domain quota authority")
        .expect("S148 revoke-domain quota audit");
        let timeout_quota = crate::mm::with_boot_runtime_memory(|memory| {
            memory.audited_domain_quota(timeout_domain)
        })
        .expect("S148 timeout-domain quota authority")
        .expect("S148 timeout-domain quota audit");
        if signal_quota.allocated_frames == 0
            && revoke_quota.allocated_frames == 0
            && timeout_quota.allocated_frames == 0
        {
            peers_reclaimed = true;
            break;
        }
        crate::task::yield_now();
    }
    assert!(
        peers_reclaimed,
        "S148 strict race waiters did not reclaim exactly"
    );

    let final_snapshot = crate::mm::with_boot_runtime_memory(|memory| memory.audited_snapshot())
        .expect("S148 final RuntimeMemory authority")
        .expect("S148 final RuntimeMemory audit");
    assert_eq!(final_snapshot.pmm.free_frames, baseline_free_frames);
    assert_eq!(
        final_snapshot.active_allocations,
        baseline_active_allocations
    );
    assert!(!crate::ui::capability::NOTIFICATION_REGISTRY
        .lock()
        .iter()
        .any(|object| {
            object.id() == signal_notification.id
                || object.id() == revoke_notification.id
                || object.id() == timeout_notification.id
        }));

    kprintln!(
        "[K2-S148] signal_notification={} revoke_notification={} timeout_notification={} signal_waiter={} revoke_waiter={} timeout_waiter={} signal_domain={} revoke_domain={} timeout_domain={} ABI=UNCHANGED_V1_3 ARBITER=IPC_TRANSACTION_LOCK MATRIX=ALL_6_PERMUTATIONS_HOST AT_EXACT_DEADLINE=3 SIGNAL_FIRST=DELIVERED REVOKE_FIRST=CANCELLED TIMEOUT_FIRST=TIMED_OUT REGISTERED=3 DELIVERED=1 CANCELLED=1 TIMED_OUT=1 PEER_CLOSED=0 REPLIED=0 WAKE_TOTAL=3 LOSER_RETRY=STALE EXACT_ONCE=YES ALL_STRICT=YES RECLAIM=15 NOTIFICATION_CLEANUP=3 free={}->{}->{} active={}->{}->{} KERNEL_FAULTS=0 EXECUTOR=PASS",
        signal_notification.id,
        revoke_notification.id,
        timeout_notification.id,
        signal_waiter.task_id,
        revoke_waiter.task_id,
        timeout_waiter.task_id,
        signal_domain.id(),
        revoke_domain.id(),
        timeout_domain.id(),
        baseline_free_frames,
        spawned.pmm.free_frames,
        final_snapshot.pmm.free_frames,
        baseline_active_allocations,
        spawned.active_allocations,
        final_snapshot.active_allocations,
    );
    run_qemu_s149_ipc_deadline_saturation_recovery();
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn acquire_s383_production_scheduler_writer_access(
) -> Result<G8lS383ProductionSchedulerWriterAccess, 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(G8lS383ProductionSchedulerWriterAccess { _access: access })
}

#[test]
fn boundary_has_exactly_one_s383_acquire_and_release_pair() {
    let boundary = first_signal_boundary();
    assert_eq!(
        boundary
            .matches("acquire_s383_production_scheduler_writer_access")
            .count(),
        1
    );
    assert_eq!(boundary.matches("drop(s383_writer_access)").count(), 1);
}

  {
    id: "g8l-s383-qemu-s148-first-signal-wake-writer-guard-integration-partial",
    date: "2026-08-29",
    sequence: 383,
    status: "passed",
    umbrella_status: "partial",
    title:
      "S383 · QEMU S148 first-signal Wake production writer guard integration",
    summary:
      "S383, run_qemu_s148_notification_race_arbitration içindeki source-order ilk ve exact Wake bekleyen notification_signal(signal_notification.id, signal_notification.generation, 0x2) mutable scheduler sınırını S382 ile 44 production reader'ın kullandığı aynı statik S247 state word'e bağlar. Nonzero controller identity, controller-owned üç notification root'u, üç strict EL0 WAIT grant'i, üç exact waiter identity'si, blocked-task sayıları ve üç deadline kaydı mevcut outer arbitration IRQ guard ile writer'dan önce tamamlanır. Gerçek per-CPU kimliğiyle CPU0-only S383 exclusive writer yeni mutable aliasından önce alınır; exact tek SCHEDULER aliası signal-root id/generation ve immutable 0x2 bitlerini notification_signal helper'ına taşır. Owned NotificationSignalOutcome writer release sınırını geçer; exact Wake { waiter=signal_waiter, observed: 0x2, pending: 0 } doğrulaması release sonrasında yapılır. Revoke-first commit bundan sonra gelir; timeout-first, stale probe'lar ve S382 post-arbitration Coalesced signal ayrı memberships olarak kalır. Tarihsel S313 yalnız writer-authority audit'idir ve production authority olarak yeniden kullanılmaz. Guarded writer 56/69, açık writer 13, provider authority 0 ve whole-scheduler exclusion false'dur. S148 fixture board-qemu, wrapper RPi5-only olduğundan supported-profile direct caller/runtime observation=0 açıkça korunur.",
    evidence: [
      "İlk canonical focused komut ayrı S383 module/source registration ve production first-signal Wake boundary yokken compile RED verdi; S383 tarihsel S313 kartına veya S382'ye topluca eklenmedi.",
      "İlk RED exit 101 verdi; log 2113 B / 181fda4b7a2f8f230a543c599575010f1624ae9cbccf417a3a4b0b1992996f60 SHA-256'dır.",
      "RED exact eksiklikleri ayrı sınıfladı: kernel S383 modülü yoktu, simulation export'u yoktu ve S148 first-signal production membership taşımıyordu.",
      "İlk production focused koşusu 43/43 PASS verdi; log 3495 B / d3958c84b2c3fdb0059cb71c9739cc0e38c12f20d22d354583acc7efa111769d SHA-256'dır.",
      "cargo fmt --all ve cargo fmt --all -- --check exit 0 verdi; format çıktısı boş ve global format GREEN'dir.",
      "Final canonical focused koşu CARGO_INCREMENTAL=0 ile 43/43 PASS / 0 fail verdi; log 3495 B / 88ff1a3c4ed550b9d0b12f70e300d33c72d77fc115d1e7297269ad7ea8b048c4 SHA-256'dır.",
      "Ürün, coverage, source-order veya authority assertion'ı gevşetilmedi; ilk compile RED ve ilk production PASS tarihçesi final PASS ile silinmez.",
      "S383 modülü S382 typed preflight outcome'unu yeniden doğrular; inherited 44 reader + 55 guarded writer + 14 open writer snapshot'ı saparsa InventoryDrift ile fail-closed kapanır.",
      "S383 başarı outcome'u FiftySixthWriterGuardedAwaitingRemaining'dir ve exact 44 guarded reader + 56/69 guarded writer + 13 open writer envanterini sabitler.",
      "Production wrapper exact target_arch=aarch64, target_os=none, feature=board-rpi5 cfg kesişimindedir; host executor production runtime observation diye sunulmaz.",
      "acquire_s383_production_scheduler_writer_access gerçek try_current_cpu_id sonucunu kullanır; caller-supplied production CPU parametresi yoktur ve CPU0 dışı InvalidCpu verir.",
      "Writer lease S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE üzerinde try_acquire_exclusive_for_valid_cpu ile alınır; yeni static veya ikinci exclusion domain yaratılmaz.",
      "Host executor callback'i exact bir kez çağırır; canlı reader veya writer callback'ten önce ExclusiveBusy üretir, invalid CPU fail-closed kapanır ve callback error RAII lease'i bırakır.",
      "S382 ve S383 token'ları aynı shared gate üzerinde monoton ve ayrıdır; iki kapı tek transaction, range dispatcher veya Kod kartı değildir.",
      "Exact production/source giriş sınırı kernel/src/main.rs içindeki run_qemu_s148_notification_race_arbitration fonksiyonudur; başka QEMU fixture'ları S383 coverage'ına katılmaz.",
      "Nonzero controller task identity'si S383 writer'dan önce kurulur ve controller scheduler'da current olarak doğrulanır.",
      "Signal-first, revoke-first ve timeout-first için üç ayrı controller-owned normal Notification root'u writer öncesinde mint edilir; object id ve generation'lar birbirine karıştırılmaz.",
      "Üç strict EL0 WAIT grant'i exact waiter task owner'larına bağlanır; grant provenance, generation ve WAIT rights writer'dan önce kanıtlanır.",
      "Üç waiter identity'si nonzero, controller'dan ve birbirinden ayrıdır; source-order ilk signal yalnız signal-first waiter'ı uyandırabilir.",
      "Üç waiter blocked state'i ve notification wait queue bağları S383 üyeliğinden önce kurulur; S383 yeni waiter park etmez.",
      "Üç deadline kaydı writer'dan önce IPC deadline registry'ye yerleştirilir; signal-first Wake exact deadline cancel yolunu kullanır.",
      "Mevcut arbitration_guard first-signal, revoke-first, timeout-first ve cleanup sınırını kapsar; S383 bu outer IRQ domain'i yeniden yaratmaz.",
      "acquire_s383_production_scheduler_writer_access exact yeni mutable SCHEDULER aliasından önce ve outer IRQ guard aktifken çağrılır.",
      "Exact tek alias notification_signal(signal_notification.id, signal_notification.generation, 0x2) çağrısını taşır; 0x2 bitleri nonzero ve immutable'dır.",
      "S383 writer membership yalnız helper çağrısını kapsar; controller/grant/wait/deadline proof'ları veya downstream assertion lease içine alınmaz.",
      "Helper transaction signaler'ın live task-owned SIGNAL authority'sini, normal notification object shape'ini ve exact generation'ı yeniden doğrular.",
      "Helper nonzero bits doğrulamasından sonra exact waiter'ı queue'dan çıkarır ve deadline kaydını cancel eder.",
      "Helper waiter CNode/grant bağını revalidate eder; stale generation, revoked grant veya yanlış owner commit'e erişemez.",
      "Helper exact waiter task state'ini Ready yapar ve ready queue wake commit'ini aynı IRQ/IPC transaction içinde tamamlar.",
      "Owned NotificationSignalOutcome S383 lease'i bırakılmadan oluşturulur fakat caller doğrulaması için by-value olarak release sınırını geçer.",
      "drop(s383_writer_access) exact helper çağrısından sonra ve Wake assertion'ından önce gelir; assertion sırasında shared writer tutulmaz.",
      "Release sonrası exact Ok(Wake { waiter=signal_waiter, observed: 0x2, pending: 0 }) beklenir; Coalesced veya başka task/bits/pending fail-closed assertion üretir.",
      "Revoke-first revoke_notification_grant commit'i exact Wake kontrolünden sonradır ve S383 writer membership'ine katılmaz.",
      "Timeout-first deadline advancement ve timeout commit'i S383'ten sonradır; signal-first writer timeout kararını sahiplenmez.",
      "Stale generation ve revoked capability probe'ları ayrı source-order sınırlarıdır; S383 bunları canlı authority veya runtime writer saymaz.",
      "S382 final-loop post-arbitration Coalesced signal daha aşağıdadır ve kendi acquire/release çiftini korur; S383 token'ı S382 loop'una taşınmaz.",
      "Tarihsel S313 first-signal Wake writer-authority audit'i model/source preflight kanıtıdır; S383 gerçek production membership'i sequence kimliğini veya tarihsel 69-open snapshot'ını değiştirmez.",
      "S376 normal EL0 notification signal syscall membership'idir; S148 QEMU fixture aliasını sahiplenmez ve S383 sonucu farklıdır.",
      "CPU1 coverage service timer zincirinde S382'den sonra ve tarihsel S242 sender service'ten önce S383 preflight'ını yürütür; S245 view yalnız inspect edilir.",
      "Coverage service request take etmez, S244 whole-scheduler admission yayımlamaz, writer acquire etmez ve provider authority oluşturmaz.",
      "S148 fixture yalnız feature=board-qemu altında derlenir; S383 production acquire satırları aynı öğede yalnız feature=board-rpi5 altında etkinleşir.",
      "Desteklenen profil matrisi board-qemu ile board-rpi5'i birlikte çalıştırmadığından exact source seam hiçbir desteklenen profilde runtime invoke edilmiş sayılmaz.",
      "Bu cfg ayrımı gizlenmez: supported-profile runtime observations=0 ve production direct supported caller paths=0'dır; host executor yalnız shared-gate davranışını kanıtlar.",
      "Seçili regresyon tarihsel S312/S313, S376, komşu S381/S382, yeni S383 ve üç notification runtime grubunu seri çalıştırdı.",
      "Final seçili regresyon 9 grup / 233/233 PASS / 0 fail verdi; log 23678 B / c38dff8c62e993a22297a746116b385fa0438702af277a7067e1b78bf5acf9c9 SHA-256'dır.",
      "S238–S383 dependency listesi 147 gruptur; iki bağımsız seri koşunun her biri 3532/3532 PASS / 0 fail verdi.",
      "İki kanonik dependency özeti 31628 B ve 6d13a5bbb0df33602168538358f5cf02c408a3b232ea75f3d9f33aafbb8af4ca SHA-256 ile byte-eşittir.",
      "Exact yedi frozen G8h assertion dışındaki seri workspace 346 sonuç grubu / 5406 PASS / 0 fail / 7 filtered verdi.",
      "Filtered workspace log 535111 B / f0bd58a4baac47ae5fa7f265ede968ab3879cbb8b253c11198347b066acf45ad; summary 26176 B / 463ed14cae0160f419857a9b60cb7b58ad6d8190cd1a710218c77c0677e38e06 SHA-256'dır.",
      "Filtresiz workspace exit 101 ile yalnız frozen S96 wiring_does_not_mutate_timer_gic_boot_or_expand_runtime_scope reddinde durdu: 299 grup / 5151 PASS / 1 fail; global workspace GREEN iddia edilmez.",
      "Filtresiz log 503461 B / 35476fcbd9ccdcb2bd2d724410adb958f28280eee2c050fcd55258488d0ec8bd; summary 22650 B / fe6ca0eb74de1cad4f76372c5cf263e3ee892ca9409560562bbe6cbd20f25f00 SHA-256'dır.",
      "Fresh dev AArch64 profilleri 4/4 exit 0 verdi; önceki release denemeleri canonical profil kanıtına katılmadı.",
      "board-qemu log 112202 B / c048932f6d07ebad94d7571f365ae1388aa98b7d3ace9298e6b1ce852ba1829c, 293 warning header; ELF 16812880 B / 9a67957a8d6b623f5a3572ae9988f3f407ad3e5662d99e28bfafa7949405bc7d'dir.",
      "board-rpi4 log 150994 B / 2f6d96a2bf6b2adede5e8d58b2d2e426f0ed37aa27f20827d519ed62b5961dde, 391 warning header; ELF 11925528 B / 2be50d38e7794dcedda7dbf5be1541b6a702978276d4e6c8bd8f31c534b3ebc5'dir.",
      "board-rpi5 log 638954 B / 42f6086469a59619333e33a6cb1d414db3993a444fc90afc4ed726a1183bd1d3, 1458 warning header; ELF 15226456 B / c93d8642e666f55667d27e058cb9b2f94421d029fe04b17d0554961f7e58ff78'dir.",
      "board-rpi5+smp log 638577 B / ed43e107dfb1dbe5bb47c5bfdce88e7cb2257fdc9c2c44269ab269ddd5b9588e, 1458 warning header; ELF 15233416 B / 13113c44775a0d43e4babedd03a95487b691fa43035f7718807f6c2a193d09a3'dır. Zero-warning iddiası yoktur.",
      "CARGO_INCREMENTAL=0 make verify-qemu exit 0 verdi. 116354 B log / 1fe7748b8722f466bd5697fefb8c84c3d91215dc59b6e239e518811ab38090a1 SHA-256 ile W^X 31/31, S130–S154+S271, RuntimePmm, EL0x4096, IPC 20/20 ve scheduler SEC5 PASS'tir.",
      "Ortak board-qemu regresyonu RPi5-only S383 wrapper invocation kanıtı değildir; supported-profile runtime observation=0 kalır.",
      "Source-bound Kod hedefi S1–S383 383/383 ayrı kapı, pre-S328 S1–S327 327/327, missing=none ve duplicate=0'dır.",
      "S383 Code kartı tam run_qemu_s148_notification_race_arbitration Rust öğesi içinde yalnız first-signal upstream identity/root/grant/waiter/deadline→outer IRQ→writer→single alias→owned outcome→release→exact Wake→revoke-first sınırını yayımlar.",
      "Ayrı S383 guard modülü, focused test, proof ve exact Operations object'i kendi source excerpt'leriyle yayımlanır; her excerpt repository path, satır aralığı, file SHA-256 ve snippet SHA-256 taşır.",
      "S1–S327 tarihsel kapılar Operations sequence kimliğiyle 327/327 ayrı kart olarak korunur; S328 öncesi kayıtlar generic placeholder içinde birleştirilmez veya S328 kartına eklenmez.",
      "S313, S376, S382 ve S384 kartları S383 kod kutusuna katılmaz; sequence başına exact bir kart ve unique kaynak bağı zorunludur.",
      "İlk source-bound registry S1–S383 aralığında 383/383 unique kapı, 1100 exact excerpt, pre-S328 S1–S327 327/327, missing=none ve duplicate=0 üretti; JSON 8435019 B / ba142a0f90598f42294f37174303fee1260c3e881ad59be41a03d6a0076d14ae dosya SHA-256 ve 4ca4e8264f7e82246fc98f1bf91befda2fd34a40db91dea75679f337d5207319 registry SHA-256 taşır.",
      "İlk website kabulü 685/685 test, lint PASS, TypeScript exit 0 ve 0 B çıktı, 24/24 static page, 202 export dosyası ve Timeline/yol-haritasi 222 ayrı gate-policy kartı verdi.",
      "İlk website test logu 63708 B / 69ec32468f90d60218d8e23c860043c6cb46e71f834475264166cc5f86951cac, lint 218 B / 79c084453e339ceb2efe76ed96d1d68be8ac51442957a7a048fd17dba3067ba2, TypeScript 0 B / e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ve build 1213 B / 1cdb9c544b02ea567aaabef6f31158e0e1b101f4d49b5f8b5c92d412af924217 SHA-256'dır.",
      "S383 core Operations policy'si ilk yayında 18292 karakter / 18790 UTF-8 byte ölçüldü; tek satırlık özet değil, kaynak/guard/test/proof/publication ayrımı taşıyan kanıt-yoğun karttır.",
      "İlk production/main deployment c4ff0681-4f8a-44b3-b86a-1b0306c1a850 ile 117 uploaded + 84 existing = 201 asset olarak tamamlandı; deploy logu 1821 B / 6f8aa178291ea20307cc5eea3775bfbd568d9c5945e2b32c5a7546accf163e3b SHA-256'dır.",
      "İlk cache-busted custom-domain readback dört rotada HTTP 200 ve raw byte-exact PASS verdi: /code/ 23787411 B / 00645e720b2c794c54eb0c21c2eca22ced4d84a60e908642c4ec20d3a0c8a96d, /operations/ 14046336 B / 9558225c52d9bd70f56adb8723ccbcaca20c197b45d1a381bb5e1061429b120b, /timeline/ 5690327 B / b8c7c75c32fb4efecfe9cf83974d972e70943b7257fc9c62e95e3f3649559828 ve /yol-haritasi/ 5690075 B / 1aeed9e1f1c53734cb54c517daa56ebad49091fc9e69339b899f97958480a3ad SHA-256'dır.",
      "İlk canlı /code/ no-transform header'ı taşıdı; literal kart sayımı 383/383, pre-S328 327/327, duplicate=0, S1=1, S327=1, S328=1, S382=1, S383=1 ve S384=0'dır.",
      "S383 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_S383=NO.",
      "S383 bazlı bağlayıcı olmayan planlama görünümü R1 S383–S413, R2 S438–S488, R3 S567+, kaba S543–S593 ve risk paylı merkez yaklaşık S568'dir; ürün veya sıra taahhüdü değildir.",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s383_qemu_s148_first_signal_wake_writer_guard_integration -- --test-threads=1",
      "run S312, S313, S376, S381, S382, S383 and three notification runtime groups serially",
      "run four fresh isolated dev AArch64 profiles; run S238-S383 dependency list twice; run filtered and unfiltered serial workspace audits; CARGO_INCREMENTAL=0 make verify-qemu",
      "python3 scripts/render-project-status.py --write && python3 scripts/render-project-status.py --check; cargo test -p aselsan_microkernel_simulation --test project_status_manifest -- --test-threads=1",
      "npm run code:generate && npm test && npm run lint && npx tsc --noEmit && npm run build",
      "npm run deploy; cache-busted curl + raw cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
    ],
    terminalSessions: [
      {
        id: "g8l-s383-focused-source-contract",
        title: "S383 focused QEMU S148 first-signal Wake writer membership",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s383_qemu_s148_first_signal_wake_writer_guard_integration -- --test-threads=1",
        ],
        outputLines: [
          "initial result: compile RED; separate S383 module/source registration and production first-signal boundary absent",
          "first production result: ok; S383 focused 1 group / 43 passed / 0 failed",
          "final result: ok; S383 focused 1 group / 43 passed / 0 failed",
          "shared S247 gate: 44 guarded readers + 56/69 guarded writers; 13 writers open",
          "identity/roots/grants/waiters/deadlines + outer IRQ < S383 writer < one signal alias < owned outcome < release < exact Wake < revoke-first",
          "historical S313 authority audit and S382 post-arbitration Coalesced membership remain separate",
          "board-qemu fixture and RPi5-only wrapper do not intersect in a supported runtime profile; observations=0",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s383-selected-notification-regression",
        title:
          "S383 selected notification arbitration and lifecycle regression",
        commandLines: [
          "run S312, S313, S376, S381, S382, S383, ipc_notification_deadline_runtime, ipc_notification_lifecycle_runtime and ipc_notification_race_runtime serially",
        ],
        outputLines: [
          "result: 9 groups / 233 passed / 0 failed",
          "historical S312 post-arbitration and S313 first-Wake audits remain separate",
          "S376 EL0 signal, S381 QueueFull and S382 post-arbitration memberships remain distinct",
          "S383 owns only the source-order first signal Wake scheduler alias",
          "three runtime groups preserve deadline, revoke/destroy and six-order arbitration semantics",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s383-full-acceptance",
        title: "S383 four-profile, dependency, workspace and QEMU acceptance",
        commandLines: [
          "run four fresh isolated dev AArch64 profile builds",
          "run S238-S383 dependency list twice and normalize timing fields",
          "run filtered and unfiltered serial workspace audits",
          "CARGO_INCREMENTAL=0 make verify-qemu",
        ],
        outputLines: [
          "four profiles 4/4 exit 0; log and ELF byte/hash measurements recorded separately",
          "dependency 147 groups / 3532/3532 twice; normalized 31628-byte summaries are SHA-256 identical",
          "filtered workspace 346 groups / 5406 PASS / 7 filtered; unfiltered frozen-S96 remains RED",
          "QEMU W^X 31/31 + S130-S154 + S271 + IPC 20/20 + SEC5 PASS; not an S383 runtime observation",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "g8l-s383-production-publication",
        title: "S383 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 + raw cmp for /code/, /operations/, /timeline/ and /yol-haritasi/",
        ],
        outputLines: [
          "target registry: S1-S383 383/383 unique gates; pre-S328 S1-S327 327/327; missing=none; duplicate=0",
          "initial registry: S1-S383 383/383 unique gates / 1100 exact excerpts; pre-S328 S1-S327 327/327; missing=none; duplicate=0",
          "website tests 685/685 PASS; lint PASS; TypeScript exit 0 with empty output; static routes 24/24",
          "export files=202; Timeline/yol-haritasi gate cards=222; initial S383 core policy=18292 chars / 18790 bytes",
          "initial deployment c4ff0681-4f8a-44b3-b86a-1b0306c1a850; 117 upload + 84 existing",
          "custom-domain /code/, /operations/, /timeline/ and /yol-haritasi/ HTTP 200 and byte-exact=true; code no-transform=true",
          "live code=383/383; pre-S328=327/327; S1/S327/S328/S382/S383=1; S384=0; duplicate=0",
        ],
        exitCode: 0,
        outputMode: "complete",
        outputNote:
          "Bu oturum ilk S383 production publication ölçümlerini taşır; bu ölçümlerin metne işlendiği evidence-sync deployment ayrı kabul kanıtıdır.",
      },
    ],
    terminalSessionsNote:
      "TAM ÇIKTI kayıtları S383 focused 43/43, seçili 9 grup / 233 PASS, iki kez 147 grup / 3532 PASS, filtreli workspace 346 grup / 5406 PASS, filtresiz yalnız frozen-S96 RED, dört dev AArch64 profil 4/4 ve ortak QEMU kabulünü ayrı oturumlar halinde taşır. İlk /code registry ve canlı readback S1–S383 aralığını 383/383 ayrı source-bound kart, S1–S327 tarihsel kapsamını 327/327 tekil, missing=none ve duplicate=0 olarak doğruladı; ilk production deployment c4ff0681-4f8a-44b3-b86a-1b0306c1a850'dir.",
    limitations: [
      "S383 yalnız run_qemu_s148_notification_race_arbitration içindeki source-order first-signal Wake sınırını kapatır; S384 post-lifecycle stale signal ve kalan 13 writer açıktır.",
      "S148 board-qemu fixture ile RPi5-only writer cfg aynı desteklenen profilde kesişmediği için production runtime invocation gözlenmedi.",
      "Production provider authority, whole-scheduler exclusion, supported-profile end-to-end admission ve generic SMP henüz yoktur.",
      "Fiziksel cihaz işlemi yapılmadı; S383 bir güç/UART/raw/archive/promotion kapısı değildir.",
    ],
  },