Linting pass

.claude/settings.local.json

···
       "Bash(cmd /c \"cd /d F:\\OS\\aethelos-source && cargo build 2>&1 | findstr /C:\"Compiling\" /C:\"Finished\" /C:\"error\"\")",
       "Bash(cargo doc:*)",
       "Bash(cmd /c \"cd /d F:\\OS\\aethelos-source && taskkill /F /IM qemu-system-x86_64.exe 2>nul & cd /d F:\\OS\\aethelos-source & del serial.log 2>nul & start /B \"\" \"C:Program Filesqemuqemu-system-x86_64.exe\" -cdrom aethelos.iso -serial file:serial.log -m 256M -display gtk -no-reboot -no-shutdown\")",
-      "Bash(cmd /c \"cd /d F:\\OS\\aethelos-source && taskkill /F /IM qemu-system-x86_64.exe 2>nul & del serial.log 2>nul & start /B \"\" \"C:Program Filesqemuqemu-system-x86_64.exe\" -cdrom aethelos.iso -serial file:serial.log -m 256M -display gtk -no-reboot -no-shutdown\")"
+      "Bash(cmd /c \"cd /d F:\\OS\\aethelos-source && taskkill /F /IM qemu-system-x86_64.exe 2>nul & del serial.log 2>nul & start /B \"\" \"C:Program Filesqemuqemu-system-x86_64.exe\" -cdrom aethelos.iso -serial file:serial.log -m 256M -display gtk -no-reboot -no-shutdown\")",
+      "Bash(cargo fix:*)",
+      "Bash(tee:*)"
     ],
     "deny": [],
     "ask": []

aethelos-source/heartwood/Cargo.toml

···
 [[bin]]
 name = "heartwood"
 path = "src/main.rs"
-
-[profile.dev]
-panic = "abort"
-
-[profile.release]
-panic = "abort"

aethelos-source/heartwood/src/attunement/keyboard.rs

···
     unsafe {
         let keyboard = Keyboard::new();
         let lock = InterruptSafeLock::new(keyboard);
-        core::ptr::write(KEYBOARD.as_mut_ptr(), lock);
+        core::ptr::write(core::ptr::addr_of_mut!(KEYBOARD).cast(), lock);
         KEYBOARD_INITIALIZED = true;
     }
 }
···
             return;
         }
 
-        let mut keyboard = (*KEYBOARD.as_ptr()).lock();
+        let mut keyboard = (*core::ptr::addr_of!(KEYBOARD).cast::<InterruptSafeLock<Keyboard>>()).lock();
         let scancode = keyboard.read_scancode();
 
         // Ignore key release events (scancode >= 0x80)

aethelos-source/heartwood/src/boot/boot32.rs

···
 
 global_asm!(
     r#"
-    .intel_syntax noprefix
     .section .boot.text, "awx"
     .code32
     .globl boot32_start

aethelos-source/heartwood/src/boot/multiboot2.rs

···
 //! This is the handshake between bootloader and kernel - the first
 //! moment of trust between two systems working together.
 
-use core::arch::global_asm;
-
 /// Multiboot2 magic number
 /// Bootloaders look for this to identify our kernel
 pub const MULTIBOOT2_MAGIC: u32 = 0xE85250D6;

aethelos-source/heartwood/src/eldarin.rs

···
 //! The shell does not merely execute - it interprets, validates, and responds
 //! with both action and wisdom.
 
-use core::fmt::Write;
 use crate::mana_pool::InterruptSafeLock;
 use core::mem::MaybeUninit;
 
···
     unsafe {
         let buffer = CommandBuffer::new();
         let lock = InterruptSafeLock::new(buffer);
-        core::ptr::write(COMMAND_BUFFER.as_mut_ptr(), lock);
+        core::ptr::write(core::ptr::addr_of_mut!(COMMAND_BUFFER).cast(), lock);
         BUFFER_INITIALIZED = true;
 
         let history = CommandHistory::new();
         let history_lock = InterruptSafeLock::new(history);
-        core::ptr::write(COMMAND_HISTORY.as_mut_ptr(), history_lock);
+        core::ptr::write(core::ptr::addr_of_mut!(COMMAND_HISTORY).cast(), history_lock);
         HISTORY_INITIALIZED = true;
     }
 }
 
 /// Get reference to command buffer
 unsafe fn get_buffer() -> &'static InterruptSafeLock<CommandBuffer> {
-    COMMAND_BUFFER.assume_init_ref()
+    &*core::ptr::addr_of!(COMMAND_BUFFER).cast::<InterruptSafeLock<CommandBuffer>>()
 }
 
 /// Get reference to command history
 unsafe fn get_history() -> &'static InterruptSafeLock<CommandHistory> {
-    COMMAND_HISTORY.assume_init_ref()
+    &*core::ptr::addr_of!(COMMAND_HISTORY).cast::<InterruptSafeLock<CommandHistory>>()
 }
 
 /// Handle a character from keyboard input
···
             let has_newline = buffer.as_str().contains('\n');
             if has_newline {
                 // Debug: we found a newline!
-                let mut port = 0x3f8u16;
+                let port = 0x3f8u16;
                 core::arch::asm!(
                     "out dx, al",
                     in("dx") port,
···
 pub fn display_prompt() {
     // Debug: signal that we're about to print prompt
     unsafe {
-        let mut port = 0x3f8u16;
+        let port = 0x3f8u16;
         core::arch::asm!(
             "out dx, al",
             in("dx") port,
···
         0
     };
 
-    // Draw a beautiful progress bar
-    crate::println!("  Total Essence: {} KB", total_kb);
-    crate::println!();
-    crate::print!("  [");
+    // Sanctuary Pool (Persistent Memory)
+    crate::println!("  Sanctuary Pool (Persistent):");
+    crate::println!("    Total: {} KB", sanctuary_total_kb);
+    crate::println!("    Used:  {} KB", sanctuary_used_kb);
+    crate::println!("    Free:  {} KB", sanctuary_free_kb);
 
-    let bar_width = 50;
-    let filled = (used_percent as usize * bar_width) / 100;
+    // Draw sanctuary progress bar
+    let sanctuary_percent = if stats.sanctuary_total > 0 {
+        (stats.sanctuary_used * 100) / stats.sanctuary_total
+    } else {
+        0
+    };
+    crate::print!("    [");
+    let bar_width = 40;
+    let filled = (sanctuary_percent as usize * bar_width) / 100;
     for i in 0..bar_width {
         if i < filled {
             crate::print!("█");
···
             crate::print!("░");
         }
     }
-    crate::println!("] {}%", used_percent);
+    crate::println!("] {}%", sanctuary_percent);
     crate::println!();
 
-    crate::println!("  Sustenance (Used):     {} KB", used_kb);
-    crate::println!("  Free Flow (Available): {} KB", free_kb);
+    // Ephemeral Pool (Temporary Memory)
+    crate::println!("  Ephemeral Mist (Temporary):");
+    crate::println!("    Total: {} KB", ephemeral_total_kb);
+    crate::println!("    Used:  {} KB", ephemeral_used_kb);
+    crate::println!("    Free:  {} KB", ephemeral_free_kb);
+
+    // Draw ephemeral progress bar
+    let ephemeral_percent = if stats.ephemeral_total > 0 {
+        (stats.ephemeral_used * 100) / stats.ephemeral_total
+    } else {
+        0
+    };
+    crate::print!("    [");
+    let filled = (ephemeral_percent as usize * bar_width) / 100;
+    for i in 0..bar_width {
+        if i < filled {
+            crate::print!("█");
+        } else {
+            crate::print!("░");
+        }
+    }
+    crate::println!("] {}%", ephemeral_percent);
     crate::println!();
 
-    crate::println!("  Sanctuary (Long-lived):");
-    crate::println!("    Used: {} KB / {} KB", sanctuary_used_kb, sanctuary_total_kb);
-    crate::println!();
+    // Overall Summary
+    crate::println!("  Overall Summary:");
+    crate::println!("    Total: {} KB", total_kb);
+    crate::println!("    Used:  {} KB", used_kb);
+    crate::println!("    Free:  {} KB", free_kb);
 
-    crate::println!("  Ephemeral Mist (Short-lived):");
-    crate::println!("    Used: {} KB / {} KB", ephemeral_used_kb, ephemeral_total_kb);
+    // Draw total progress bar
+    crate::print!("    [");
+    let bar_width = 40;
+    let filled = (used_percent as usize * bar_width) / 100;
+    for i in 0..bar_width {
+        if i < filled {
+            crate::print!("█");
+        } else {
+            crate::print!("░");
+        }
+    }
+    crate::println!("] {}%", used_percent);
     crate::println!();
 
     crate::println!("  Total Objects: {}", stats.total_objects);

aethelos-source/heartwood/src/irq_safe_mutex.rs

···
         }
     }
 
-    pub fn lock(&self) -> IrqSafeMutexGuard<T> {
+    pub fn lock(&self) -> IrqSafeMutexGuard<'_, T> {
         // Check if interrupts are currently enabled
         let were_enabled: bool;
         unsafe {

aethelos-source/heartwood/src/loom_of_fate/context.rs

···
 ///
 /// This function is called when a new thread is first scheduled.
 /// It handles any setup needed before calling the actual entry point.
-pub extern "C" fn thread_entry_wrapper(entry_point: fn() -> !) -> ! {
+pub extern "C" fn thread_entry_wrapper(entry_point: extern "C" fn() -> !) -> ! {
     // Enable interrupts for this new thread
     unsafe {
         asm!("sti", options(nomem, nostack));

aethelos-source/heartwood/src/loom_of_fate/mod.rs

···
         serial_out(b'D'); // InterruptSafeLock created
 
         // Write the small InterruptSafeLock<Box<Scheduler>> to static
-        core::ptr::write(LOOM.as_mut_ptr(), lock);
+        core::ptr::write(core::ptr::addr_of_mut!(LOOM).cast(), lock);
         serial_out(b'y'); // Written to MaybeUninit
 
         LOOM_INITIALIZED = true;
···
 /// # Safety
 /// LOOM must be initialized before calling this function
 pub unsafe fn get_loom() -> &'static InterruptSafeLock<Box<Scheduler>> {
-    LOOM.assume_init_ref()
+    &*core::ptr::addr_of!(LOOM).cast::<InterruptSafeLock<Box<Scheduler>>>()
 }
 
 /// Spawn a new thread

aethelos-source/heartwood/src/loom_of_fate/scheduler.rs

···
 
         // Pre-allocate capacity to prevent reallocation during push
         // This avoids memory overlap between Vec storage and stack allocations
-        let mut threads = Vec::with_capacity(16);
+        let threads = Vec::with_capacity(16);
         unsafe { serial_out(b'b'); } // threads Vec created
-        let mut stacks = Vec::with_capacity(16);
+        let stacks = Vec::with_capacity(16);
         unsafe { serial_out(b'c'); } // stacks Vec created
         let ready_queue = VecDeque::new();
         unsafe { serial_out(b'd'); } // ready_queue created
···
     ///
     /// # Safety
     /// Assumes both thread IDs are valid and the threads exist
+    ///
+    /// Note: This is an old implementation from preemptive scheduling experiments.
+    /// The system now uses a different approach (cooperative + interrupt-based).
+    /// Kept as reference for alternative scheduling strategies.
+    #[allow(dead_code)]
     fn perform_context_switch(&mut self, from_id: ThreadId, to_id: ThreadId) {
         // Get raw pointers to the contexts before borrowing
         let from_idx = self.threads.iter().position(|t| t.id() == from_id).unwrap();
···
     ///
     /// # Safety
     /// This function never returns normally - it restores the thread's context
+    ///
+    /// Note: Old implementation from preemptive scheduling experiments.
+    /// Current system uses context::context_switch_first() instead.
+    /// Kept as reference for alternative boot strategies.
+    #[allow(dead_code)]
     fn restore_first_thread(&mut self, to_id: ThreadId) -> ! {
         // Find the thread's context
         let to_idx = self.threads.iter().position(|t| t.id() == to_id).unwrap();

aethelos-source/heartwood/src/loom_of_fate/system_threads.rs

···
 //! The keyboard thread listens attentively to user intentions.
 //! The shell thread translates human wishes into system actions.
 
-use super::{ThreadPriority, yield_now};
+use super::yield_now;
 
 /// The Idle Thread - The First Awakening
 ///
···
 
     // DEBUG: Silent marker that we've awakened
     unsafe {
-        let mut port = 0x3f8u16;
+        let port = 0x3f8u16;
         core::arch::asm!(
             "out dx, al",
             in("dx") port,
···
 
     // DEBUG: Interrupts enabled
     unsafe {
-        let mut port = 0x3f8u16;
+        let port = 0x3f8u16;
         core::arch::asm!(
             "out dx, al",
             in("dx") port,
···
         );
         let interrupts_enabled = (flags & 0x200) != 0;
 
-        let mut port = 0x3f8u16;
+        let port = 0x3f8u16;
         core::arch::asm!(
             "out dx, al",
             in("dx") port,

aethelos-source/heartwood/src/loom_of_fate/thread.rs

···
     pub(crate) id: ThreadId,
     pub(crate) state: ThreadState,
     pub(crate) priority: ThreadPriority,
+
+    /// Entry point function - kept for debugging/inspection
+    #[allow(dead_code)]
     pub(crate) entry_point: fn() -> !,
 
     // CPU state (for context switching)
     pub(crate) context: ThreadContext,
+
+    /// Stack boundaries - kept for future stack overflow detection
+    #[allow(dead_code)]
     pub(crate) stack_bottom: u64,
+    #[allow(dead_code)]
     pub(crate) stack_top: u64,
 
     // Harmony tracking

aethelos-source/heartwood/src/main.rs

···
 extern crate alloc;
 
 // Reference the modules from lib.rs
-use heartwood::{nexus, loom_of_fate, mana_pool, attunement, vga_buffer};
+use heartwood::{nexus, loom_of_fate, mana_pool, attunement};
 
 // Need to use macros with #[macro_use]
 #[macro_use]
···
     }
 
     // UNREACHABLE - the bootstrap ghost is gone
-    unreachable!("The Great Hand-Off should never return")
+    // This is intentional defensive programming to document the expected behavior
+    #[allow(unreachable_code)]
+    {
+        unreachable!("The Great Hand-Off should never return")
+    }
 }
 
 /// Initialize the Heartwood's core systems

aethelos-source/heartwood/src/mana_pool/buddy.rs

···
     /// unused parts to the appropriate free lists
     fn split_block(&mut self, block: NonNull<Block>, current_order: usize, target_order: usize) {
         let mut order = current_order;
-        let mut addr = block.as_ptr() as usize;
+        let addr = block.as_ptr() as usize;
 
         while order > target_order {
             order -= 1;

aethelos-source/heartwood/src/mana_pool/interrupt_lock.rs

···
     }
 
     /// Acquire the lock, returning a guard that restores interrupt state on drop
-    pub fn lock(&self) -> InterruptSafeLockGuard<T> {
+    pub fn lock(&self) -> InterruptSafeLockGuard<'_, T> {
         // Save current interrupt state
         let interrupts_enabled = are_interrupts_enabled();
 

aethelos-source/heartwood/src/mana_pool/mod.rs

···
         let lock = InterruptSafeLock::new(mana_pool_on_heap);
         serial_out(b'Q'); // After InterruptSafeLock::new
 
-        core::ptr::write(MANA_POOL.as_mut_ptr(), lock);
+        core::ptr::write(core::ptr::addr_of_mut!(MANA_POOL).cast(), lock);
         serial_out(b'R'); // Written to static
 
         MANA_POOL_INITIALIZED = true;
···
 
 /// Get reference to MANA_POOL (assumes initialized)
 unsafe fn get_mana_pool() -> &'static InterruptSafeLock<Box<ManaPool>> {
-    MANA_POOL.assume_init_ref()
+    &*core::ptr::addr_of!(MANA_POOL).cast::<InterruptSafeLock<Box<ManaPool>>>()
 }
 
 /// Allocate memory with a specific purpose

aethelos-source/heartwood/src/mana_pool/object_manager.rs

···
 
 /// An object in the Mana Pool
 struct Object {
+    /// Object handle - kept for future reverse lookups and debugging
+    #[allow(dead_code)]
     pub(super) handle: ObjectHandle,
     pub(super) object_type: ObjectType,
     pub(super) address: usize,

aethelos-source/heartwood/src/nexus/mod.rs

···
         let lock = InterruptSafeLock::new(nexus_core);
         serial_out(b'u'); // After InterruptSafeLock::new
 
-        core::ptr::write(NEXUS.as_mut_ptr(), lock);
+        core::ptr::write(core::ptr::addr_of_mut!(NEXUS).cast(), lock);
         serial_out(b'!'); // Written to static
 
         NEXUS_INITIALIZED = true;
···
 
 /// Get reference to NEXUS (assumes initialized)
 unsafe fn get_nexus() -> &'static InterruptSafeLock<NexusCore> {
-    NEXUS.assume_init_ref()
+    &*core::ptr::addr_of!(NEXUS).cast::<InterruptSafeLock<NexusCore>>()
 }
 
 /// Send a message through the Nexus

aethelos-source/heartwood/src/vga_buffer.rs

···
 
         // Wrap in IRQ-safe mutex and write to static
         let mutex = IrqSafeMutex::new(writer);
-        core::ptr::write(WRITER.as_mut_ptr(), mutex);
+        core::ptr::write(core::ptr::addr_of_mut!(WRITER).cast(), mutex);
         WRITER_INITIALIZED = true;
 
         // Clear the screen
-        let mut writer = WRITER.assume_init_mut().lock();
+        let mut writer = (*core::ptr::addr_of_mut!(WRITER).cast::<IrqSafeMutex<Writer>>()).lock();
         for row in 0..BUFFER_HEIGHT {
             writer.clear_row(row);
         }
···
 
 /// Get reference to WRITER (assumes initialized)
 unsafe fn get_writer() -> &'static IrqSafeMutex<Writer> {
-    WRITER.assume_init_ref()
+    &*core::ptr::addr_of!(WRITER).cast::<IrqSafeMutex<Writer>>()
 }
 
 /// Force unlock the VGA writer (for use before context switches)
···
 /// no other code will try to use the lock.
 pub unsafe fn force_unlock() {
     if WRITER_INITIALIZED {
-        let writer = WRITER.assume_init_mut();
+        let writer = &mut *core::ptr::addr_of_mut!(WRITER).cast::<IrqSafeMutex<Writer>>();
         writer.force_unlock();
     }
 }
···
     }
 
     // Get raw pointer to the writer inside the IRQ-safe mutex
-    let writer_ptr = WRITER.as_ptr() as *mut IrqSafeMutex<Writer>;
+    let writer_ptr = core::ptr::addr_of_mut!(WRITER).cast::<IrqSafeMutex<Writer>>();
     // Access the inner Mutex to get the data (unsafe pointer dereference)
     let inner_mutex = &mut (*writer_ptr).inner;
     let writer = inner_mutex.get_mut();
···
         }
     }
 }
-
-/// Execute a closure with interrupts disabled
-/// This prevents deadlocks when acquiring locks that might be used in interrupt handlers
-fn without_interrupts<F, R>(f: F) -> R
-where
-    F: FnOnce() -> R,
-{
-    // Check if interrupts are currently enabled
-    let were_enabled: bool;
-    unsafe {
-        let flags: u64;
-        core::arch::asm!(
-            "pushfq",
-            "pop {0}",
-            out(reg) flags,
-            options(nomem, preserves_flags)
-        );
-        were_enabled = (flags & 0x200) != 0;
-    }
-
-    // Disable interrupts
-    unsafe {
-        core::arch::asm!("cli", options(nomem, nostack, preserves_flags));
-    }
-
-    // Execute the closure
-    let result = f();
-
-    // Only re-enable if they were enabled before
-    // This prevents re-enabling interrupts during early boot
-    if were_enabled {
-        unsafe {
-            core::arch::asm!("sti", options(nomem, nostack, preserves_flags));
-
-            // Debug: output to serial that we re-enabled interrupts
-            core::arch::asm!(
-                "mov dx, 0x3f8",
-                "mov al, 0x2B",  // '+' = re-enabled
-                "out dx, al",
-                options(nomem, nostack, preserves_flags)
-            );
-        }
-    } else {
-        unsafe {
-            // Debug: output that we DIDN'T re-enable
-            core::arch::asm!(
-                "mov dx, 0x3f8",
-                "mov al, 0x2D",  // '-' = stayed disabled
-                "out dx, al",
-                options(nomem, nostack, preserves_flags)
-            );
-        }
-    }
-
-    result
-}