/*
 * kido-resonate.c — Kido agent signaling on the resonant mesh.
 *
 * Scheduler tasks are transmitter-agents. transmit() addresses a
 * frequency band; every tuned task evaluates its own Lorentzian eta;
 * delivery is gated at the half-power threshold. The neural-dynamics
 * loop is honored structurally: release -> resonance response ->
 * receiver state change (queue + counters) -> reuptake (recv frees).
 *
 * STATIC TABLES ONLY. No kido-alloc (fenced by Gate order). No
 * scheduler internals beyond the public kido_sched_task() observer.
 * No interrupts: delivery is synchronous, consumption is polled.
 *
 * TESTING: KIDO_HOSTED_TEST builds the portable core.
 *  gcc -std=c11 -Wall -Wextra -Werror -DKIDO_HOSTED_TEST \
 *      -DKIDO_RESONATE_SELFTEST modules/kido-sched.c modules/kido-alloc.c \
 *      modules/kido-image.c modules/kido-reloc.c modules/kido-resonate.c \
 *      -o /tmp/kido-resonate-test
 * (kido-alloc.c joined the link when the scheduler's fence was fulfilled,
 * 2026-10-14 — the scheduler's stacks are allocator clients now.)
 */

#include "kido-resonate.h"

/* ------------------------------------------------------------------ */
/* Static state. One entry per scheduler slot; indexed by task id.     */
/* ------------------------------------------------------------------ */

typedef struct kido_rx_queue {
    kido_signal_t slots[KIDO_RESONATE_QUEUE_DEPTH];
    uint32_t      head;   /* dequeue index */
    uint32_t      count;  /* occupied slots */
} kido_rx_queue_t;

static uint32_t     s_band[KIDO_SCHED_MAX_TASKS];
static uint32_t     s_q[KIDO_SCHED_MAX_TASKS];
static kido_rx_queue_t s_queue[KIDO_SCHED_MAX_TASKS];
static uint32_t     s_rx_delivered[KIDO_SCHED_MAX_TASKS];
static uint32_t     s_rx_rejected[KIDO_SCHED_MAX_TASKS];
static uint32_t     s_rx_dropped[KIDO_SCHED_MAX_TASKS];
static uint32_t     s_tx_sent[KIDO_SCHED_MAX_TASKS];
static uint64_t   (*s_timer_ticks)(void);  /* NULL = tolerated, stamp 0 */

/* Mesh outbox: deferred, UNEVALUATED signals. FIFO ring; static, the
 * allocator stays fenced. eta is computed at drain time, so entries
 * carry no eta and no arrival stamp — both are delivery-time facts. */
typedef struct kido_mesh_entry {
    uint32_t source_id;
    uint32_t dest_band_hz;
    uint32_t type;
    uint32_t strength_permille;
    uint32_t freq_hz;
} kido_mesh_entry_t;

static kido_mesh_entry_t s_outbox[KIDO_RESONATE_OUTBOX_DEPTH];
static uint32_t s_outbox_head;     /* dequeue index */
static uint32_t s_outbox_count;    /* occupied slots */
static uint32_t s_deferred_total;  /* accepted into the mesh, all time */
static uint32_t s_mesh_dropped;    /* refused at the door: outbox full */
static uint32_t s_dissipated;      /* drained with no tuned listener */

/* Task must exist and not be EMPTY. */
static int task_live(uint32_t id)
{
    const kido_task_t *t;
    if (id >= KIDO_SCHED_MAX_TASKS)
        return 0;
    t = kido_sched_task(id);
    if (t == NULL)
        return 0;
    return t->state != KIDO_TASK_EMPTY;
}

kido_status_t kido_resonate_init(const kido_hal_t *hal)
{
    uint32_t i;
    if (hal == NULL)
        return KIDO_ERR_EARLY_ENV;
    for (i = 0; i < KIDO_SCHED_MAX_TASKS; i++) {
        s_band[i]          = KIDO_BAND_UNTUNED;
        s_q[i]             = 0u;
        s_queue[i].head    = 0u;
        s_queue[i].count   = 0u;
        s_rx_delivered[i]  = 0u;
        s_rx_rejected[i]   = 0u;
        s_rx_dropped[i]    = 0u;
        s_tx_sent[i]       = 0u;
    }
    /* NULL timer tolerated (P5 convention): arrivals stamp 0. */
    s_timer_ticks = hal->timer_ticks;
    s_outbox_head    = 0u;
    s_outbox_count   = 0u;
    s_deferred_total = 0u;
    s_mesh_dropped   = 0u;
    s_dissipated     = 0u;
    return KIDO_OK;
}

kido_status_t kido_resonate_tune(uint32_t task_id, uint32_t band_hz,
                                 uint32_t q)
{
    if (!task_live(task_id))
        return KIDO_ERR_EARLY_ENV;
    s_band[task_id] = band_hz;
    s_q[task_id]    = q;
    return KIDO_OK;
}

float kido_resonate_eta(uint32_t q, uint32_t f_rx_hz, uint32_t f_tx_hz)
{
    float detune, x;
    if (f_rx_hz == 0u)
        return 0.0f;  /* untuned receiver binds nothing; no div-by-zero */
    if (q == 0u)
        return 1.0f;  /* unselective receiver: the Lorentzian's limit */
    /* eta = 1 / (1 + (2*Q*(f_tx - f_rx)/f_rx)^2). Signed detune is
     * fine: it is squared. float: AArch64 mandates FP (see header). */
    detune = (float)((int64_t)f_tx_hz - (int64_t)f_rx_hz);
    x = (2.0f * (float)q * detune) / (float)f_rx_hz;
    return 1.0f / (1.0f + x * x);
}

/* One evaluation path for both delivery modes (no duplicated truth).
 * Evaluates every candidate receiver for one signal: for a band, tasks
 * tuned to it; for BROADCAST, every tuned task. Each computes its own
 * eta against CURRENT tuning; >= threshold -> queued (DELIVERED),
 * < threshold -> REJECTED, full queue -> DROPPED. Returns the number of
 * candidate receivers evaluated (0 = nobody was listening).
 * now_ticks stamps arrival at the moment of DELIVERY. */
static uint32_t mesh_deliver_entry(uint32_t src_id, uint32_t dest_band_hz,
                                   uint32_t type, uint32_t strength_permille,
                                   uint32_t freq_hz, uint64_t now_ticks,
                                   uint32_t *delivered_out,
                                   uint32_t *rejected_out,
                                   uint32_t *dropped_out)
{
    uint32_t i, candidates = 0u;
    for (i = 0; i < KIDO_SCHED_MAX_TASKS; i++) {
        const kido_task_t *t = kido_sched_task(i);
        float eta;
        kido_rx_queue_t *q;
        uint32_t tail;
        if (t == NULL || t->state == KIDO_TASK_EMPTY)
            continue;
        if (s_band[i] == KIDO_BAND_UNTUNED)
            continue;  /* not participating; not a rejection */
        if (dest_band_hz != KIDO_BAND_BROADCAST && s_band[i] != dest_band_hz)
            continue;  /* not addressed; not a rejection */
        candidates++;
        eta = kido_resonate_eta(s_q[i], s_band[i], freq_hz);
        if (eta < KIDO_RESONATE_DELIVERY_THRESHOLD) {
            s_rx_rejected[i]++;
            (*rejected_out)++;
            continue;  /* detuned: loud, counted, never silent */
        }
        q = &s_queue[i];
        if (q->count >= KIDO_RESONATE_QUEUE_DEPTH) {
            s_rx_dropped[i]++;
            (*dropped_out)++;
            continue;  /* passed resonance, nowhere to store: loud */
        }
        tail = (q->head + q->count) % KIDO_RESONATE_QUEUE_DEPTH;
        q->slots[tail].source_id         = src_id;
        q->slots[tail].dest_band_hz      = dest_band_hz;
        q->slots[tail].type              = type;
        q->slots[tail].strength_permille = strength_permille;
        q->slots[tail].freq_hz           = freq_hz;
        q->slots[tail].arrival_ticks     = now_ticks;
        q->slots[tail].eta               = eta;
        q->count++;
        s_rx_delivered[i]++;
        (*delivered_out)++;
    }
    return candidates;
}

kido_status_t kido_resonate_transmit(uint32_t src_id, uint32_t dest_band_hz,
                                     uint32_t type, uint32_t strength_permille,
                                     uint32_t freq_hz,
                                     uint32_t *delivered_out,
                                     uint32_t *rejected_out,
                                     uint32_t *dropped_out)
{
    uint32_t delivered = 0u, rejected = 0u, dropped = 0u;
    uint64_t now;
    if (!task_live(src_id))
        return KIDO_ERR_EARLY_ENV;
    if (strength_permille > 1000u)
        return KIDO_ERR_EARLY_ENV;
    if (delivered_out == NULL || rejected_out == NULL || dropped_out == NULL)
        return KIDO_ERR_EARLY_ENV;

    /* One release-moment stamp for the whole call (v1 stamped per
     * receiver; no test distinguishes, and one release has one time). */
    now = (s_timer_ticks != NULL) ? s_timer_ticks() : 0u;
    mesh_deliver_entry(src_id, dest_band_hz, type, strength_permille,
                       freq_hz, now, &delivered, &rejected, &dropped);
    s_tx_sent[src_id]++;
    *delivered_out = delivered;
    *rejected_out  = rejected;
    *dropped_out   = dropped;
    return KIDO_OK;
}

kido_status_t kido_resonate_defer(uint32_t src_id, uint32_t dest_band_hz,
                                  uint32_t type, uint32_t strength_permille,
                                  uint32_t freq_hz,
                                  uint32_t *accepted_out,
                                  uint32_t *dropped_out)
{
    kido_mesh_entry_t *e;
    uint32_t tail;
    if (!task_live(src_id))
        return KIDO_ERR_EARLY_ENV;
    if (strength_permille > 1000u)
        return KIDO_ERR_EARLY_ENV;
    if (accepted_out == NULL || dropped_out == NULL)
        return KIDO_ERR_EARLY_ENV;
    if (s_outbox_count >= KIDO_RESONATE_OUTBOX_DEPTH) {
        s_mesh_dropped++;
        *accepted_out = 0u;
        *dropped_out  = 1u;
        return KIDO_OK;  /* refused at the door: loud, counted */
    }
    tail = (s_outbox_head + s_outbox_count) % KIDO_RESONATE_OUTBOX_DEPTH;
    e = &s_outbox[tail];
    e->source_id         = src_id;
    e->dest_band_hz      = dest_band_hz;
    e->type              = type;
    e->strength_permille = strength_permille;
    e->freq_hz           = freq_hz;
    s_outbox_count++;
    s_deferred_total++;
    s_tx_sent[src_id]++;  /* a send is a send */
    *accepted_out = 1u;
    *dropped_out  = 0u;
    return KIDO_OK;
}

kido_status_t kido_resonate_drain(uint32_t *delivered_out,
                                  uint32_t *rejected_out,
                                  uint32_t *dropped_out)
{
    uint32_t delivered = 0u, rejected = 0u, dropped = 0u;
    if (delivered_out == NULL || rejected_out == NULL || dropped_out == NULL)
        return KIDO_ERR_EARLY_ENV;
    while (s_outbox_count > 0u) {
        kido_mesh_entry_t e = s_outbox[s_outbox_head];
        uint64_t now = (s_timer_ticks != NULL) ? s_timer_ticks() : 0u;
        uint32_t candidates;
        s_outbox_head = (s_outbox_head + 1u) % KIDO_RESONATE_OUTBOX_DEPTH;
        s_outbox_count--;
        /* eta against CURRENT tuning (radio semantics); arrival
         * stamped at drain — arrival means arrival at the receiver. */
        candidates = mesh_deliver_entry(e.source_id, e.dest_band_hz,
                                        e.type, e.strength_permille,
                                        e.freq_hz, now,
                                        &delivered, &rejected, &dropped);
        if (candidates == 0u)
            s_dissipated++;  /* nobody listening: consumed, counted */
    }
    *delivered_out = delivered;
    *rejected_out  = rejected;
    *dropped_out   = dropped;
    return KIDO_OK;
}

void kido_resonate_courier(void *arg)
{
    uint32_t d, r, dr;
    (void)arg;
    for (;;) {
        /* drain() fails only on NULL outs; ours are valid. The status
         * is deliberately unchecked: there is nothing louder to do
         * with it inside the courier loop. */
        (void)kido_resonate_drain(&d, &r, &dr);
        kido_sched_yield();
    }
}

kido_status_t kido_resonate_mesh_stats(kido_resonate_mesh_stats_t *out)
{
    if (out == NULL)
        return KIDO_ERR_EARLY_ENV;
    out->outbox_pending = s_outbox_count;
    out->deferred_total = s_deferred_total;
    out->mesh_dropped   = s_mesh_dropped;
    out->dissipated     = s_dissipated;
    return KIDO_OK;
}

kido_status_t kido_resonate_recv(uint32_t task_id, kido_signal_t *out,
                                 uint8_t *got_out)
{
    kido_rx_queue_t *q;
    if (!task_live(task_id))
        return KIDO_ERR_EARLY_ENV;
    if (out == NULL || got_out == NULL)
        return KIDO_ERR_EARLY_ENV;
    q = &s_queue[task_id];
    if (q->count == 0u) {
        *got_out = 0u;
        return KIDO_OK;
    }
    *out = q->slots[q->head];  /* reuptake: slot frees on dequeue */
    q->head = (q->head + 1u) % KIDO_RESONATE_QUEUE_DEPTH;
    q->count--;
    *got_out = 1u;
    return KIDO_OK;
}

kido_status_t kido_resonate_stats(uint32_t task_id,
                                  kido_resonate_stats_t *out)
{
    if (!task_live(task_id))
        return KIDO_ERR_EARLY_ENV;
    if (out == NULL)
        return KIDO_ERR_EARLY_ENV;
    out->band_hz      = s_band[task_id];
    out->q            = s_q[task_id];
    out->rx_delivered = s_rx_delivered[task_id];
    out->rx_rejected   = s_rx_rejected[task_id];
    out->rx_dropped    = s_rx_dropped[task_id];
    out->tx_sent       = s_tx_sent[task_id];
    out->pending       = s_queue[task_id].count;
    return KIDO_OK;
}

/* ------------------------------------------------------------------ */
/* Hosted self-test. Runs the REAL signaling core on the dev machine.  */
/* ------------------------------------------------------------------ */
#ifdef KIDO_RESONATE_SELFTEST
#ifndef KIDO_HOSTED_TEST
#error "KIDO_RESONATE_SELFTEST needs KIDO_HOSTED_TEST."
#endif

#include <stdio.h>

/* Test-local kido_halt: the resonate tests never drive yield/run, so the
 * halt path is unreachable here; the symbol exists for the linker. */
void kido_halt(kido_status_t code)
{
    (void)code;
}

static int s_checks = 0;
static int s_failures = 0;

#define CHECK(cond) do { \
    s_checks++; \
    if (!(cond)) { s_failures++; \
        printf("[FAIL] line %d: %s\n", __LINE__, #cond); } \
} while (0)

/* Fake HAL: timer ticks a counter so arrival stamps are observable. */
static uint64_t s_fake_ticks = 1000u;
static uint64_t fake_ticks(void) { s_fake_ticks += 7u; return s_fake_ticks; }
static uint32_t fake_hz(void)    { return 1000u; }
static void fake_putc(char c)    { (void)c; }
static void fake_puts(const char *s) { (void)s; }

static void t_body(void *arg) { (void)arg; }

int main(void)
{
    kido_hal_t hal;
    kido_signal_t sig;
    kido_resonate_stats_t st;
    uint32_t d, r, dr, id0, id1, id2, i;
    uint8_t got;

    hal.console_putc = fake_putc;
    hal.console_puts = fake_puts;
    hal.timer_ticks  = fake_ticks;
    hal.timer_hz    = fake_hz;

    /* 1. init guards */
    CHECK(kido_resonate_init(NULL) == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_init(&hal) == KIDO_OK);

    /* Scheduler must be up for task liveness. */
    CHECK(kido_sched_init(&hal) == KIDO_OK);
    CHECK(kido_sched_create(t_body, NULL, "tx", &id0) == KIDO_OK);
    CHECK(kido_sched_create(t_body, NULL, "rx515", &id1) == KIDO_OK);
    CHECK(kido_sched_create(t_body, NULL, "rx555", &id2) == KIDO_OK);

    /* tune guards */
    CHECK(kido_resonate_tune(99u, 515u, 10u) == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_tune(id1, 515u, 10u) == KIDO_OK);
    CHECK(kido_resonate_tune(id2, 555u, 50u) == KIDO_OK);

    /* 2. eta unit checks */
    CHECK(kido_resonate_eta(10u, 515u, 515u) == 1.0f);       /* exact match */
    CHECK(kido_resonate_eta(0u, 515u, 999u) == 1.0f);        /* Q=0: unselective */
    CHECK(kido_resonate_eta(10u, 0u, 515u) == 0.0f);         /* untuned: no div0 */
    {   /* half-power point: detune = f/(2Q) = 515/20 = 25.75 -> eta = 0.5 */
        float e = kido_resonate_eta(10u, 515u, 541u);        /* detune 26 */
        CHECK(e < 0.5f && e > 0.49f);
        e = kido_resonate_eta(10u, 515u, 540u);              /* detune 25 */
        CHECK(e >= 0.5f && e < 0.52f);
    }

    /* 3. tuned delivery: exact band + freq match */
    CHECK(kido_resonate_transmit(id0, 515u, 7u, 800u, 515u, &d, &r, &dr)
          == KIDO_OK);
    CHECK(d == 1u && r == 0u && dr == 0u);
    CHECK(kido_resonate_recv(id1, &sig, &got) == KIDO_OK && got == 1u);
    CHECK(sig.source_id == id0 && sig.dest_band_hz == 515u && sig.type == 7u);
    CHECK(sig.strength_permille == 800u && sig.freq_hz == 515u);
    CHECK(sig.eta == 1.0f && sig.arrival_ticks > 0u);
    CHECK(kido_resonate_recv(id1, &sig, &got) == KIDO_OK && got == 0u);

    /* 4. detuned rejection: 515 Hz into the 555/Q=50 receiver */
    CHECK(kido_resonate_transmit(id0, 555u, 1u, 500u, 515u, &d, &r, &dr)
          == KIDO_OK);
    CHECK(d == 0u && r == 1u && dr == 0u);
    CHECK(kido_resonate_recv(id2, &sig, &got) == KIDO_OK && got == 0u);

    /* 5. threshold edges: Q=10, f_rx=515 -> 540 delivers, 541 rejects */
    CHECK(kido_resonate_transmit(id0, 515u, 2u, 500u, 540u, &d, &r, &dr)
          == KIDO_OK && d == 1u && r == 0u);
    CHECK(kido_resonate_recv(id1, &sig, &got) == KIDO_OK && got == 1u);
    CHECK(kido_resonate_transmit(id0, 515u, 3u, 500u, 541u, &d, &r, &dr)
          == KIDO_OK && d == 0u && r == 1u);

    /* 6. forge constant honored. Note: id1 is tuned to 515, so it
     * receives its own transmission — honest pub/sub bus semantics. */
    CHECK(KIDO_RESONATE_FORGE_HZ == 515u);
    CHECK(kido_resonate_tune(id0, KIDO_RESONATE_FORGE_HZ, 10u) == KIDO_OK);
    CHECK(kido_resonate_transmit(id1, KIDO_RESONATE_FORGE_HZ, 9u, 1000u,
                                 KIDO_RESONATE_FORGE_HZ, &d, &r, &dr)
          == KIDO_OK && d == 2u);

    /* 7. broadcast: 515-task delivers, high-Q 531-task rejects */
    {
        uint32_t id3;
        CHECK(kido_sched_create(t_body, NULL, "rx531", &id3) == KIDO_OK);
        CHECK(kido_resonate_tune(id3, 531u, 100u) == KIDO_OK);
        CHECK(kido_resonate_transmit(id1, KIDO_BAND_BROADCAST, 4u, 600u,
                                     515u, &d, &r, &dr) == KIDO_OK);
        /* id1: 515/10 exact -> delivered; id2: 555/50 detune 40 ->
         * (2*50*40/555)^2 = 51.9 -> eta .019 -> rejected;
         * id3: 531/100 detune 16 -> (2*100*16/531)^2 = 36.3 ->
         * eta .027 -> rejected; id0: forge-tuned 515/10 -> delivered */
        CHECK(d == 2u && r == 2u && dr == 0u);
    }

    /* 8. queue-full drops are loud. Move id0 off 515 so only id1
     * receives band-515 traffic, and drain id1 first for exact counts. */
    CHECK(kido_resonate_tune(id0, 600u, 10u) == KIDO_OK);
    while (kido_resonate_recv(id1, &sig, &got) == KIDO_OK && got == 1u) { }
    for (i = 0; i < KIDO_RESONATE_QUEUE_DEPTH; i++) {
        CHECK(kido_resonate_transmit(id0, 515u, 5u, 100u, 515u, &d, &r, &dr)
              == KIDO_OK && d == 1u);
    }
    CHECK(kido_resonate_transmit(id0, 515u, 5u, 100u, 515u, &d, &r, &dr)
          == KIDO_OK && d == 0u && dr == 1u);
    CHECK(kido_resonate_stats(id1, &st) == KIDO_OK);
    CHECK(st.rx_dropped == 1u && st.pending == KIDO_RESONATE_QUEUE_DEPTH);

    /* 9. untuned task never receives, even broadcast */
    {
        uint32_t id4;
        CHECK(kido_sched_create(t_body, NULL, "quiet", &id4) == KIDO_OK);
        /* id4 never tuned */
        CHECK(kido_resonate_transmit(id0, KIDO_BAND_BROADCAST, 6u, 100u,
                                     515u, &d, &r, &dr) == KIDO_OK);
        CHECK(kido_resonate_recv(id4, &sig, &got) == KIDO_OK && got == 0u);
    }

    /* 10. arg validation is loud */
    CHECK(kido_resonate_transmit(99u, 515u, 1u, 100u, 515u, &d, &r, &dr)
          == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_transmit(id0, 515u, 1u, 1001u, 515u, &d, &r, &dr)
          == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_transmit(id0, 515u, 1u, 100u, 515u, NULL, &r, &dr)
          == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_recv(99u, &sig, &got) == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_recv(id1, NULL, &got) == KIDO_ERR_EARLY_ENV);
    CHECK(kido_resonate_stats(99u, &st) == KIDO_ERR_EARLY_ENV);

    /* 11. stats honesty */
    CHECK(kido_resonate_stats(id0, &st) == KIDO_OK);
    CHECK(st.tx_sent > 0u && st.band_hz == 600u);  /* retuned in test 8 */
    CHECK(kido_resonate_stats(id2, &st) == KIDO_OK);
    CHECK(st.rx_rejected >= 1u && st.rx_delivered == 0u);

    /* 12. deferred delivery at yield (D2 refinement). Re-init the mesh;
     * scheduler tasks persist; bands/queues/counters/outbox reset. */
    CHECK(kido_resonate_init(&hal) == KIDO_OK);
    {
        uint32_t idA, idB, acc, drp, dd, rr, drd, i;
        kido_resonate_mesh_stats_t ms;
        CHECK(kido_sched_create(t_body, NULL, "dfrA", &idA) == KIDO_OK);
        CHECK(kido_sched_create(t_body, NULL, "dfrB", &idB) == KIDO_OK);

        /* 12a. door arg guards are loud */
        CHECK(kido_resonate_defer(99u, 515u, 1u, 100u, 515u, &acc, &drp)
              == KIDO_ERR_EARLY_ENV);
        CHECK(kido_resonate_defer(idA, 515u, 1u, 1001u, 515u, &acc, &drp)
              == KIDO_ERR_EARLY_ENV);
        CHECK(kido_resonate_defer(idA, 515u, 1u, 100u, 515u, NULL, &drp)
              == KIDO_ERR_EARLY_ENV);
        CHECK(kido_resonate_defer(idA, 515u, 1u, 100u, 515u, &acc, NULL)
              == KIDO_ERR_EARLY_ENV);
        CHECK(kido_resonate_drain(NULL, &rr, &drd) == KIDO_ERR_EARLY_ENV);
        CHECK(kido_resonate_mesh_stats(NULL) == KIDO_ERR_EARLY_ENV);

        /* 12b. defer accepted; the receiver sees nothing until drain */
        CHECK(kido_resonate_tune(idB, 515u, 10u) == KIDO_OK);
        CHECK(kido_resonate_defer(idA, 515u, 11u, 800u, 515u, &acc, &drp)
              == KIDO_OK);
        CHECK(acc == 1u && drp == 0u);
        CHECK(kido_resonate_recv(idB, &sig, &got) == KIDO_OK && got == 0u);
        CHECK(kido_resonate_mesh_stats(&ms) == KIDO_OK);
        CHECK(ms.outbox_pending == 1u && ms.deferred_total == 1u);

        /* 12c. drain delivers; arrival stamped at drain */
        CHECK(kido_resonate_drain(&dd, &rr, &drd) == KIDO_OK);
        CHECK(dd == 1u && rr == 0u && drd == 0u);
        CHECK(kido_resonate_recv(idB, &sig, &got) == KIDO_OK && got == 1u);
        CHECK(sig.source_id == idA && sig.type == 11u && sig.eta == 1.0f);
        CHECK(sig.arrival_ticks > 0u);

        /* 12d. eta evaluated at DRAIN time (radio semantics): the
         * receiver's tuning at drain — not at defer — decides. Q is
         * varied with the band held constant, so this pins true
         * selectivity, not band addressing. */
        CHECK(kido_resonate_tune(idB, 515u, 100u) == KIDO_OK);  /* narrow */
        CHECK(kido_resonate_defer(idA, 515u, 12u, 800u, 520u, &acc, &drp)
              == KIDO_OK && acc == 1u);  /* 520 Hz rejects at Q=100 */
        CHECK(kido_resonate_tune(idB, 515u, 10u) == KIDO_OK);   /* widen */
        CHECK(kido_resonate_drain(&dd, &rr, &drd) == KIDO_OK);
        CHECK(dd == 1u && rr == 0u);   /* heard with the new, wider ears */
        CHECK(kido_resonate_defer(idA, 515u, 13u, 800u, 520u, &acc, &drp)
              == KIDO_OK && acc == 1u);
        CHECK(kido_resonate_tune(idB, 515u, 100u) == KIDO_OK);  /* narrow */
        CHECK(kido_resonate_drain(&dd, &rr, &drd) == KIDO_OK);
        CHECK(dd == 0u && rr == 1u);   /* detuned at drain -> rejected */
        CHECK(kido_resonate_tune(idB, 515u, 10u) == KIDO_OK);
        while (kido_resonate_recv(idB, &sig, &got) == KIDO_OK && got == 1u) { }

        /* 12e. outbox full: the door refusal is loud and counted */
        for (i = 0; i < KIDO_RESONATE_OUTBOX_DEPTH; i++) {
            CHECK(kido_resonate_defer(idA, 515u, 20u, 100u, 515u,
                                      &acc, &drp) == KIDO_OK && acc == 1u);
        }
        CHECK(kido_resonate_defer(idA, 515u, 20u, 100u, 515u, &acc, &drp)
              == KIDO_OK);
        CHECK(acc == 0u && drp == 1u);
        CHECK(kido_resonate_mesh_stats(&ms) == KIDO_OK);
        CHECK(ms.mesh_dropped == 1u);
        CHECK(ms.outbox_pending == KIDO_RESONATE_OUTBOX_DEPTH);
        /* drain the 32: idB's queue holds 8 -> 8 delivered, 24 dropped */
        CHECK(kido_resonate_drain(&dd, &rr, &drd) == KIDO_OK);
        CHECK(dd == 8u && drd == 24u && rr == 0u);

        /* 12f. unheard signal dissipates: counted, never silent */
        CHECK(kido_resonate_init(&hal) == KIDO_OK);  /* idB untuned now */
        CHECK(kido_resonate_defer(idA, 515u, 30u, 100u, 515u, &acc, &drp)
              == KIDO_OK && acc == 1u);
        CHECK(kido_resonate_drain(&dd, &rr, &drd) == KIDO_OK);
        CHECK(dd == 0u && rr == 0u && drd == 0u);
        CHECK(kido_resonate_mesh_stats(&ms) == KIDO_OK);
        CHECK(ms.dissipated == 1u && ms.outbox_pending == 0u
              && ms.deferred_total == 1u);

        /* 12g. tx_sent counts accepted defers (the re-init reset it;
         * only the 12f defer stands since) */
        CHECK(kido_resonate_stats(idA, &st) == KIDO_OK);
        CHECK(st.tx_sent == 1u);
    }

    printf("[test] kido-resonate: %d checks, %d failures\n",
           s_checks, s_failures);
    return s_failures == 0 ? 0 : 1;
}
#endif /* KIDO_RESONATE_SELFTEST */
