feat(kernel): add handle_tick and handle_interrupt entry points

crates/kernel/src/tests/mod.rs

@@ -1,5 +1,6 @@
 mod exit;
 mod simple;
+mod tick;
 
 use domain::memory::page_pool::PagePool;
 use platform::Platform;

crates/kernel/src/tests/tick.rs

@@ -0,0 +1,55 @@
+use super::*;
+use domain::scheduler::SchedulerDecision;
+use types::id::{CoreId, IrqId, ThreadId};
+use types::time::TimeSlice;
+
+#[test]
+fn tick_continues_when_time_remaining() {
+    let (mut k, _) = kernel_with_process();
+    let decision = k.handle_tick(CoreId::from_raw(0));
+    assert!(matches!(decision, SchedulerDecision::Continue));
+}
+
+#[test]
+fn tick_preempts_when_time_expired_and_other_thread_ready() {
+    let mut k = test_kernel();
+    let mock = MockPlatform::new(1);
+    let pool = PagePool::new(PhysicalAddress::from_raw(0x8000_0000), 1024);
+    let mut k = Kernel::new(mock, pool);
+
+    // Boot with quantum=2 so it expires after 2 ticks
+    let (pid, tid1) = k.boot(Priority::new(16).unwrap(), TimeSlice::new(2)).unwrap();
+
+    // Spawn a second thread so scheduler has someone to switch to
+    let tid2 = k.spawn_thread_for_test(pid, Priority::new(16).unwrap(), TimeSlice::new(100));
+
+    // First tick: time remaining
+    let d1 = k.handle_tick(CoreId::from_raw(0));
+    assert!(matches!(d1, SchedulerDecision::Continue));
+
+    // Second tick: time expired, should preempt
+    let d2 = k.handle_tick(CoreId::from_raw(0));
+    assert!(matches!(d2, SchedulerDecision::Preempt(_)));
+}
+
+#[test]
+fn interrupt_unknown_irq_returns_none() {
+    let (mut k, _) = kernel_with_process();
+    assert!(k.handle_interrupt(IrqId::from_raw(99)).is_none());
+}
+
+#[test]
+fn interrupt_unblocks_registered_thread() {
+    let (mut k, _) = kernel_with_process();
+    let tid = ThreadId::from_raw(0);
+    let irq = IrqId::from_raw(5);
+
+    // Register and block the thread on this IRQ
+    k.register_irq_for_test(irq, tid);
+    k.block_thread_for_test(tid, domain::thread::BlockReason::WaitingForInterrupt(
+        types::bounded::CapSlot::new(0).unwrap()
+    ));
+
+    let result = k.handle_interrupt(irq);
+    assert_eq!(result, Some(tid));
+}