# Kido module map (2026-10-14)

Planned modules for the outer kernel. Status per module.

| Module        | Purpose                                              | Status  |
|---------------|------------------------------------------------------|---------|
| kido-boot     | power-on -> first adaptive breath (this session)     | DRAFT   |
| kido-hal      | bare-metal driver tables (UART, timer per board); RPi4 UART LANDED 2026-10-23: AUX mini-UART (uart1) init sequence + polled TX are REAL — the session-2 loud stub is closed. 8-write sequence (AUX enable, CNTL=0, IER=0, LCR=3, MCR=0, BAUD=541, GPIO14/15->ALT5 RMW, CNTL=3), 115200 @ named 500 MHz VPU bet (config.txt core_freq_min=500; rpi4os pairing); board table now init+putc hooks (qemu-virt init NULL = firmware-owned); WRITTEN NOT EXECUTED ON HARDWARE (hosted scratch-register double pins order+values, 19-check self-test); unknown board still loud NO_CONSOLE | DRAFT (arm64) |
| kido-entry    | power-on entry: EL drop, stack/BSS, bootinfo, boot call | DRAFT (arm64) |
| kido-mem      | physical memory discovery + allocator seed; DTB-EXTENT TRIM LANDED 2026-10-21: discover removes the firmware blob's own [dtb, dtb+totalsize) from every region before selection/publication (interior split / head / tail / drop; no-overlap no-op; overflow/bound loud); seed list is usable-by-construction, KIDO_MEM_MAX_REGIONS 8->16 (still static/bounded); hosted injector kido_mem_test_set_dtb_extent (vacuous default); /memreserve/ interior rule unchanged; measured on QEMU virt: DTB at [0x44000000, 0x44100000), 128MiB region split into 64MiB+63MiB, clean boot, zero exceptions; UEFI DISCOVERY LANDED 2026-10-23: the no-DTB path is real — parses the GetMemoryMap descriptor array (v1, little-endian manual loads, no struct casts) through the same pipeline shape (parse+classify -> sort -> coalesce -> map-buffer trim via the shared trimmer -> largest-wins -> shared kido_mem_publish); type law: Conventional + BootServices code/data seeded (EBS caller contract), loader/ACPI-reclaim/persistent/reserved/runtime/MMIO/PAL/unknown excluded-declared; overlap/overflow/version/stride/ragged/>64 fail loud; zero-page no-op; self-test 100/100 (50 pre-existing DTB checks pin the publish-extraction regression byte-identical + 50 new UEFI checks incl. a real-address buffer-trim split) | DRAFT   |
| kido-alloc    | first-fit free-list allocator (sched's stack backing)| DRAFT   |
| kido-sched    | cooperative round-robin, allocator-backed stacks (fence fulfilled); TEARDOWN LANDED 2026-10-21: kido_sched_destroy() — teardown at rest, frees every scheduler-owned stack via kido_free (first production caller of free; closes session-6 D1), table back to EMPTY, scheduler to never-initialized; refuses LOUD (EARLY_ENV) over READY/RUNNING tasks, before init, or twice — refusal precedes any free (table+allocator untouched); allocator + image carve-out NOT sched's property, left alone (post-destroy stats: allocs==frees, bytes 0, carve intact); free-then-clear per slot with fail-stop; additive only, no asm touched; hosted self-test 110/110 (35 new checks §§50-59) | DRAFT |
| kido-resonate | resonant-mesh agent signaling (import://resonant-mesh); D2 CLOSED 2026-10-20: deferred delivery at yield — defer() (unevaluated mesh outbox, 32-deep static) + drain() (delivery at the caller's pace, eta at drain, arrival stamped at drain) + kido_resonate_courier (canonical drain/yield task, public API only — zero scheduler hooks, the fence stands) + mesh stats (pending/deferred_total/mesh_dropped/dissipated). Synchronous transmit() bit-identical (one shared evaluation path); kido_signal_t unchanged (interop untouched). | DRAFT |
| kido-interop  | Kido<->BUBO protocol + doll-layer placement (2026-10-15) | DRAFT |
| kido-image    | kernel-image bounds (linker symbols) -> allocator reservation; closes sched D2 (2026-10-16) | DRAFT |
| kido-reloc | relocation detection + phase-2 adaptation + phase-3 self-relocation (PROVEN 2026-10-20, session 18): entry-.S manifest walker over the named .rela.dyn (R_AARCH64_RELATIVE, wrap-guarded, two carve-outs: probe-constant section + .S literal-pool range), BSS zero at actual bounds, five-slot BSS report; verify() policy flip gated on the build-time audit stamp (defaults CLOSED — a relocated image under the closed gate refuses with correct addresses); bounds inversion (linked = actual - delta). PROOFS: object gate (23 relocs, 8 allowlisted ABS64, disassembly matches .S instruction-for-instruction); audit PASS 14/5/9 on all three link addresses; QEMU virt/cortex-a57 — delta-0 proceed, +0x80000 PROCEED, -0x80000 PROCEED (each breath -> ABCABCABCABC, zero exceptions), gate-closed +0x80000 refuses silent (zero exceptions). Two draft bugs caught at the gate and fixed: linker-script manifest bounds via ADDR/SIZEOF (in-section `.` blind to generated size); finding-4 REFUTED (literal-pool words DO carry RELATIVEs — range carve-out prevents a double-add boot-killer on _stack_top/_bss_start/_bss_end). Tree left WITHOUT the stamp (gate-closed is the honest default; stamp generated per build). | DRAFT (phase-3 proven) |
| kido-mmu | ARM64 stage-1 MMU, static identity map (DRAFT 2026-10-22, session 22): 4 KiB granule, 39-bit VA (T0SZ=25), walk from L1; largest-fitting blocks (L1 1 GiB / L2 2 MiB / L3 4 KiB), exact coverage; 16-page bounded static tables in BSS — 4 KiB ALIGNMENT load-bearing (`__attribute__((aligned))`; the self-test caught bit-6 masking from a misaligned array); MAIR {0x00 device-nGnRnE, 0xFF normal WBWA}; pure-C TCR (0x200993519) + MAIR (0xFF00); enable sequence TLBI->TTBR0->TCR->MAIR->DSB/ISB->SCTLR|=M\|C\|I->ISB (WRITTEN, NOT ASSEMBLED, NEVER EXECUTED — no toolchain; hosted double records order+values). Caller-supplied map, no kido-mem/HAL coupling. Call-site seam DECLARED not wired (after kido_reloc_verify OK, before kido_boot — future Gate item; the relocator runs MMU-off). Hosted self-test 121/121. | DRAFT |
| kido-mbox | BCM2711 VideoCore mailbox, property-tags channel 8 (DRAFT 2026-10-24, session 25): base 0xFE00B880, READ 0x00 / STATUS0 0x18 (EMPTY) / WRITE1 0x20 / STATUS1 0x38 (FULL); single static 16-byte-aligned BSS buffer, one in-flight call, no allocator/timer/HAL dependency; get-clock-rate tag 0x00030002, packet [clock_id, rate_hz]; five validations (mail echo, success bit, tag echo, length 8, clock echo + nonzero rate) all loud EARLY_ENV with *hz untouched; bounded polls, never infinite; HAL seam DECLARED not wired (future HAL init: kido_mbox_vpu_hz() -> BAUD = hz/(8*115200)-1; HAL keeps its named 500 MHz constant until a Pi4 run confirms the query). VPU id 5 carried from the firmware clock table, NOT re-verified this session — first Pi4 run must show a sane rate before HAL adoption. WRITTEN, NOT EXECUTED ON HARDWARE; hosted self-test 33/33 against a scripted VideoCore double. | DRAFT |
| kido-pl011 | PrimeCell UART (PL011) driver: init (baud divisor from a caller-supplied clock), polled TX/RX (DRAFT 2026-10-24, session 26): registers per TRM DDI 0183 (DR 0x00 / FR 0x18 / IBRD 0x24 / FBRD 0x28 / LCR_H 0x2C / CR 0x30 / IMSC 0x38 / DMACR 0x48); divisor = clk/(16*baud) in uint64 with TRM +0.5 rounding and IBRD-carry; 8N1+FEN, IMSC=0 (polled, no GIC yet), DMACR=0; RX split poll()-flag vs bounded getc(); DR error bits OE/BE/PE/FE rejected with ECR clear, never delivered; bounded polls everywhere (1<<20), no new header codes. Bases: QEMU virt 0x09000000 @ 24 MHz verified, RPi4 uart0 0xFE201000 verified — but NO Pi4 UART clock constant named (unverified; candidate source mbox clock id 2, unconfirmed). Stateless + idempotent init; putc works firmware-configured without init (HAL's current QEMU use, preserved). NOT wired into the HAL (Gate item); HAL's static kido_pl011_putc helper untouched — name overlap flagged, legal by linkage (static vs global), rewire must delete the helper. WRITTEN, NOT EXECUTED ON HARDWARE; hosted self-test 49/49 against a scripted UART double (divisor table 24M/115200=13,1; 24M/9600=156,16; 48M/115200=26,3). | DRAFT |
| kido-gic | GICv2 interrupt controller, distributor + CPU interface, UP, Group0 routing (DRAFT 2026-10-25, session 27): registers per IHI 0048B (GICD CTLR 0x000 / TYPER 0x004 / ISENABLER 0x100 / ICENABLER 0x180 / ISPENDR 0x200 / ICPENDR 0x280 / ISACTIVER 0x300 / ICACTIVER 0x380 / IPRIORITYR 0x400 / ITARGETSR 0x800 / ICFGR 0xC00 / SGIR 0xF00; GICC CTLR 0x000 / PMR 0x004 / BPR 0x008 / IAR 0x00C / EOIR 0x010); init (distributor off -> SPI targets CPU0 -> enables/pending/active cleared -> PMR 0xFF, BPR 0, CPU CTLR 1 -> distributor CTLR 1); enable/disable, priority byte RMW, target byte RMW (SPI only — SGI/PPI targets RO), config 2-bit RMW (SPI only), pending/trigger/clear, SGI send (explicit list only), static 1020-slot handler table, dispatch owns EOIR always (full IAR echo for SGI CPUID) except spurious 1023 (no EOIR); IRQ bound from TYPER ITLinesNumber capped at 1020 sources. Bases: QEMU virt dist 0x08000000 / cpu 0x08010000 verified; NO Pi4 GIC base named (unverified). NOT wired into any vector table (Gate item: exception-vector module owns VBAR + DAIF + the IRQ stub). SGI-PROVEN ON QEMU (scratch harness, /tmp only): console SKIG, one IRQ taken, one clean exception return, zero fault entries, Group0 rung validated first try (C1 ladder stops at rung 1); SPI delivery through a real device NOT proven. Hosted self-test 115/115 against a scripted GIC double (register file + set/clear semantics + IAR arbitration). | DRAFT |
| kido-vec | ARM64 exception-vector module: VBAR_EL1 table + DAIF controls + IRQ stub -> kido_gic_dispatch (DRAFT 2026-10-25, session 28): table 2048-aligned, 16 entries x 128 bytes (EL1t / EL1h / EL0-64 / EL0-32, Sync/IRQ/FIQ/SErr each); only IRQ EL1h (entry 5) is live — full 256-byte frame save x0-x30, dispatch, restore, eret; all 15 other entries stash vector index + ESR_EL1 in BSS and spin (no EL0, no EL1t stack, no FIQ source in the Group0 config); install via adr (PC-relative, zero .rela.dyn entries by design, to be confirmed by disassembly); DAIF enable/disable/masked query, no status codes (cannot fail at EL1); install order law install -> GIC init -> IRQ enable last (VBAR undefined at reset). NOT wired into entry/kido_main (Gate item); session-27 scratch stub is the sketch this promotes, not the module. PROVEN 2026-10-27 (session 31): the committed table ran under QEMU virt — VBAR readback == table address, 5 IRQs through entry 5 with 5 clean returns, zero faults (deliberations/2026-10-27-qemu-irq-proof.log). The session-27 scratch-stub qualifier is retired. | DRAFT |
| kido-timer | ARM Generic Timer driver, EL1 physical (DRAFT 2026-10-26, session 29): CNTFRQ_EL0 read-only (never written; 0 = NO_TIMER, the existing code), CNTPCT_EL0 count, CNTP_CTL_EL0 (ENABLE/IMASK/ISTATUS), CNTP_CVAL_EL0 one-shot compare; API init/hz/now/arm_ticks/arm_us/disarm/mask/unmask/pending; CVAL-only arming (TVAL documented, never written); zero/sub-tick/wrap arms refused loud; pending() reports the SIGNAL (ENABLE and not IMASK and condition met), not the raw ISTATUS bit; IRQ identity PPI 30 declared for the GIC/vec wiring (NOT wired — Gate item). HAL keeps its session-2 probe (reads are ownerless); this driver owns arming. PROVEN 2026-10-27 (session 31): PPI-30 delivery on QEMU virt — exactly one timer IRQ, handler disarm, clean return (T1:1). Scheduler-tick policy still a Gate item. | DRAFT |
| kido-serial-irq | Interrupt-driven PL011 RX (DRAFT 2026-10-26, session 30): GIC handler drains the UART RX FIFO into a static 256-byte ring; init order handler -> level config -> GIC enable -> UART unmask (IFLS 1/4 trigger, IMSC RXIM, ICR clear), stop reverses it and keeps the ring; error bytes discarded + ECR cleared + counted, full ring drops + counted, per-invocation drain bounded by the 16-deep FIFO; consumer API non-blocking (available() flag, getc() drain, empty = EARLY_ENV); owns a declared 5-register IRQ window (DR/FR/IMSC/IFLS/ICR/RSR, DDI 0183) while kido-pl011 keeps init/baud/TX/polled RX — the window exists because pl011's double feed is static inside its own self-test TU and unreachable otherwise. SPI 33 named (QEMU virt); NO Pi4 UART0 IRQ named (unverified). PROVEN 2026-10-27 (session 31): SPI delivery on QEMU virt — "KIDO" injected over the socket chardev arrived in the ring byte-identical (ST:4), clean returns, zero faults. Boot-path wiring still a Gate item. | DRAFT |
| kido-psci | ARM PSCI conduit, SMC only (DRAFT 2026-10-27, session 32): DEN0022 0.2 core (VERSION 0x84000000, CPU_SUSPEND 0xC4000001 SMC64, CPU_OFF 0x84000002, CPU_ON 0xC4000003 SMC64, AFFINITY_INFO 0xC4000004 SMC64, SYSTEM_OFF 0x84000008, SYSTEM_RESET 0x84000009) + 1.0 FEATURES probe (0x8400000A, version-gated); version encoding major<<16\|minor (0.2 = 0x00000002); error map NOT_SUPPORTED -> STUB_REACHED, all other negatives -> EARLY_ENV, AFFINITY_INFO states (0 ON / 1 OFF / 2 ON_PENDING) are not errors; power_state and affinity passed through opaque (platform firmware data, never invented); SYSTEM_OFF/SYSTEM_RESET/CPU_OFF never return on success — hosted double records and returns OK by stated divergence. MIGRATE family NOT offered (no Trusted OS to migrate); HVC conduit + 1.1 functions (SYSTEM_RESET2/CPU_FREEZE/SYSTEM_SUSPEND) named futures. WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 15th data point); hosted self-test 48/48 against a scripted firmware double (4-CPU stand-in table, values 0..3, NOT MPIDR format). NOT wired into the boot path (Gate item: init cannot detect a missing monitor — an SMC with no monitor faults). | DRAFT |
| kido-smp | Secondary-CPU bring-up policy on top of PSCI CPU_ON (DRAFT 2026-10-28, session 33): 8-slot static table, caller-supplied 16 KiB stacks (no allocator coupling); bring_up order guards -> duplicate scan -> reserve + mailbox write -> cpu_on (slot index as context_id) -> bounded AFFINITY_INFO poll -> STARTED; two phases (STARTED = firmware reports ON, ARRIVED = stub called secondary_arrived); per-slot BSS stack-top mailbox kido_smp_secondary_stack_top[slot] for the future stub (PC-relative load, no C call before SP exists); release/wait_release (spin-bound, no timer dependency); secondary_off propagates psci_cpu_off and marks nothing (never returns on bare-metal success); query re-reads firmware truth (ARRIVED/STARTED -> OFF only on firmware OFF). No "off another CPU" API (PSCI has none); no new header codes. Secondary entry stub DECLARED, not built (Gate item, contract in kido-smp.h). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 16th data point); hosted self-test 56/56 driving the REAL psci API against psci.c's scripted double (ON_PENDING-transient + poll-timeout paths code-reviewed, not hosted-proven — the double reports ON immediately). | DRAFT |
| kido-sync | SMP spinlock, the exclusion primitive session 33's secondaries lacked (DRAFT 2026-10-28, session 34): caller-embedded 16-byte struct {word, magic, owner}, no allocator, no scheduler coupling, leaf module (depends on kido-boot.h codes only); ARM64 LDAXR/STLXR acquire/release pair with SEVL/WFE/SEV (WFE only on the observed-held branch — a failed STLXR retries immediately, never through WFE); hosted __atomic_compare_exchange_n / __atomic_store_n proving the state machine exactly; owner law (MPIDR_EL1 raw on ARM64, hosted injector on hosted; stranger unlock and free-lock unlock refuse EARLY_ENV, state untouched); contention is not failure (try_lock returns OK + acquired 0, no new header codes); init refuses a held lock; lock() spins by definition with the dead-holder law stated; IRQ law (no IRQ masking — CPU-to-CPU exclusion only). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 17th data point); hosted self-test 49/49 incl. injector-proven stranger refusal. First consumer (scheduler/Gate wiring, smp shared-state guard) is a Gate item. |
| kido-barrier | SMP rendezvous barrier, the starting-line primitive sync's secondaries lacked (DRAFT 2026-10-29, session 35): caller-embedded struct {spinlock, arrived, generation, participants, magic}, no allocator, no scheduler coupling, leaf module (depends on kido-sync public API + kido-boot.h codes only); generation counter + arrival counter under one spinlock — last arriver resets arrived then bumps generation under the lock, waiters spin on an acquire load of generation (LDAR on ARM64, __atomic acquire on hosted), unlock's release orders the bump before any waiter that observes it (no DMB claimed); participants 1..8 matching KIDO_SMP_MAX_CPUS; init refuses a round in flight and preserves generation monotonic (never reset); deadlock law (no timeout — a timeout would release a partial group, silent corruption); IRQ law (no wait from IRQ context that preempted a participant); caller contract one call per participant per round (double-arrive counts twice, stated not detected); no new header codes. WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 18th data point); hosted self-test 53/53 incl. a real 4-thread 2-round pthread rendezvous (pre-barrier-write visibility sum 10/10 per thread) and in-flight re-init refusal proven with a blocked thread; pthreads live in the TEST TU ONLY (plain -c needs no -pthread). First consumer is a Gate item. | DRAFT |
| kido-ipi | Inter-processor interrupt discipline on top of GIC SGI (DRAFT 2026-10-29, session 36): module-global registry (SGI ids are one system-wide namespace, not caller-embedded); transport injected via ops table whose send slot matches kido_gic_send_sgi exactly (one-line Gate binding, zero MMIO in the leaf, zero existing files touched); two types only — RESCHED (scheduler-tick vocabulary) + PING (diagnostic presence); per-type handler registry (IRQ context: short, non-blocking, no allocator; no-handler delivery OK + counted, the GIC precedent); mask is uint32_t validated against the 8-CPU smp census (zero mask refused, bits >= 8 refused, never truncated, narrowed to uint8_t only after validation); dispatch maps sgi_id -> type by subtracting the init-time base (base + 1 <= 15 enforced), out-of-range counts unknown + refuses EARLY_ENV (a wiring bug made loud); send claims handoff never delivery (sent vs received are separate counters); kido_ipi_sgi_id() exposes base + type so the wiring registers exactly the owned ids; no new header codes. WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 19th data point); hosted self-test 54/54 against a scripted transport (record + fail-switch) + direct dispatch calls. SGI actually arriving on another CPU awaits the Gate wiring + a QEMU virt -smp 2 run. | DRAFT |
| kido-call | Cross-CPU function mailbox, the work carrier ipi D2 named as the CALL type's blocker (DRAFT 2026-10-30, session 37): module-global table of 8 slots (slots belong to their target CPU, the ipi-registry precedent — the sync/barrier caller-embedded shape argued and distinguished); state machine EMPTY -> POSTED -> RUNNING -> DONE -> EMPTY; one-deep per CPU (busy = OK + accepted 0 door, the defer/try_lock precedent — a queue is a second invention); poll() claims under the slot lock, runs the function OUTSIDE the lock, stores the result (running under the lock would serialize reaps and deadlock a self-posting function); poster law (reap by a non-poster refuses EARLY_ENV, slot untouched, stranger counted — the sync stranger-unlock precedent); fn returns kido_status_t stored in the slot, arg lifetime is the caller's (never copied/freed); poll-first, NO ipi/GIC/scheduler/MMIO in the leaf (wakeup is a Gate binding: ipi PING/RESCHED or the future CALL handler calling poll); caller passes both CPU indices explicitly (no MPIDR parsing — the ipi C6/C3 settlement); idle loop services its OWN slot (stated, not detected — the barrier contract precedent); lock order slot -> stats, stats lock held only across one increment; no new header codes. WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 20th data point); module has no asm, so no ARM64 spelling awaits disassembly — only cross-CPU execution itself, awaiting the Gate secondary stub + QEMU virt -smp 2 run. Hosted self-test 79/79 incl. a pthread proof the function runs on the poller's thread. | DRAFT |
| kido-mpidr | CPU-identity leaf: MPIDR_EL1 decode (DRAFT 2026-10-30, session 38): closes the ipi C3 / call C8 named future (MPIDR parsing) as its own leaf — read() (one MRS, sync's spelling verbatim; hosted injector, sync precedent) + pure decode() (shared path, read calls decode, never drifts) + same_cpu() (Aff3..Aff0 only; MT/U are not identity); field law per Arm MPIDR_EL1 (Aff0 [7:0], Aff1 [15:8], Aff2 [23:16], MT [24], RES0 [29:25], U [30], RES1 [31], Aff3 [39:32], RES0 [63:40]); NO linear CPU index, deliberately (Aff0-as-index is a QEMU-virt accident that aliases PEs on multi-cluster systems; slot-from-affinity is a Gate table lookup, never arithmetic here); reserved bits masked, never interpreted or policed, raw carried whole; EL1+ caller law (stated, not enforced); zero existing files touched (sync keeps its raw owner — D2); no wiring into smp/sync/ipi/call/boot (consumers are Gate items). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 21st data point); the one MRS awaits a disassembly check + a QEMU virt -smp 2 run showing two distinct Aff tuples. Hosted self-test 37/37. | DRAFT |
| kido-cache | Cache-maintenance leaf: VA-based D/I-cache ops, barrier-closed (DRAFT 2026-10-31, session 39): the primitive mmu's cache-on state and smp's cross-CPU mailbox both lacked — clean_range (DC CVAC, PoC) / invalidate_range (DC IVAC, PoC, DESTRUCTIVE: unaligned addr/len refused EARLY_ENV, the one preventable data-loss case) / clean_invalidate_range (DC CIVAC, the safe handoff shape) / sync_icache_range (the unreorderable CVAU, DSB, IVAU, DSB, ISB sequence) / icache_invalidate_all (IC IALLU, DSB, ISB; discards no data); TWO line sizes, deliberately (CTR_EL0 DminLine [19:16] vs IminLine [3:0], 4 << field each; DC walks step by D, IVAU by I — one size would skip lines on cores whose lines differ); DSB SY scope (full system, not ISH); NO set/way ops (geometry-addressed, would discard other agents' lines); NO bare dsb()/isb() API (barriers ride inside ops); shared round_range guard+alignment helper so hosted/ARM64 paths cannot drift; zero existing files touched (smp mailbox clean + post-mmu-enable invalidate are named Gate consumers, not this session's edits). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 22nd data point); the DC/IC spellings await disassembly + a QEMU virt -smp 2 run with caches on. Hosted self-test 74/74 against the recording trace log (two-walk sync proof with D=64/I=32). | DRAFT |
| kido-topo | CPU-topology registry: Aff tuple <-> smp slot (DRAFT 2026-10-31, session 40): the binding smp (slots by bring_up order) and mpidr (decoded identity) never recorded — module-global table of 8 entries (own MAX_CPUS constant, the ipi precedent; must move with the smp census as a Gate item), one kido-sync spinlock held across each whole operation, decoded kido_mpidr_t stored whole; register takes the slot explicitly (no Aff->slot arithmetic, the mpidr C2 refusal carried forward); two loud conflict arms (same Aff another slot = aliasing, different Aff same slot = theft, both EARLY_ENV table-untouched) + idempotent exact-pair re-register; absence is OK + found 0, never an error; init succeeds once and registers nothing (the primary's registration is a Gate wiring, not an init side effect); zero tuple registrable (the UP shape); no raw-affinity API (consumer decodes via pure mpidr_decode, one comparison path); no destroy API (static table, nothing to free). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 23rd data point); no asm of its own (ARM64 content is sync's exclusive pair) — awaits a QEMU virt -smp 2 run + the Gate arrival wiring. Hosted self-test 52/52 incl. a 2-thread concurrent-registration proof under the real spinlock. | DRAFT |
| kido-time | Monotonic nanosecond clock over an injected timer source (DRAFT 2026-11-01, session 41): the conversion session 29's timer never owned — ns = (ticks/hz)*1e9 + (ticks%hz)*1e9/hz in pure uint64 (no __int128, no float), truncation toward zero, error under one tick; two overflow guards (seconds cap ~584.9y, sum crossing UINT64_MAX — the second pinned by a constructed hz=4 case, refuse vs boundary-fit pair); monotonic clamp on a backwards source step + regression counter (a clock must answer, and must testify); elapsed refuses a future stamp; init-once (epoch is single, the topo precedent); source injected via ops table whose slots match kido_timer_now/hz exactly (one-line Gate binding named, zero timer.c edits — timer's selftest-main collision is the concrete reason, the ipi precedent); hz==0 is EARLY_ENV in the converter but NO_TIMER at init (missing time base, the timer's own code); no new header codes; no destroy API (static state, borrowed table). WRITTEN, NOT ASSEMBLED, NEVER EXECUTED (toolchain absent, 24th data point); no asm of its own (ARM64 content is the timer's register reads) — awaits the Gate binding + a QEMU virt advancing-clock run at the real 62.5 MHz CNTFRQ. Hosted self-test 38/38 against a scripted source. | DRAFT |

Dependency order: kido-boot -> kido-hal -> kido-mem -> kido-alloc -> kido-sched.
kido-resonate rides on the scheduler (public header only; no allocator symbols
of its own). kido-interop wraps kido-resonate's wire shape whole for the
Kido<->BUBO boundary (asymmetric: Kido adapts, BUBO ACKs); placement defined
in architecture/doll-layers.md. The scheduler's fence from kido-alloc is
FULFILLED (2026-10-14): stacks are allocator clients, sequenced after the
QEMU multitasking proof.
RE-PROOF LANDED 2026-10-15: the allocator-integrated tree cross-compiled
clean (ARM64, -ffreestanding, zero warnings) and re-proved under QEMU virt
(ABCABCABCABC interleave, zero exceptions, loud-halt spin) — session 7's
honest limit is closed. D2 CLOSED 2026-10-16: kido-image feeds the linker-
script bounds (_image_start/_image_end, boot stack included) into
kido_alloc_init's reservation from kido_sched_init; hosted path is
declared-vacuous (0,0) unless the test injects bounds.
RESERVED-TREE PROOF LANDED 2026-10-16: the reserved tree executed on bare
metal (QEMU virt / cortex-a57 / 128 MiB): breath -> kido_main -> 3 tasks ->
ABCABCABCABC, zero exceptions, exit 124 (designed loud-halt spin). The
console reaching "3 tasks created" proves kido_image_bounds returned OK
from real linker symbols (_image_start=0x40080000, _image_end=0x40088f70);
a mislinked image would have halted LOUD at sched_init first. Stacks land
below the carved image (first-fit low->high from 0x40000000; exact carve
geometry pinned by the hosted injected-image test on the same source) —
zero exceptions on a working switch loop is the bare-metal non-overlap
evidence. Harness lesson recorded: entry.o/entry-c.o must lead the link
line (QEMU -kernel raw binary starts at the load address, not ELF ENTRY).
Nothing here is final without N8toriousAi's review; first boot is his to witness.
