Sweep: extract crimson/render strings, move pure-constant files into constants/ subfolders, strip explanatory comments and multi-line headers tree-wide, zig fmt

65 files changed, 171 insertions, 302 deletions

diff --git a/hikari/boot/params.zig b/hikari/boot/params.zig
index ebc7c67..1574008 100644
--- a/hikari/boot/params.zig
+++ b/hikari/boot/params.zig
@@ -1,10 +1,8 @@
 //! Hikari Boot Parameters
-//!
-//! This structure is passed to the Mirai kernel at boot time.
 
 const paging = @import("../paging/paging.zig");
 
-pub const boot_params_magic: u64 = 0x494152494D424B41; // "AKBMIRAI"
+pub const boot_params_magic: u64 = 0x494152494D424B41;
 pub const boot_params_version: u32 = 1;
 
 pub const BootParams = extern struct {
diff --git a/hikari/disk/gpt/constants.zig b/hikari/disk/gpt/constants.zig
index 5bc2c91..afb86f7 100644
--- a/hikari/disk/gpt/constants.zig
+++ b/hikari/disk/gpt/constants.zig
@@ -1,6 +1,6 @@
 //! Hikari GPT Constants
 
-pub const signature: u64 = 0x5452415020494645; // "EFI PART"
+pub const signature: u64 = 0x5452415020494645;
 pub const revision_1_0: u32 = 0x00010000;
 
 pub const header_size_minimum: u32 = 92;
diff --git a/hikari/efi/constants/tables.zig b/hikari/efi/constants/tables.zig
index 592113e..c2ade51 100644
--- a/hikari/efi/constants/tables.zig
+++ b/hikari/efi/constants/tables.zig
@@ -1,8 +1,8 @@
 //! Hikari EFI Table Signature Constants
 
-pub const system_table_signature: u64 = 0x5453595320494249; // "IBI SYST"
-pub const boot_services_signature: u64 = 0x56524553544f4f42; // "BOOTSERV"
-pub const runtime_services_signature: u64 = 0x56524553544e5552; // "RUNTSERV"
+pub const system_table_signature: u64 = 0x5453595320494249;
+pub const boot_services_signature: u64 = 0x56524553544f4f42;
+pub const runtime_services_signature: u64 = 0x56524553544e5552;
 
 pub const system_table_revision_2_100: u32 = (2 << 16) | 100;
 pub const system_table_revision_2_90: u32 = (2 << 16) | 90;
diff --git a/hikari/fs/afs/afs.zig b/hikari/fs/afs/afs.zig
index efad50f..575e4c6 100644
--- a/hikari/fs/afs/afs.zig
+++ b/hikari/fs/afs/afs.zig
@@ -2,12 +2,10 @@
 
 const shared_afs = @import("shared").afs;
 
-// Adapters (EFI-specific)
 pub const btree = @import("btree.zig");
 pub const reader = @import("reader.zig");
 pub const block_io = @import("block.zig");
 
-// Re-export shared types
 pub const constants = shared_afs.constants;
 pub const types = shared_afs.types;
 
@@ -29,7 +27,6 @@ pub const JournalInfoCell = shared_afs.types.JournalInfoCell;
 pub const JournalHeader = shared_afs.types.JournalHeader;
 pub const Timestamp = shared_afs.types.Timestamp;
 
-// Adapter types
 pub const BTree = btree.BTree;
 pub const BTreeError = btree.BTreeError;
 
diff --git a/hikari/fs/afs/block.zig b/hikari/fs/afs/block.zig
index ae45f7b..f13edf2 100644
--- a/hikari/fs/afs/block.zig
+++ b/hikari/fs/afs/block.zig
@@ -6,7 +6,6 @@ const shared_afs = @import("shared").afs;
 const BlockReader = shared_afs.BlockReader;
 const BlockError = shared_afs.BlockError;
 
-/// EFI Block I/O context
 pub const EfiBlockContext = struct {
     block_io: *efi.protocols.BlockIoProtocol,
     boot_services: *efi.services.BootServices,
@@ -15,7 +14,6 @@ pub const EfiBlockContext = struct {
     cell_size: u32,
 };
 
-/// EFI block read function - implements shared BlockReader interface
 pub fn efi_read_cell(context: *anyopaque, cell: u64, buffer: []u8) BlockError!void {
     const ctx: *EfiBlockContext = @ptrCast(@alignCast(context));
 
@@ -34,7 +32,6 @@ pub fn efi_read_cell(context: *anyopaque, cell: u64, buffer: []u8) BlockError!vo
     }
 }
 
-/// Create a BlockReader from EFI context
 pub fn create_block_reader(ctx: *EfiBlockContext, total_cells: u64) BlockReader {
     return BlockReader{
         .context = @ptrCast(ctx),
diff --git a/hikari/fs/afs/btree.zig b/hikari/fs/afs/btree.zig
index d5de00c..4ce4c2a 100644
--- a/hikari/fs/afs/btree.zig
+++ b/hikari/fs/afs/btree.zig
@@ -6,7 +6,6 @@ const block_io = @import("block.zig");
 
 const EfiBlockContext = block_io.EfiBlockContext;
 
-// Import shared types
 const BTreeNodeDescriptor = shared_afs.BTreeNodeDescriptor;
 const BTreeHeaderRecord = shared_afs.BTreeHeaderRecord;
 const IndexKey = shared_afs.types.IndexKey;
@@ -15,7 +14,6 @@ const UnitRecord = shared_afs.UnitRecord;
 const ThreadRecord = shared_afs.types.ThreadRecord;
 const SpanDescriptor = shared_afs.SpanDescriptor;
 
-// Import shared B-tree operations
 const btree_ops = shared_afs.btree;
 const constants = shared_afs.constants;
 
diff --git a/hikari/fs/afs/reader.zig b/hikari/fs/afs/reader.zig
index 9a4e98c..db6445c 100644
--- a/hikari/fs/afs/reader.zig
+++ b/hikari/fs/afs/reader.zig
@@ -4,7 +4,6 @@ const efi = @import("../../efi/efi.zig");
 const shared_afs = @import("shared").afs;
 const btree_adapter = @import("btree.zig");
 
-// Import shared types
 const VolumeHeader = shared_afs.VolumeHeader;
 const SpanDescriptor = shared_afs.SpanDescriptor;
 const ChannelInfo = shared_afs.ChannelInfo;
@@ -163,7 +162,6 @@ pub const Reader = struct {
             };
 
             if (unit_record) |unit| {
-                // Check if this is the last component
                 if (iter.next() == null) {
                     last_unit = unit.*;
                     break;
diff --git a/hikari/fs/fat32/fat32.zig b/hikari/fs/fat32/fat32.zig
index 41d2d91..f1612e6 100644
--- a/hikari/fs/fat32/fat32.zig
+++ b/hikari/fs/fat32/fat32.zig
@@ -3,7 +3,6 @@
 const efi = @import("../../efi/efi.zig");
 const shared_fat32 = @import("shared").fat32;
 
-// Re-export shared types
 pub const constants = shared_fat32.constants;
 pub const types = shared_fat32.types;
 
@@ -14,7 +13,6 @@ pub const LongIdentityEntry = shared_fat32.LongIdentityEntry;
 pub const TimeFormat = shared_fat32.TimeFormat;
 pub const DateFormat = shared_fat32.DateFormat;
 
-// Reader adapter
 pub const reader = @import("reader.zig");
 pub const Reader = reader.Reader;
 pub const ReadError = reader.ReadError;
diff --git a/hikari/fs/fat32/reader.zig b/hikari/fs/fat32/reader.zig
index 89a449a..fcaa7da 100644
--- a/hikari/fs/fat32/reader.zig
+++ b/hikari/fs/fat32/reader.zig
@@ -3,7 +3,6 @@
 const efi = @import("../../efi/efi.zig");
 const shared_fat32 = @import("shared").fat32;
 
-// Import shared types
 const BootSector = shared_fat32.BootSector;
 const FsInfo = shared_fat32.FsInfo;
 const StackEntry = shared_fat32.StackEntry;
diff --git a/hikari/paging/types.zig b/hikari/paging/types.zig
index 0cb512e..812f14e 100644
--- a/hikari/paging/types.zig
+++ b/hikari/paging/types.zig
@@ -62,11 +62,10 @@ pub const PageTable = struct {
     }
 };
 
-// Page table levels (L4 = top, L1 = bottom)
-pub const TableL4 = PageTable; // PML4
-pub const TableL3 = PageTable; // PDPT
-pub const TableL2 = PageTable; // PD
-pub const TableL1 = PageTable; // PT
+pub const TableL4 = PageTable;
+pub const TableL3 = PageTable;
+pub const TableL2 = PageTable;
+pub const TableL1 = PageTable;
 
 pub fn get_l4_index(address: u64) usize {
     return @truncate((address >> constants.pml4_shift) & 0x1FF);
diff --git a/mirai/crimson/panic/halt.zig b/mirai/crimson/panic/halt.zig
index 55d7966..058d528 100644
--- a/mirai/crimson/panic/halt.zig
+++ b/mirai/crimson/panic/halt.zig
@@ -12,10 +12,6 @@ pub fn halt_current() noreturn {
     asm_cpu.halt_loop();
 }
 
-pub fn send_halt_ipi() void {
-    // TODO: Send IPI to all other cores to halt them
-}
+pub fn send_halt_ipi() void {}
 
-pub fn wait_for_other_cpus() void {
-    // TODO: Wait for all other CPUs to acknowledge halt
-}
+pub fn wait_for_other_cpus() void {}
diff --git a/mirai/crimson/ports/constants/constants.zig b/mirai/crimson/ports/constants/constants.zig
new file mode 100644
index 0000000..11bc58f
--- /dev/null
+++ b/mirai/crimson/ports/constants/constants.zig
@@ -0,0 +1,3 @@
+//! Exception Port Constants
+
+pub const masks = @import("masks.zig");
diff --git a/mirai/crimson/ports/masks.zig b/mirai/crimson/ports/constants/masks.zig
index fb7453f..43295dd 100644
--- a/mirai/crimson/ports/masks.zig
+++ b/mirai/crimson/ports/constants/masks.zig
@@ -1,6 +1,6 @@
 //! Exception Masks
 
-const constants = @import("../constants/constants.zig");
+const constants = @import("../../constants/constants.zig");
 
 const ExceptionType = constants.ExceptionType;
 
diff --git a/mirai/crimson/ports/ports.zig b/mirai/crimson/ports/ports.zig
index c145491..c4757b6 100644
--- a/mirai/crimson/ports/ports.zig
+++ b/mirai/crimson/ports/ports.zig
@@ -2,7 +2,7 @@
 
 pub const port = @import("port.zig");
 pub const array = @import("array.zig");
-pub const masks = @import("masks.zig");
+pub const masks = @import("constants/masks.zig");
 pub const host = @import("host.zig");
 pub const kata = @import("kata.zig");
 pub const thread = @import("thread.zig");
diff --git a/mirai/crimson/render/banner.zig b/mirai/crimson/render/banner.zig
index 802c804..aa40abe 100644
--- a/mirai/crimson/render/banner.zig
+++ b/mirai/crimson/render/banner.zig
@@ -1,23 +1,24 @@
 //! Collapse Banner
 
 const serial = @import("../../drivers/serial/serial.zig");
+const messages = @import("strings/strings.zig").messages;
 
 pub fn render() void {
     serial.printf("\n", .{});
-    serial.printf("================================================================================\n", .{});
-    serial.printf("                              AKIBA HAS COLLAPSED                              \n", .{});
-    serial.printf("================================================================================\n", .{});
+    serial.printf(messages.separator, .{});
+    serial.printf(messages.collapse_header, .{});
+    serial.printf(messages.separator, .{});
     serial.printf("\n", .{});
 }
 
 pub fn render_message(message: []const u8) void {
-    serial.printf("Reason: %s\n", .{message});
+    serial.printf(messages.reason, .{message});
     serial.printf("\n", .{});
 }
 
 pub fn render_halt() void {
     serial.printf("\n", .{});
-    serial.printf("================================================================================\n", .{});
-    serial.printf("System halted. Please restart your computer.\n", .{});
-    serial.printf("================================================================================\n", .{});
+    serial.printf(messages.separator, .{});
+    serial.printf(messages.system_halted, .{});
+    serial.printf(messages.separator, .{});
 }
diff --git a/mirai/crimson/render/context.zig b/mirai/crimson/render/context.zig
index 944f2cc..c18a9a7 100644
--- a/mirai/crimson/render/context.zig
+++ b/mirai/crimson/render/context.zig
@@ -2,20 +2,21 @@
 
 const serial = @import("../../drivers/serial/serial.zig");
 const types = @import("../types/types.zig");
+const messages = @import("strings/strings.zig").messages;
 
 const Context = types.Context;
 
 pub fn render(context: *const Context) void {
-    serial.printf("CPU Context:\n", .{});
-    serial.printf("  RAX: %x  RBX: %x\n", .{ context.rax, context.rbx });
-    serial.printf("  RCX: %x  RDX: %x\n", .{ context.rcx, context.rdx });
-    serial.printf("  RSI: %x  RDI: %x\n", .{ context.rsi, context.rdi });
-    serial.printf("  RBP: %x  RSP: %x\n", .{ context.rbp, context.rsp });
-    serial.printf("  R8:  %x  R9:  %x\n", .{ context.r8, context.r9 });
-    serial.printf("  R10: %x  R11: %x\n", .{ context.r10, context.r11 });
-    serial.printf("  R12: %x  R13: %x\n", .{ context.r12, context.r13 });
-    serial.printf("  R14: %x  R15: %x\n", .{ context.r14, context.r15 });
-    serial.printf("  RIP: %x  RFLAGS: %x\n", .{ context.rip, context.rflags });
+    serial.printf(messages.cpu_context_header, .{});
+    serial.printf(messages.reg_rax_rbx, .{ context.rax, context.rbx });
+    serial.printf(messages.reg_rcx_rdx, .{ context.rcx, context.rdx });
+    serial.printf(messages.reg_rsi_rdi, .{ context.rsi, context.rdi });
+    serial.printf(messages.reg_rbp_rsp, .{ context.rbp, context.rsp });
+    serial.printf(messages.reg_r8_r9, .{ context.r8, context.r9 });
+    serial.printf(messages.reg_r10_r11, .{ context.r10, context.r11 });
+    serial.printf(messages.reg_r12_r13, .{ context.r12, context.r13 });
+    serial.printf(messages.reg_r14_r15, .{ context.r14, context.r15 });
+    serial.printf(messages.reg_rip_rflags, .{ context.rip, context.rflags });
     serial.printf("\n", .{});
 
     render_control_registers(context);
@@ -23,15 +24,15 @@ pub fn render(context: *const Context) void {
 }
 
 fn render_control_registers(context: *const Context) void {
-    serial.printf("Control Registers:\n", .{});
-    serial.printf("  CR0: %x  CR2: %x\n", .{ context.cr0, context.cr2 });
-    serial.printf("  CR3: %x  CR4: %x\n", .{ context.cr3, context.cr4 });
+    serial.printf(messages.control_registers_header, .{});
+    serial.printf(messages.reg_cr0_cr2, .{ context.cr0, context.cr2 });
+    serial.printf(messages.reg_cr3_cr4, .{ context.cr3, context.cr4 });
     serial.printf("\n", .{});
 }
 
 fn render_segment_registers(context: *const Context) void {
-    serial.printf("Segment Registers:\n", .{});
-    serial.printf("  CS: %x  DS: %x  ES: %x\n", .{ context.cs, context.ds, context.es });
-    serial.printf("  FS: %x  GS: %x  SS: %x\n", .{ context.fs, context.gs, context.ss });
+    serial.printf(messages.segment_registers_header, .{});
+    serial.printf(messages.reg_cs_ds_es, .{ context.cs, context.ds, context.es });
+    serial.printf(messages.reg_fs_gs_ss, .{ context.fs, context.gs, context.ss });
     serial.printf("\n", .{});
 }
diff --git a/mirai/crimson/render/exception.zig b/mirai/crimson/render/exception.zig
index edc8dd3..17c5e0c 100644
--- a/mirai/crimson/render/exception.zig
+++ b/mirai/crimson/render/exception.zig
@@ -3,34 +3,35 @@
 const serial = @import("../../drivers/serial/serial.zig");
 const types = @import("../types/types.zig");
 const classify = @import("../classify/classify.zig");
+const messages = @import("strings/strings.zig").messages;
 
 const Exception = types.Exception;
 const PageFaultError = classify.PageFaultError;
 
 pub fn render(exception: *const Exception) void {
-    serial.printf("Exception: %s (%s)\n", .{
+    serial.printf(messages.exception_line, .{
         exception.exception_type.name(),
         classify.get_vector_name(exception.vector),
     });
 
-    serial.printf("  Vector: %d\n", .{exception.vector});
-    serial.printf("  Code: %x\n", .{exception.code});
-    serial.printf("  Subcode: %x\n", .{exception.subcode});
+    serial.printf(messages.vector, .{exception.vector});
+    serial.printf(messages.code, .{exception.code});
+    serial.printf(messages.subcode, .{exception.subcode});
 
     if (exception.address != 0) {
-        serial.printf("  Fault Address: %x\n", .{exception.address});
+        serial.printf(messages.fault_address, .{exception.address});
     }
 
     if (exception.vector == 14) {
         render_page_fault_details(exception.code);
     }
 
-    serial.printf("  Location: %s mode\n", .{
-        if (exception.context.is_kernel_mode()) "kernel" else "user",
+    serial.printf(messages.location, .{
+        if (exception.context.is_kernel_mode()) messages.location_kernel else messages.location_user,
     });
 
     if (exception.kata_id != 0) {
-        serial.printf("  Kata: %d, Thread: %d\n", .{ exception.kata_id, exception.thread_id });
+        serial.printf(messages.kata_thread, .{ exception.kata_id, exception.thread_id });
     }
 
     serial.printf("\n", .{});
@@ -39,21 +40,21 @@ pub fn render(exception: *const Exception) void {
 fn render_page_fault_details(error_code: u64) void {
     const pf_error = PageFaultError.from_error_code(error_code);
 
-    serial.printf("  Access: %s\n", .{pf_error.description()});
+    serial.printf(messages.access, .{pf_error.description()});
 
     if (pf_error.user) {
-        serial.printf("  Mode: User\n", .{});
+        serial.printf(messages.mode_user, .{});
     } else {
-        serial.printf("  Mode: Kernel\n", .{});
+        serial.printf(messages.mode_kernel, .{});
     }
 }
 
 pub fn render_faulting_instruction(rip: u64) void {
-    serial.printf("Faulting Instruction:\n", .{});
-    serial.printf("  Address: %x\n", .{rip});
+    serial.printf(messages.faulting_instruction_header, .{});
+    serial.printf(messages.address, .{rip});
 
     const code_ptr: [*]const u8 = @ptrFromInt(rip);
-    serial.printf("  Bytes: ", .{});
+    serial.printf(messages.bytes_label, .{});
     for (0..8) |i| {
         serial.printf("%x ", .{code_ptr[i]});
     }
diff --git a/mirai/crimson/render/memory.zig b/mirai/crimson/render/memory.zig
index efef69c..44938e5 100644
--- a/mirai/crimson/render/memory.zig
+++ b/mirai/crimson/render/memory.zig
@@ -1,6 +1,7 @@
 //! Render Memory Around Fault
 
 const serial = @import("../../drivers/serial/serial.zig");
+const messages = @import("strings/strings.zig").messages;
 
 pub fn render_around_address(address: u64, bytes_before: usize, bytes_after: usize) void {
     if (address == 0) return;
@@ -8,7 +9,7 @@ pub fn render_around_address(address: u64, bytes_before: usize, bytes_after: usi
     const start = if (address >= bytes_before) address - bytes_before else 0;
     const total_bytes = bytes_before + bytes_after;
 
-    serial.printf("Memory around %x:\n", .{address});
+    serial.printf(messages.memory_around, .{address});
 
     const mem_ptr: [*]const u8 = @ptrFromInt(start);
 
@@ -44,7 +45,7 @@ pub fn render_around_address(address: u64, bytes_before: usize, bytes_after: usi
 }
 
 pub fn render_instruction_bytes(rip: u64, count: usize) void {
-    serial.printf("Instruction bytes at %x:\n  ", .{rip});
+    serial.printf(messages.instruction_bytes, .{rip});
 
     const code_ptr: [*]const u8 = @ptrFromInt(rip);
 
diff --git a/mirai/crimson/render/modules.zig b/mirai/crimson/render/modules.zig
index 8520fb1..697cc32 100644
--- a/mirai/crimson/render/modules.zig
+++ b/mirai/crimson/render/modules.zig
@@ -1,6 +1,7 @@
 //! Render Loaded Modules
 
 const serial = @import("../../drivers/serial/serial.zig");
+const messages = @import("strings/strings.zig").messages;
 
 pub const ModuleInfo = struct {
     name: [64]u8,
@@ -35,15 +36,15 @@ pub fn register_module(name: []const u8, base_address: u64, size: u64) bool {
 
 pub fn render() void {
     if (module_count == 0) {
-        serial.printf("Loaded Modules: (none registered)\n\n", .{});
+        serial.printf(messages.modules_none, .{});
         return;
     }
 
-    serial.printf("Loaded Modules:\n", .{});
+    serial.printf(messages.modules_header, .{});
 
     for (0..module_count) |i| {
         const module = &loaded_modules[i];
-        serial.printf("  %s: %x - %x (%d bytes)\n", .{
+        serial.printf(messages.module_entry, .{
             module.name[0..module.name_len],
             module.base_address,
             module.base_address + module.size,
diff --git a/mirai/crimson/render/stack.zig b/mirai/crimson/render/stack.zig
index a00f0c7..e9f443d 100644
--- a/mirai/crimson/render/stack.zig
+++ b/mirai/crimson/render/stack.zig
@@ -2,11 +2,12 @@
 
 const serial = @import("../../drivers/serial/serial.zig");
 const types = @import("../types/types.zig");
+const messages = @import("strings/strings.zig").messages;
 
 const Context = types.Context;
 
 pub fn render(context: *const Context) void {
-    serial.printf("Stack Trace:\n", .{});
+    serial.printf(messages.stack_trace_header, .{});
 
     var rbp = context.rbp;
     var depth: usize = 0;
@@ -28,14 +29,14 @@ pub fn render(context: *const Context) void {
     }
 
     if (depth == 0) {
-        serial.printf("  (no stack frames available)\n", .{});
+        serial.printf(messages.no_stack_frames, .{});
     }
 
     serial.printf("\n", .{});
 }
 
 pub fn render_raw_stack(rsp: u64, count: usize) void {
-    serial.printf("Raw Stack (from %x):\n", .{rsp});
+    serial.printf(messages.raw_stack, .{rsp});
 
     const stack_ptr: [*]const u64 = @ptrFromInt(rsp);
 
diff --git a/mirai/crimson/render/strings/messages.zig b/mirai/crimson/render/strings/messages.zig
new file mode 100644
index 0000000..f64a805
--- /dev/null
+++ b/mirai/crimson/render/strings/messages.zig
@@ -0,0 +1,50 @@
+//! Crimson Render Messages
+
+pub const separator = "================================================================================\n";
+pub const collapse_header = "                              AKIBA HAS COLLAPSED                              \n";
+pub const reason = "Reason: %s\n";
+pub const system_halted = "System halted. Please restart your computer.\n";
+
+pub const cpu_context_header = "CPU Context:\n";
+pub const reg_rax_rbx = "  RAX: %x  RBX: %x\n";
+pub const reg_rcx_rdx = "  RCX: %x  RDX: %x\n";
+pub const reg_rsi_rdi = "  RSI: %x  RDI: %x\n";
+pub const reg_rbp_rsp = "  RBP: %x  RSP: %x\n";
+pub const reg_r8_r9 = "  R8:  %x  R9:  %x\n";
+pub const reg_r10_r11 = "  R10: %x  R11: %x\n";
+pub const reg_r12_r13 = "  R12: %x  R13: %x\n";
+pub const reg_r14_r15 = "  R14: %x  R15: %x\n";
+pub const reg_rip_rflags = "  RIP: %x  RFLAGS: %x\n";
+pub const control_registers_header = "Control Registers:\n";
+pub const reg_cr0_cr2 = "  CR0: %x  CR2: %x\n";
+pub const reg_cr3_cr4 = "  CR3: %x  CR4: %x\n";
+pub const segment_registers_header = "Segment Registers:\n";
+pub const reg_cs_ds_es = "  CS: %x  DS: %x  ES: %x\n";
+pub const reg_fs_gs_ss = "  FS: %x  GS: %x  SS: %x\n";
+
+pub const exception_line = "Exception: %s (%s)\n";
+pub const vector = "  Vector: %d\n";
+pub const code = "  Code: %x\n";
+pub const subcode = "  Subcode: %x\n";
+pub const fault_address = "  Fault Address: %x\n";
+pub const location = "  Location: %s mode\n";
+pub const location_kernel = "kernel";
+pub const location_user = "user";
+pub const kata_thread = "  Kata: %d, Thread: %d\n";
+pub const access = "  Access: %s\n";
+pub const mode_user = "  Mode: User\n";
+pub const mode_kernel = "  Mode: Kernel\n";
+pub const faulting_instruction_header = "Faulting Instruction:\n";
+pub const address = "  Address: %x\n";
+pub const bytes_label = "  Bytes: ";
+
+pub const memory_around = "Memory around %x:\n";
+pub const instruction_bytes = "Instruction bytes at %x:\n  ";
+
+pub const stack_trace_header = "Stack Trace:\n";
+pub const no_stack_frames = "  (no stack frames available)\n";
+pub const raw_stack = "Raw Stack (from %x):\n";
+
+pub const modules_none = "Loaded Modules: (none registered)\n\n";
+pub const modules_header = "Loaded Modules:\n";
+pub const module_entry = "  %s: %x - %x (%d bytes)\n";
diff --git a/mirai/crimson/render/strings/strings.zig b/mirai/crimson/render/strings/strings.zig
new file mode 100644
index 0000000..506643f
--- /dev/null
+++ b/mirai/crimson/render/strings/strings.zig
@@ -0,0 +1,3 @@
+//! Crimson Render Strings
+
+pub const messages = @import("messages.zig");
diff --git a/mirai/drivers/pit/constants/constants.zig b/mirai/drivers/pit/constants/constants.zig
new file mode 100644
index 0000000..d61651a
--- /dev/null
+++ b/mirai/drivers/pit/constants/constants.zig
@@ -0,0 +1,17 @@
+//! PIT Constants
+
+pub const limits = @import("limits.zig");
+
+pub const channel0_data = limits.channel0_data;
+pub const channel1_data = limits.channel1_data;
+pub const channel2_data = limits.channel2_data;
+pub const command = limits.command;
+
+pub const base_frequency = limits.base_frequency;
+pub const target_frequency = limits.target_frequency;
+
+pub const mode_square_wave = limits.mode_square_wave;
+pub const mode_rate_generator = limits.mode_rate_generator;
+
+pub const irq = limits.irq;
+pub const vector = limits.vector;
diff --git a/mirai/drivers/pit/constants.zig b/mirai/drivers/pit/constants/limits.zig
index 9aa8dec..9aa8dec 100644
--- a/mirai/drivers/pit/constants.zig
+++ b/mirai/drivers/pit/constants/limits.zig
diff --git a/mirai/drivers/pit/handler.zig b/mirai/drivers/pit/handler.zig
index 4d3d3b0..f1e676d 100644
--- a/mirai/drivers/pit/handler.zig
+++ b/mirai/drivers/pit/handler.zig
@@ -1,6 +1,6 @@
 //! PIT IRQ Handler
 
-const constants = @import("constants.zig");
+const constants = @import("constants/constants.zig");
 const pic = @import("../../interrupts/pic/pic.zig");
 const idt = @import("../../interrupts/idt.zig");
 
diff --git a/mirai/drivers/pit/init.zig b/mirai/drivers/pit/init.zig
index f31e47f..fe6c1d1 100644
--- a/mirai/drivers/pit/init.zig
+++ b/mirai/drivers/pit/init.zig
@@ -1,6 +1,6 @@
 //! PIT Initialization
 
-const constants = @import("constants.zig");
+const constants = @import("constants/constants.zig");
 const asm_io = @import("../../asm/io/io.zig");
 
 pub fn init(frequency: u32) void {
diff --git a/mirai/drivers/pit/pit.zig b/mirai/drivers/pit/pit.zig
index db0f12a..5832dd0 100644
--- a/mirai/drivers/pit/pit.zig
+++ b/mirai/drivers/pit/pit.zig
@@ -1,6 +1,6 @@
 //! PIT - Programmable Interval Timer
 
-pub const constants = @import("constants.zig");
+pub const constants = @import("constants/constants.zig");
 pub const init = @import("init.zig");
 pub const handler = @import("handler.zig");
 
diff --git a/mirai/interrupts/pic/constants/constants.zig b/mirai/interrupts/pic/constants/constants.zig
new file mode 100644
index 0000000..c68b936
--- /dev/null
+++ b/mirai/interrupts/pic/constants/constants.zig
@@ -0,0 +1,3 @@
+//! PIC Constants
+
+pub const ports = @import("ports.zig");
diff --git a/mirai/interrupts/pic/ports.zig b/mirai/interrupts/pic/constants/ports.zig
index aba363f..aba363f 100644
--- a/mirai/interrupts/pic/ports.zig
+++ b/mirai/interrupts/pic/constants/ports.zig
diff --git a/mirai/interrupts/pic/eoi.zig b/mirai/interrupts/pic/eoi.zig
index 810ea37..ff71b78 100644
--- a/mirai/interrupts/pic/eoi.zig
+++ b/mirai/interrupts/pic/eoi.zig
@@ -1,6 +1,6 @@
 //! PIC End-of-Interrupt
 
-const ports = @import("ports.zig");
+const ports = @import("constants/ports.zig");
 const asm_io = @import("../../asm/io/io.zig");
 
 pub fn send(irq: u4) void {
diff --git a/mirai/interrupts/pic/init.zig b/mirai/interrupts/pic/init.zig
index 2f84b8a..d6dcbff 100644
--- a/mirai/interrupts/pic/init.zig
+++ b/mirai/interrupts/pic/init.zig
@@ -1,6 +1,6 @@
 //! PIC Initialization
 
-const ports = @import("ports.zig");
+const ports = @import("constants/ports.zig");
 const asm_io = @import("../../asm/io/io.zig");
 
 pub fn remap() void {
diff --git a/mirai/interrupts/pic/mask.zig b/mirai/interrupts/pic/mask.zig
index 3b98e28..4170cd0 100644
--- a/mirai/interrupts/pic/mask.zig
+++ b/mirai/interrupts/pic/mask.zig
@@ -1,6 +1,6 @@
 //! PIC IRQ Masking
 
-const ports = @import("ports.zig");
+const ports = @import("constants/ports.zig");
 const asm_io = @import("../../asm/io/io.zig");
 
 pub fn enable_irq(irq: u4) void {
diff --git a/mirai/interrupts/pic/pic.zig b/mirai/interrupts/pic/pic.zig
index ee34508..bec6a1f 100644
--- a/mirai/interrupts/pic/pic.zig
+++ b/mirai/interrupts/pic/pic.zig
@@ -1,6 +1,6 @@
 //! PIC - 8259A Programmable Interrupt Controller
 
-pub const ports = @import("ports.zig");
+pub const ports = @import("constants/ports.zig");
 pub const init = @import("init.zig");
 pub const mask = @import("mask.zig");
 pub const eoi = @import("eoi.zig");
diff --git a/mirai/kernel/boot.zig b/mirai/kernel/boot.zig
index fb8997b..f70aac6 100644
--- a/mirai/kernel/boot.zig
+++ b/mirai/kernel/boot.zig
@@ -1,8 +1,6 @@
 //! Boot Parameters
-//!
-//! This structure matches what Hikari bootloader passes to the kernel.
 
-pub const boot_params_magic: u64 = 0x494152494D424B41; // "AKBMIRAI"
+pub const boot_params_magic: u64 = 0x494152494D424B41;
 pub const boot_params_version: u32 = 1;
 
 pub const BootParams = extern struct {
diff --git a/shared/fs/afs/afs.zig b/shared/fs/afs/afs.zig
index 42990ee..9c494af 100644
--- a/shared/fs/afs/afs.zig
+++ b/shared/fs/afs/afs.zig
@@ -7,7 +7,6 @@ pub const btree = @import("btree/btree.zig");
 pub const read = @import("read/read.zig");
 pub const write = @import("write/write.zig");
 
-// Re-export commonly used types
 pub const VolumeHeader = types.VolumeHeader;
 pub const SpanDescriptor = types.SpanDescriptor;
 pub const ChannelInfo = types.ChannelInfo;
@@ -19,13 +18,11 @@ pub const BTreeHeaderRecord = types.BTreeHeaderRecord;
 pub const IndexKey = types.IndexKey;
 pub const Permissions = types.Permissions;
 
-// Re-export I/O interfaces
 pub const BlockReader = io.BlockReader;
 pub const BlockWriter = io.BlockWriter;
 pub const BlockDevice = io.BlockDevice;
 pub const BlockError = io.BlockError;
 
-// Re-export errors
 pub const BTreeError = btree.BTreeError;
 pub const ReadError = read.ReadError;
 pub const WriteError = write.WriteError;
diff --git a/shared/fs/afs/btree/btree.zig b/shared/fs/afs/btree/btree.zig
index ba72f99..cac9e36 100644
--- a/shared/fs/afs/btree/btree.zig
+++ b/shared/fs/afs/btree/btree.zig
@@ -3,7 +3,6 @@
 pub const node = @import("node.zig");
 pub const search = @import("search.zig");
 
-// Node operations
 pub const get_node_cell = node.get_node_cell;
 pub const get_node_offset_in_cell = node.get_node_offset_in_cell;
 pub const get_record_offset = node.get_record_offset;
@@ -11,7 +10,6 @@ pub const get_record_ptr = node.get_record_ptr;
 pub const get_record_ptr_const = node.get_record_ptr_const;
 pub const NodeError = node.NodeError;
 
-// Search operations
 pub const compare_keys = search.compare_keys;
 pub const search_index_node = search.search_index_node;
 pub const search_leaf_for_unit = search.search_leaf_for_unit;
diff --git a/shared/fs/afs/btree/node.zig b/shared/fs/afs/btree/node.zig
index d2ccc73..5fe161f 100644
--- a/shared/fs/afs/btree/node.zig
+++ b/shared/fs/afs/btree/node.zig
@@ -13,32 +13,27 @@ pub const NodeError = error{
     OutOfBounds,
 };
 
-/// Calculate the cell containing a node
 pub fn get_node_cell(node_number: u32, cell_size: u32, node_size: u32) u64 {
     const nodes_per_cell = cell_size / node_size;
     return node_number / nodes_per_cell;
 }
 
-/// Calculate offset of a node within a cell
 pub fn get_node_offset_in_cell(node_number: u32, cell_size: u32, node_size: u32) u32 {
     const nodes_per_cell = cell_size / node_size;
     return (node_number % nodes_per_cell) * node_size;
 }
 
-/// Get record offset from the offset table at the end of the node
 pub fn get_record_offset(node_buffer: [*]const u8, node_size: u32, record_index: u16) u16 {
     const offset_table_start = node_size - (@as(u32, record_index) + 1) * 2;
     const offset_ptr: *align(1) const u16 = @ptrCast(node_buffer + offset_table_start);
     return offset_ptr.*;
 }
 
-/// Get pointer to a record in the node buffer
 pub fn get_record_ptr(node_buffer: [*]u8, node_size: u32, record_index: u16) [*]u8 {
     const offset = get_record_offset(node_buffer, node_size, record_index);
     return node_buffer + offset;
 }
 
-/// Get const pointer to a record in the node buffer
 pub fn get_record_ptr_const(node_buffer: [*]const u8, node_size: u32, record_index: u16) [*]const u8 {
     const offset = get_record_offset(node_buffer, node_size, record_index);
     return node_buffer + offset;
diff --git a/shared/fs/afs/btree/search.zig b/shared/fs/afs/btree/search.zig
index 85f7c4b..93614d1 100644
--- a/shared/fs/afs/btree/search.zig
+++ b/shared/fs/afs/btree/search.zig
@@ -10,8 +10,6 @@ const StackRecord = types.StackRecord;
 const UnitRecord = types.UnitRecord;
 const ThreadRecord = types.ThreadRecord;
 
-/// Compare search key against a B-tree key
-/// Returns: -1 if search < key, 0 if equal, 1 if search > key
 pub fn compare_keys(parent_node_id: u32, identity: []const u16, key: *align(1) const IndexKey) i32 {
     if (parent_node_id < key.parent_node_id) {
         return -1;
@@ -45,7 +43,6 @@ pub fn compare_keys(parent_node_id: u32, identity: []const u16, key: *align(1) c
     return 0;
 }
 
-/// Search an index node for the child pointer to follow
 pub fn search_index_node(
     node_buffer: [*]const u8,
     node_size: u32,
@@ -65,7 +62,6 @@ pub fn search_index_node(
         }
     }
 
-    // Return last child pointer if search key is greater than all keys
     if (record_count > 0) {
         const last_record = node_ops.get_record_ptr_const(node_buffer, node_size, record_count - 1);
         const last_key: *align(1) const IndexKey = @ptrCast(last_record);
@@ -76,7 +72,6 @@ pub fn search_index_node(
     return null;
 }
 
-/// Search a leaf node for a unit record
 pub fn search_leaf_for_unit(
     node_buffer: [*]const u8,
     node_size: u32,
@@ -104,7 +99,6 @@ pub fn search_leaf_for_unit(
     return null;
 }
 
-/// Search a leaf node for a stack record
 pub fn search_leaf_for_stack(
     node_buffer: [*]const u8,
     node_size: u32,
@@ -132,7 +126,6 @@ pub fn search_leaf_for_stack(
     return null;
 }
 
-/// Search a leaf node for a thread record
 pub fn search_leaf_for_thread(
     node_buffer: [*]const u8,
     node_size: u32,
diff --git a/shared/fs/afs/constants/constants.zig b/shared/fs/afs/constants/constants.zig
index 2478a86..6be89a4 100644
--- a/shared/fs/afs/constants/constants.zig
+++ b/shared/fs/afs/constants/constants.zig
@@ -7,7 +7,6 @@ pub const records = @import("records.zig");
 pub const btree = @import("btree.zig");
 pub const flags = @import("flags.zig");
 
-// Re-export commonly used constants
 pub const signature = magic.signature;
 pub const version = magic.version;
 pub const journal_signature = magic.journal_signature;
diff --git a/shared/fs/afs/constants/flags.zig b/shared/fs/afs/constants/flags.zig
index 3ac1143..32daaa9 100644
--- a/shared/fs/afs/constants/flags.zig
+++ b/shared/fs/afs/constants/flags.zig
@@ -1,6 +1,5 @@
 //! AFS Flags
 
-// Unit flags
 pub const unit_locked: u16 = 0x0001;
 pub const unit_has_thread: u16 = 0x0002;
 pub const unit_has_alias: u16 = 0x0004;
@@ -8,21 +7,17 @@ pub const unit_has_security: u16 = 0x0008;
 pub const unit_has_twins: u16 = 0x0010;
 pub const unit_has_resource_channel: u16 = 0x0020;
 
-// Channel types
 pub const channel_data: u8 = 0x00;
 pub const channel_resource: u8 = 0xFF;
 
-// Compression types
 pub const compression_none: u32 = 0;
 pub const compression_zlib: u32 = 1;
 pub const compression_lz4: u32 = 2;
 pub const compression_zstd: u32 = 3;
 
-// Encryption types
 pub const encryption_none: u32 = 0;
 pub const encryption_aes_128_xts: u32 = 1;
 pub const encryption_aes_256_xts: u32 = 2;
 
-// Journal flags
 pub const journal_on_other_device: u32 = 0x00000001;
 pub const journal_needs_init: u32 = 0x00000002;
diff --git a/shared/fs/afs/constants/magic.zig b/shared/fs/afs/constants/magic.zig
index 84f46db..f268615 100644
--- a/shared/fs/afs/constants/magic.zig
+++ b/shared/fs/afs/constants/magic.zig
@@ -1,15 +1,11 @@
 //! AFS Magic Numbers and Signatures
 
-/// "AKIBAFS!" signature
 pub const signature: u64 = 0x2153464142494B41;
 
-/// AFS version
 pub const version: u16 = 0x0001;
 
-/// "JNRL" journal signature
 pub const journal_signature: u32 = 0x4A4E524C;
 
-/// AFS partition type GUID: 414B4942-4146-5300-0000-000000000001
 pub const partition_type_guid = [16]u8{
     0x42, 0x49, 0x4B, 0x41,
     0x46, 0x41, 0x00, 0x53,
diff --git a/shared/fs/afs/io/block.zig b/shared/fs/afs/io/block.zig
index 8abd71c..8475562 100644
--- a/shared/fs/afs/io/block.zig
+++ b/shared/fs/afs/io/block.zig
@@ -9,7 +9,6 @@ pub const BlockError = error{
     NotSupported,
 };
 
-/// Block reader interface - implemented by each consumer
 pub const BlockReader = struct {
     context: *anyopaque,
     read_fn: *const fn (context: *anyopaque, cell: u64, buffer: []u8) BlockError!void,
@@ -40,7 +39,6 @@ pub const BlockReader = struct {
     }
 };
 
-/// Block writer interface - implemented by each consumer
 pub const BlockWriter = struct {
     context: *anyopaque,
     write_fn: *const fn (context: *anyopaque, cell: u64, data: []const u8) BlockError!void,
@@ -71,7 +69,6 @@ pub const BlockWriter = struct {
     }
 };
 
-/// Combined reader/writer for read-write operations
 pub const BlockDevice = struct {
     reader: BlockReader,
     writer: BlockWriter,
diff --git a/shared/fs/afs/read/location.zig b/shared/fs/afs/read/location.zig
index ef145fc..f76b9d4 100644
--- a/shared/fs/afs/read/location.zig
+++ b/shared/fs/afs/read/location.zig
@@ -13,14 +13,12 @@ pub const LocationError = error{
     BTreeError,
 };
 
-/// Result of looking up a location
 pub const LookupResult = union(enum) {
     unit: UnitRecord,
     stack: StackRecord,
     not_found: void,
 };
 
-/// Convert ASCII location component to UTF-16 identity
 pub fn component_to_identity(component: []const u8, identity_buffer: []u16) usize {
     var len: usize = 0;
     for (component) |byte| {
@@ -31,14 +29,12 @@ pub fn component_to_identity(component: []const u8, identity_buffer: []u16) usiz
     return len;
 }
 
-/// Iterator for location components
 pub const LocationIterator = struct {
     location: []const u8,
     position: usize,
 
     pub fn init(location: []const u8) LocationIterator {
         var start: usize = 0;
-        // Skip leading separator
         if (location.len > 0 and (location[0] == '/' or location[0] == '\\')) {
             start = 1;
         }
@@ -49,7 +45,6 @@ pub const LocationIterator = struct {
     }
 
     pub fn next(self: *LocationIterator) ?[]const u8 {
-        // Skip empty components
         while (self.position < self.location.len and
             (self.location[self.position] == '/' or self.location[self.position] == '\\'))
         {
diff --git a/shared/fs/afs/read/read.zig b/shared/fs/afs/read/read.zig
index 7b232db..6adb4be 100644
--- a/shared/fs/afs/read/read.zig
+++ b/shared/fs/afs/read/read.zig
@@ -3,13 +3,11 @@
 pub const unit = @import("unit.zig");
 pub const location = @import("location.zig");
 
-// Unit operations
 pub const read_span = unit.read_span;
 pub const read_unit_inline_spans = unit.read_unit_inline_spans;
 pub const read_unit = unit.read_unit;
 pub const ReadError = unit.ReadError;
 
-// Location operations
 pub const component_to_identity = location.component_to_identity;
 pub const LocationIterator = location.LocationIterator;
 pub const LocationError = location.LocationError;
diff --git a/shared/fs/afs/read/unit.zig b/shared/fs/afs/read/unit.zig
index cecd5f7..46a7b82 100644
--- a/shared/fs/afs/read/unit.zig
+++ b/shared/fs/afs/read/unit.zig
@@ -17,7 +17,6 @@ pub const ReadError = error{
     BufferTooSmall,
 };
 
-/// Read data from a span into a buffer
 pub fn read_span(
     reader: *const BlockReader,
     span: *const SpanDescriptor,
@@ -50,7 +49,6 @@ pub fn read_span(
     return bytes_read;
 }
 
-/// Read unit data using inline spans
 pub fn read_unit_inline_spans(
     reader: *const BlockReader,
     channel: *const ChannelInfo,
@@ -86,7 +84,6 @@ pub fn read_unit_inline_spans(
     return bytes_read;
 }
 
-/// Read entire unit data (inline spans only, no overflow support yet)
 pub fn read_unit(
     reader: *const BlockReader,
     unit: *const UnitRecord,
diff --git a/shared/fs/afs/types/types.zig b/shared/fs/afs/types/types.zig
index 151435e..21d5ad6 100644
--- a/shared/fs/afs/types/types.zig
+++ b/shared/fs/afs/types/types.zig
@@ -8,17 +8,14 @@ pub const attributes = @import("attributes.zig");
 pub const journal = @import("journal.zig");
 pub const timestamp = @import("timestamp.zig");
 
-// Volume types
 pub const VolumeHeader = volume.VolumeHeader;
 pub const SpanDescriptor = volume.SpanDescriptor;
 pub const ChannelInfo = volume.ChannelInfo;
 
-// B-tree types
 pub const BTreeNodeDescriptor = btree.NodeDescriptor;
 pub const BTreeHeaderRecord = btree.HeaderRecord;
 pub const IndexKey = btree.IndexKey;
 
-// Catalog types
 pub const StackRecord = catalog.StackRecord;
 pub const UnitRecord = catalog.UnitRecord;
 pub const ThreadRecord = catalog.ThreadRecord;
@@ -28,20 +25,16 @@ pub const SpecialInfo = catalog.SpecialInfo;
 pub const AliasInfo = catalog.AliasInfo;
 pub const TwinInfo = catalog.TwinInfo;
 
-// Extent types
 pub const SpanKey = extents.SpanKey;
 pub const SpanRecord = extents.SpanRecord;
 
-// Attribute types
 pub const AttributeKey = attributes.AttributeKey;
 pub const AttributeInlineRecord = attributes.AttributeInlineRecord;
 pub const AttributeChannelRecord = attributes.AttributeChannelRecord;
 
-// Journal types
 pub const JournalInfoCell = journal.JournalInfoCell;
 pub const JournalHeader = journal.JournalHeader;
 pub const JournalCellList = journal.JournalCellList;
 pub const JournalCellInfo = journal.JournalCellInfo;
 
-// Timestamp
 pub const Timestamp = timestamp.Timestamp;
diff --git a/shared/fs/afs/write/allocate.zig b/shared/fs/afs/write/allocate.zig
index 2377f4f..9573a88 100644
--- a/shared/fs/afs/write/allocate.zig
+++ b/shared/fs/afs/write/allocate.zig
@@ -5,7 +5,6 @@ pub const AllocationError = error{
     InvalidCell,
 };
 
-/// Allocation bitmap operations
 pub const AllocationMap = struct {
     bitmap: []u8,
     total_cells: u32,
@@ -19,7 +18,6 @@ pub const AllocationMap = struct {
         };
     }
 
-    /// Mark a cell as allocated
     pub fn mark_allocated(self: *AllocationMap, cell: u32) void {
         if (cell >= self.total_cells) return;
         const byte_index = cell / 8;
@@ -27,7 +25,6 @@ pub const AllocationMap = struct {
         self.bitmap[byte_index] |= @as(u8, 1) << bit_index;
     }
 
-    /// Mark a cell as free
     pub fn mark_free(self: *AllocationMap, cell: u32) void {
         if (cell >= self.total_cells) return;
         const byte_index = cell / 8;
@@ -35,7 +32,6 @@ pub const AllocationMap = struct {
         self.bitmap[byte_index] &= ~(@as(u8, 1) << bit_index);
     }
 
-    /// Check if a cell is allocated
     pub fn is_allocated(self: *const AllocationMap, cell: u32) bool {
         if (cell >= self.total_cells) return true;
         const byte_index = cell / 8;
@@ -43,7 +39,6 @@ pub const AllocationMap = struct {
         return (self.bitmap[byte_index] & (@as(u8, 1) << bit_index)) != 0;
     }
 
-    /// Allocate a contiguous range of cells
     pub fn allocate_cells(self: *AllocationMap, count: u32) AllocationError!u32 {
         if (count == 0) return self.next_free;
 
@@ -61,7 +56,6 @@ pub const AllocationMap = struct {
         return start;
     }
 
-    /// Mark a range of cells as allocated (for reserved areas)
     pub fn reserve_range(self: *AllocationMap, start: u32, count: u32) void {
         var i: u32 = 0;
         while (i < count) : (i += 1) {
@@ -69,7 +63,6 @@ pub const AllocationMap = struct {
         }
     }
 
-    /// Get count of free cells
     pub fn free_count(self: *const AllocationMap) u32 {
         var count: u32 = 0;
         var i: u32 = 0;
@@ -82,7 +75,6 @@ pub const AllocationMap = struct {
     }
 };
 
-/// Calculate bitmap size needed for a given number of cells
 pub fn bitmap_size(total_cells: u32) u32 {
     return (total_cells + 7) / 8;
 }
diff --git a/shared/fs/afs/write/stack.zig b/shared/fs/afs/write/stack.zig
index 69afd53..0507bae 100644
--- a/shared/fs/afs/write/stack.zig
+++ b/shared/fs/afs/write/stack.zig
@@ -10,7 +10,6 @@ const IndexKey = types.IndexKey;
 const Permissions = types.Permissions;
 const ChannelInfo = types.ChannelInfo;
 
-/// Create a stack record
 pub fn create_stack_record(
     node_id: u32,
     timestamp: u64,
@@ -40,7 +39,6 @@ pub fn create_stack_record(
     };
 }
 
-/// Create a unit record
 pub fn create_unit_record(
     node_id: u32,
     timestamp: u64,
@@ -73,7 +71,6 @@ pub fn create_unit_record(
     };
 }
 
-/// Create an index key for a catalog entry
 pub fn create_index_key(
     parent_node_id: u32,
     identity: []const u8,
@@ -91,7 +88,6 @@ pub fn create_index_key(
     return key;
 }
 
-/// Get the size of an index key in bytes
 pub fn index_key_size(identity_len: usize) usize {
     return 8 + identity_len * 2;
 }
diff --git a/shared/fs/afs/write/unit.zig b/shared/fs/afs/write/unit.zig
index a20da4e..0162219 100644
--- a/shared/fs/afs/write/unit.zig
+++ b/shared/fs/afs/write/unit.zig
@@ -15,7 +15,6 @@ pub const WriteError = error{
     InvalidCell,
 };
 
-/// Write data to a span
 pub fn write_span(
     writer: *const BlockWriter,
     span: *const SpanDescriptor,
@@ -29,7 +28,6 @@ pub fn write_span(
     var current_cell = span.start_cell;
 
     while (bytes_written < bytes_to_write) {
-        // Clear cell buffer
         for (cell_buffer) |*b| {
             b.* = 0;
         }
@@ -37,7 +35,6 @@ pub fn write_span(
         const bytes_remaining = bytes_to_write - bytes_written;
         const bytes_to_copy = if (bytes_remaining < writer.cell_size) bytes_remaining else writer.cell_size;
 
-        // Copy data to cell buffer
         var i: u64 = 0;
         while (i < bytes_to_copy) : (i += 1) {
             cell_buffer[@intCast(i)] = data[@intCast(bytes_written + i)];
@@ -54,13 +51,11 @@ pub fn write_span(
     return bytes_written;
 }
 
-/// Calculate number of cells needed for a given size
 pub fn cells_needed(size: u64, cell_size: u32) u32 {
     if (size == 0) return 0;
     return @intCast((size + cell_size - 1) / cell_size);
 }
 
-/// Create a channel info for inline data
 pub fn create_channel_info(
     logical_size: u64,
     start_cell: u64,
diff --git a/shared/fs/afs/write/write.zig b/shared/fs/afs/write/write.zig
index b33ed3b..c4c1727 100644
--- a/shared/fs/afs/write/write.zig
+++ b/shared/fs/afs/write/write.zig
@@ -4,18 +4,15 @@ pub const unit = @import("unit.zig");
 pub const allocate = @import("allocate.zig");
 pub const stack = @import("stack.zig");
 
-// Unit operations
 pub const write_span = unit.write_span;
 pub const cells_needed = unit.cells_needed;
 pub const create_channel_info = unit.create_channel_info;
 pub const WriteError = unit.WriteError;
 
-// Allocation operations
 pub const AllocationMap = allocate.AllocationMap;
 pub const AllocationError = allocate.AllocationError;
 pub const bitmap_size = allocate.bitmap_size;
 
-// Stack operations
 pub const create_stack_record = stack.create_stack_record;
 pub const create_unit_record = stack.create_unit_record;
 pub const create_index_key = stack.create_index_key;
diff --git a/shared/fs/fat32/constants/constants.zig b/shared/fs/fat32/constants/constants.zig
index 2034699..80b8d08 100644
--- a/shared/fs/fat32/constants/constants.zig
+++ b/shared/fs/fat32/constants/constants.zig
@@ -1,63 +1,52 @@
 //! FAT32 Constants
 
-/// Boot sector signature
 pub const boot_signature: u16 = 0xAA55;
 
-/// FAT32 filesystem type string
 pub const fs_type_fat32: [8]u8 = .{ 'F', 'A', 'T', '3', '2', ' ', ' ', ' ' };
 
-// Entry attributes
 pub const attr_read_only: u8 = 0x01;
 pub const attr_hidden: u8 = 0x02;
 pub const attr_system: u8 = 0x04;
 pub const attr_volume_id: u8 = 0x08;
-pub const attr_stack: u8 = 0x10; // FAT32 calls this "directory"
+pub const attr_stack: u8 = 0x10;
 pub const attr_archive: u8 = 0x20;
 pub const attr_long_identity: u8 = attr_read_only | attr_hidden | attr_system | attr_volume_id;
 pub const attr_long_identity_mask: u8 = attr_read_only | attr_hidden | attr_system | attr_volume_id | attr_stack | attr_archive;
 
-// FAT32 spec aliases
 pub const attr_directory = attr_stack;
 pub const attr_long_name = attr_long_identity;
 pub const attr_long_name_mask = attr_long_identity_mask;
 
-// Entry markers
 pub const entry_free: u8 = 0xE5;
 pub const entry_end: u8 = 0x00;
 pub const entry_kanji_lead: u8 = 0x05;
 
-// Cluster values
 pub const cluster_free: u32 = 0x00000000;
 pub const cluster_reserved_start: u32 = 0x00000001;
 pub const cluster_reserved_end: u32 = 0x00000001;
 pub const cluster_data_start: u32 = 0x00000002;
 pub const cluster_bad: u32 = 0x0FFFFFF7;
-pub const cluster_eoc_start: u32 = 0x0FFFFFF8; // End of chain start
-pub const cluster_eoc: u32 = 0x0FFFFFFF; // End of chain marker
+pub const cluster_eoc_start: u32 = 0x0FFFFFF8;
+pub const cluster_eoc: u32 = 0x0FFFFFFF;
 pub const cluster_mask: u32 = 0x0FFFFFFF;
 
-// Long identity constants
 pub const lfn_sequence_mask: u8 = 0x1F;
 pub const lfn_last_entry: u8 = 0x40;
 pub const lfn_chars_per_entry: usize = 13;
 
-// Short identity lengths
 pub const short_identity_length: usize = 8;
 pub const short_ext_length: usize = 3;
 pub const short_total_length: usize = short_identity_length + short_ext_length;
 
-// Sector sizes
 pub const sector_size_min: u16 = 512;
 pub const sector_size_max: u16 = 4096;
 
-// FSInfo signatures
 pub const fsinfo_sig1: u32 = 0x41615252;
 pub const fsinfo_sig2: u32 = 0x61417272;
 pub const fsinfo_sig3: u32 = 0xAA550000;
 pub const fsinfo_unknown: u32 = 0xFFFFFFFF;
 
-// Default values for creation
 pub const default_oem_name: [8]u8 = .{ 'M', 'S', 'W', 'I', 'N', '4', '.', '1' };
-pub const default_media_type: u8 = 0xF8; // Fixed disk
+pub const default_media_type: u8 = 0xF8;
 pub const default_drive_number: u8 = 0x80;
 pub const default_boot_sig: u8 = 0x29;
diff --git a/shared/fs/fat32/fat32.zig b/shared/fs/fat32/fat32.zig
index 3e3cfdc..48454d4 100644
--- a/shared/fs/fat32/fat32.zig
+++ b/shared/fs/fat32/fat32.zig
@@ -5,7 +5,6 @@ pub const types = @import("types/types.zig");
 pub const read = @import("read/read.zig");
 pub const write = @import("write/write.zig");
 
-// Re-export commonly used types (Akiba terminology)
 pub const BootSector = types.BootSector;
 pub const FsInfo = types.FsInfo;
 pub const StackEntry = types.StackEntry;
@@ -13,10 +12,8 @@ pub const LongIdentityEntry = types.LongIdentityEntry;
 pub const TimeFormat = types.TimeFormat;
 pub const DateFormat = types.DateFormat;
 
-// FAT32 spec aliases (for compatibility)
 pub const DirEntry = types.DirEntry;
 pub const LongNameEntry = types.LongNameEntry;
 
-// Re-export errors
 pub const ClusterError = read.ClusterError;
 pub const LocationError = read.LocationError;
diff --git a/shared/fs/fat32/read/cluster.zig b/shared/fs/fat32/read/cluster.zig
index 7b4161d..3ad196a 100644
--- a/shared/fs/fat32/read/cluster.zig
+++ b/shared/fs/fat32/read/cluster.zig
@@ -11,19 +11,16 @@ pub const ClusterError = error{
     ReadFailed,
 };
 
-/// Check if cluster number is valid data cluster
 pub fn is_valid_cluster(cluster: u32) bool {
     return cluster >= constants.cluster_data_start and
         cluster < constants.cluster_eoc_start and
         cluster != constants.cluster_bad;
 }
 
-/// Check if cluster marks end of chain
 pub fn is_end_of_chain(cluster: u32) bool {
     return (cluster & constants.cluster_mask) >= constants.cluster_eoc_start;
 }
 
-/// Calculate FAT sector and offset for a cluster
 pub fn get_fat_position(cluster: u32, bytes_per_sector: u32) struct { sector: u32, offset: u32 } {
     const fat_offset = cluster * 4;
     return .{
@@ -32,7 +29,6 @@ pub fn get_fat_position(cluster: u32, bytes_per_sector: u32) struct { sector: u3
     };
 }
 
-/// Calculate LBA for a cluster's data
 pub fn cluster_to_lba(
     cluster: u32,
     data_start_lba: u64,
@@ -41,7 +37,6 @@ pub fn cluster_to_lba(
     return data_start_lba + (@as(u64, cluster - 2) * sectors_per_cluster);
 }
 
-/// Read next cluster from FAT entry
 pub fn parse_fat_entry(entry: u32) ClusterError!?u32 {
     const next = entry & constants.cluster_mask;
 
diff --git a/shared/fs/fat32/read/read.zig b/shared/fs/fat32/read/read.zig
index 7fca337..2bd7411 100644
--- a/shared/fs/fat32/read/read.zig
+++ b/shared/fs/fat32/read/read.zig
@@ -3,7 +3,6 @@
 pub const cluster = @import("cluster.zig");
 pub const stack = @import("stack.zig");
 
-// Cluster operations
 pub const ClusterError = cluster.ClusterError;
 pub const is_valid_cluster = cluster.is_valid_cluster;
 pub const is_end_of_chain = cluster.is_end_of_chain;
@@ -11,7 +10,6 @@ pub const get_fat_position = cluster.get_fat_position;
 pub const cluster_to_lba = cluster.cluster_to_lba;
 pub const parse_fat_entry = cluster.parse_fat_entry;
 
-// Stack operations
 pub const LocationError = stack.LocationError;
 pub const identities_equal = stack.identities_equal;
 pub const LocationIterator = stack.LocationIterator;
diff --git a/shared/fs/fat32/read/stack.zig b/shared/fs/fat32/read/stack.zig
index ded95eb..8df3ba4 100644
--- a/shared/fs/fat32/read/stack.zig
+++ b/shared/fs/fat32/read/stack.zig
@@ -10,7 +10,6 @@ pub const LocationError = error{
     InvalidLocation,
 };
 
-/// Case-insensitive comparison for identities
 pub fn identities_equal(a: []const u8, b: []const u8) bool {
     if (a.len != b.len) {
         return false;
@@ -25,14 +24,12 @@ pub fn identities_equal(a: []const u8, b: []const u8) bool {
     return true;
 }
 
-/// Location component iterator
 pub const LocationIterator = struct {
     location: []const u8,
     position: usize,
 
     pub fn init(location: []const u8) LocationIterator {
         var start: usize = 0;
-        // Skip leading separator
         if (location.len > 0 and (location[0] == '/' or location[0] == '\\')) {
             start = 1;
         }
@@ -43,7 +40,6 @@ pub const LocationIterator = struct {
     }
 
     pub fn next(self: *LocationIterator) ?[]const u8 {
-        // Skip empty components
         while (self.position < self.location.len and
             (self.location[self.position] == '/' or self.location[self.position] == '\\'))
         {
@@ -70,7 +66,6 @@ pub const LocationIterator = struct {
     }
 };
 
-/// Check if entry matches an identity (case-insensitive)
 pub fn entry_matches_identity(entry: *const StackEntry, identity: []const u8) bool {
     var short_identity_buf: [12]u8 = undefined;
     const short_identity_len = entry.get_short_identity(&short_identity_buf);
diff --git a/shared/fs/fat32/types/boot.zig b/shared/fs/fat32/types/boot.zig
index 2735404..68fc786 100644
--- a/shared/fs/fat32/types/boot.zig
+++ b/shared/fs/fat32/types/boot.zig
@@ -9,15 +9,14 @@ pub const BootSector = extern struct {
     sectors_per_cluster: u8,
     reserved_sectors: u16 align(1),
     fat_count: u8,
-    root_entry_count: u16 align(1), // Must be 0 for FAT32
-    total_sectors_16: u16 align(1), // Must be 0 for FAT32
+    root_entry_count: u16 align(1),
+    total_sectors_16: u16 align(1),
     media_type: u8,
-    fat_size_16: u16 align(1), // Must be 0 for FAT32
+    fat_size_16: u16 align(1),
     sectors_per_track: u16 align(1),
     head_count: u16 align(1),
     hidden_sectors: u32 align(1),
     total_sectors_32: u32 align(1),
-    // FAT32 extended BPB
     fat_size_32: u32 align(1),
     ext_flags: u16 align(1),
     fs_version: u16 align(1),
diff --git a/shared/fs/fat32/types/entry.zig b/shared/fs/fat32/types/entry.zig
index a2668ff..daa949a 100644
--- a/shared/fs/fat32/types/entry.zig
+++ b/shared/fs/fat32/types/entry.zig
@@ -2,7 +2,6 @@
 
 const constants = @import("../constants/constants.zig");
 
-/// Standard 32-byte entry - Stack or Unit
 pub const StackEntry = extern struct {
     identity: [8]u8,
     extension: [3]u8,
@@ -47,7 +46,6 @@ pub const StackEntry = extern struct {
         self.first_cluster_low = @intCast(cluster & 0xFFFF);
     }
 
-    /// Extract short identity (8.3 format) into buffer, returns length
     pub fn get_short_identity(self: *const StackEntry, buffer: *[12]u8) usize {
         var length: usize = 0;
 
@@ -56,7 +54,6 @@ pub const StackEntry = extern struct {
             first_byte = constants.entry_free;
         }
 
-        // Copy identity part (up to 8 chars, stop at space)
         var i: usize = 0;
         while (i < 8 and self.identity[i] != ' ') : (i += 1) {
             if (i == 0) {
@@ -67,7 +64,6 @@ pub const StackEntry = extern struct {
             length += 1;
         }
 
-        // Add extension if present
         if (self.extension[0] != ' ') {
             buffer[length] = '.';
             length += 1;
@@ -83,16 +79,15 @@ pub const StackEntry = extern struct {
     }
 };
 
-/// Long identity entry (LFN)
 pub const LongIdentityEntry = extern struct {
     sequence: u8,
-    identity_1: [10]u8, // 5 UTF-16 characters
+    identity_1: [10]u8,
     attributes: u8,
     entry_type: u8,
     checksum: u8,
-    identity_2: [12]u8, // 6 UTF-16 characters
-    first_cluster: u16 align(1), // Always 0
-    identity_3: [4]u8, // 2 UTF-16 characters
+    identity_2: [12]u8,
+    first_cluster: u16 align(1),
+    identity_3: [4]u8,
 
     pub fn is_last(self: *const LongIdentityEntry) bool {
         return (self.sequence & constants.lfn_last_entry) != 0;
@@ -102,25 +97,21 @@ pub const LongIdentityEntry = extern struct {
         return self.sequence & constants.lfn_sequence_mask;
     }
 
-    /// Extract 13 UTF-16 characters from this entry
     pub fn extract_chars(self: *const LongIdentityEntry, buffer: *[13]u16) void {
         var index: usize = 0;
 
-        // Extract from identity_1 (5 chars)
         var i: usize = 0;
         while (i < 10) : (i += 2) {
             buffer[index] = @as(u16, self.identity_1[i]) | (@as(u16, self.identity_1[i + 1]) << 8);
             index += 1;
         }
 
-        // Extract from identity_2 (6 chars)
         i = 0;
         while (i < 12) : (i += 2) {
             buffer[index] = @as(u16, self.identity_2[i]) | (@as(u16, self.identity_2[i + 1]) << 8);
             index += 1;
         }
 
-        // Extract from identity_3 (2 chars)
         i = 0;
         while (i < 4) : (i += 2) {
             buffer[index] = @as(u16, self.identity_3[i]) | (@as(u16, self.identity_3[i + 1]) << 8);
@@ -129,20 +120,17 @@ pub const LongIdentityEntry = extern struct {
     }
 };
 
-/// Time format (packed into 16 bits)
 pub const TimeFormat = packed struct(u16) {
     second_div_2: u5,
     minute: u6,
     hour: u5,
 };
 
-/// Date format (packed into 16 bits)
 pub const DateFormat = packed struct(u16) {
     day: u5,
     month: u4,
     year_from_1980: u7,
 };
 
-// FAT32 spec aliases (for external compatibility)
 pub const DirEntry = StackEntry;
 pub const LongNameEntry = LongIdentityEntry;
diff --git a/shared/fs/fat32/types/types.zig b/shared/fs/fat32/types/types.zig
index 7be282e..5799b3c 100644
--- a/shared/fs/fat32/types/types.zig
+++ b/shared/fs/fat32/types/types.zig
@@ -3,16 +3,13 @@
 pub const boot = @import("boot.zig");
 pub const entry = @import("entry.zig");
 
-// Boot sector types
 pub const BootSector = boot.BootSector;
 pub const FsInfo = boot.FsInfo;
 
-// Entry types (Akiba terminology)
 pub const StackEntry = entry.StackEntry;
 pub const LongIdentityEntry = entry.LongIdentityEntry;
 pub const TimeFormat = entry.TimeFormat;
 pub const DateFormat = entry.DateFormat;
 
-// FAT32 spec aliases
 pub const DirEntry = entry.DirEntry;
 pub const LongNameEntry = entry.LongNameEntry;
diff --git a/shared/fs/fat32/write/boot.zig b/shared/fs/fat32/write/boot.zig
index b7bc459..3f64c2e 100644
--- a/shared/fs/fat32/write/boot.zig
+++ b/shared/fs/fat32/write/boot.zig
@@ -7,7 +7,6 @@ const types = @import("../types/types.zig");
 const BootSector = types.BootSector;
 const FsInfo = types.FsInfo;
 
-/// Parameters for creating a FAT32 filesystem
 pub const CreateParams = struct {
     total_sectors: u32,
     hidden_sectors: u32 = 0,
@@ -19,16 +18,13 @@ pub const CreateParams = struct {
     volume_label: [11]u8 = .{ 'N', 'O', ' ', 'N', 'A', 'M', 'E', ' ', ' ', ' ', ' ' },
 };
 
-/// Calculate FAT size in sectors
 pub fn calculate_fat_size(params: CreateParams) u32 {
     const data_sectors = params.total_sectors - params.reserved_sectors;
     const cluster_count = data_sectors / params.sectors_per_cluster;
-    // Each FAT entry is 4 bytes
     const fat_bytes = (cluster_count + 2) * 4;
     return (fat_bytes + params.bytes_per_sector - 1) / params.bytes_per_sector;
 }
 
-/// Create a boot sector structure
 pub fn create_boot_sector(params: CreateParams) BootSector {
     const fat_size = calculate_fat_size(params);
 
@@ -67,7 +63,6 @@ pub fn create_boot_sector(params: CreateParams) BootSector {
     return boot;
 }
 
-/// Create FSInfo structure
 pub fn create_fsinfo(free_clusters: u32, next_free: u32) FsInfo {
     return FsInfo{
         .signature_1 = constants.fsinfo_sig1,
@@ -80,20 +75,14 @@ pub fn create_fsinfo(free_clusters: u32, next_free: u32) FsInfo {
     };
 }
 
-/// Initialize FAT table with required entries
 pub fn init_fat_table(fat: []u8) void {
-    // Clear
     @memset(fat, 0);
 
-    // Entry 0: Media type
     std.mem.writeInt(u32, fat[0..4], 0x0FFFFFF8, .little);
-    // Entry 1: End of chain marker
     std.mem.writeInt(u32, fat[4..8], 0x0FFFFFFF, .little);
-    // Entry 2: Origin stack EOC
     std.mem.writeInt(u32, fat[8..12], 0x0FFFFFFF, .little);
 }
 
-/// Allocate a cluster in the FAT
 pub fn allocate_cluster(fat: []u8, cluster: u32) void {
     const offset = cluster * 4;
     if (offset + 4 <= fat.len) {
@@ -101,7 +90,6 @@ pub fn allocate_cluster(fat: []u8, cluster: u32) void {
     }
 }
 
-/// Link two clusters in the FAT
 pub fn link_clusters(fat: []u8, from: u32, to: u32) void {
     const offset = from * 4;
     if (offset + 4 <= fat.len) {
diff --git a/shared/fs/fat32/write/entry.zig b/shared/fs/fat32/write/entry.zig
index 31f672e..3a26823 100644
--- a/shared/fs/fat32/write/entry.zig
+++ b/shared/fs/fat32/write/entry.zig
@@ -6,7 +6,6 @@ const types = @import("../types/types.zig");
 
 const StackEntry = types.StackEntry;
 
-/// Create a short (8.3) entry
 pub fn create_entry(
     identity: []const u8,
     extension: []const u8,
@@ -30,13 +29,11 @@ pub fn create_entry(
         .unit_size = unit_size,
     };
 
-    // Copy identity (uppercase)
     for (identity, 0..) |c, i| {
         if (i >= 8) break;
         entry.identity[i] = to_upper(c);
     }
 
-    // Copy extension (uppercase)
     for (extension, 0..) |c, i| {
         if (i >= 3) break;
         entry.extension[i] = to_upper(c);
@@ -45,7 +42,6 @@ pub fn create_entry(
     return entry;
 }
 
-/// Create a stack entry
 pub fn create_stack_entry(
     identity: []const u8,
     first_cluster: u32,
@@ -53,17 +49,14 @@ pub fn create_stack_entry(
     return create_entry(identity, "", constants.attr_stack, first_cluster, 0);
 }
 
-/// Create a "." entry for current stack
 pub fn create_dot_entry(cluster: u32) StackEntry {
     return create_entry(".", "", constants.attr_stack, cluster, 0);
 }
 
-/// Create a ".." entry for parent stack
 pub fn create_dotdot_entry(parent_cluster: u32) StackEntry {
     return create_entry("..", "", constants.attr_stack, parent_cluster, 0);
 }
 
-/// Create a unit entry
 pub fn create_unit_entry(
     identity: []const u8,
     extension: []const u8,
@@ -73,7 +66,6 @@ pub fn create_unit_entry(
     return create_entry(identity, extension, constants.attr_archive, first_cluster, unit_size);
 }
 
-/// Convert character to uppercase
 fn to_upper(c: u8) u8 {
     if (c >= 'a' and c <= 'z') {
         return c - 32;
@@ -81,9 +73,7 @@ fn to_upper(c: u8) u8 {
     return c;
 }
 
-/// Parse identity into name and extension parts
 pub fn parse_identity(identity: []const u8) struct { name: []const u8, ext: []const u8 } {
-    // Find last dot
     var dot_pos: ?usize = null;
     var i: usize = identity.len;
     while (i > 0) {
diff --git a/shared/fs/fat32/write/write.zig b/shared/fs/fat32/write/write.zig
index 711293e..b6a596e 100644
--- a/shared/fs/fat32/write/write.zig
+++ b/shared/fs/fat32/write/write.zig
@@ -3,7 +3,6 @@
 pub const boot = @import("boot.zig");
 pub const entry = @import("entry.zig");
 
-// Boot sector creation
 pub const CreateParams = boot.CreateParams;
 pub const calculate_fat_size = boot.calculate_fat_size;
 pub const create_boot_sector = boot.create_boot_sector;
@@ -12,7 +11,6 @@ pub const init_fat_table = boot.init_fat_table;
 pub const allocate_cluster = boot.allocate_cluster;
 pub const link_clusters = boot.link_clusters;
 
-// Entry creation
 pub const create_entry = entry.create_entry;
 pub const create_stack_entry = entry.create_stack_entry;
 pub const create_dot_entry = entry.create_dot_entry;
diff --git a/shared/shared.zig b/shared/shared.zig
index 323ea4b..22dfed1 100644
--- a/shared/shared.zig
+++ b/shared/shared.zig
@@ -2,6 +2,5 @@
 
 pub const fs = @import("fs/fs.zig");
 
-// Convenience re-exports
 pub const afs = fs.afs;
 pub const fat32 = fs.fat32;
diff --git a/toolchain/mkafsdisk/afs/afs.zig b/toolchain/mkafsdisk/afs/afs.zig
index 8819f05..eebded8 100644
--- a/toolchain/mkafsdisk/afs/afs.zig
+++ b/toolchain/mkafsdisk/afs/afs.zig
@@ -1,12 +1,9 @@
 //! mkafsdisk AFS Adapter
-//!
-//! Uses shared/afs for types and constants, provides host file I/O writer.
 
 const shared_afs = @import("shared").afs;
 
 pub const writer = @import("writer.zig");
 
-// Re-export shared types and constants
 pub const constants = shared_afs.constants;
 pub const types = shared_afs.types;
 
@@ -22,5 +19,4 @@ pub const Permissions = shared_afs.Permissions;
 pub const JournalInfoCell = shared_afs.types.JournalInfoCell;
 pub const JournalHeader = shared_afs.types.JournalHeader;
 
-// Writer using shared types
 pub const Writer = writer.Writer;
diff --git a/toolchain/mkafsdisk/afs/writer.zig b/toolchain/mkafsdisk/afs/writer.zig
index 9910e14..2315f32 100644
--- a/toolchain/mkafsdisk/afs/writer.zig
+++ b/toolchain/mkafsdisk/afs/writer.zig
@@ -1,11 +1,9 @@
 //! AFS Writer for mkafsdisk
-//! Creates AFS filesystem structures on disk using shared/afs types.
 
 const std = @import("std");
 const strings = @import("../strings/strings.zig");
 const shared_afs = @import("shared").afs;
 
-// Import shared types and constants
 const constants = shared_afs.constants;
 const types = shared_afs.types;
 const write_ops = shared_afs.write;
@@ -55,15 +53,6 @@ pub const Writer = struct {
         const cell_size = constants.default_cell_size;
         const total_cells: u32 = @intCast(partition_size_bytes / cell_size);
 
-        // Layout:
-        // Cell 0: Volume Header
-        // Cell 1: Alternate Volume Header
-        // Cell 2: Journal Info
-        // Cells 3-10: Journal (8 cells = 32KB)
-        // Cells 11-14: Allocation Map (4 cells for up to 128K cells)
-        // Cells 15-30: Index B-tree (16 cells)
-        // Cells 31+: Data
-
         const allocation_map_start: u32 = 11;
         const allocation_map_cells: u32 = 4;
         const index_start: u32 = allocation_map_start + allocation_map_cells;
diff --git a/toolchain/mkafsdisk/main.zig b/toolchain/mkafsdisk/main.zig
index 681ec78..2b95881 100644
--- a/toolchain/mkafsdisk/main.zig
+++ b/toolchain/mkafsdisk/main.zig
@@ -1,18 +1,13 @@
 //! mkafsdisk - Creates bootable Akiba disk image
-//!
-//! Creates a GPT disk with:
-//! - Partition 1: ESP (FAT32) with /EFI/BOOT/BOOTX64.EFI
-//! - Partition 2: AFS with /system/akiba/mirai.kernel
 
 const std = @import("std");
 const strings = @import("strings/strings.zig");
 const afs = @import("afs/afs.zig");
 
 const SECTOR_SIZE: u32 = 512;
-const ESP_SIZE_SECTORS: u32 = 69632; // 34MB so cluster count stays above the FAT32 minimum of 65525
+const ESP_SIZE_SECTORS: u32 = 69632;
 const FAT32_MINIMUM_CLUSTERS: u32 = 65525;
 
-// ESP partition type GUID: C12A7328-F81F-11D2-BA4B-00A0C93EC93B
 const ESP_TYPE_GUID = [16]u8{
     0x28, 0x73, 0x2A, 0xC1,
     0x1F, 0xF8, 0xD2, 0x11,
@@ -55,14 +50,6 @@ fn create_disk_image(
     const total_bytes: u64 = @as(u64, size_megabytes) * 1024 * 1024;
     const total_sectors: u32 = @intCast(total_bytes / SECTOR_SIZE);
 
-    // Partition layout:
-    // Sector 0: Protective MBR
-    // Sector 1: GPT Header
-    // Sectors 2-33: GPT Partition Entries
-    // Sectors 2048-67583: ESP (FAT32)
-    // Sectors 67584+: AFS
-    // Last 33 sectors: Backup GPT
-
     const esp_start_sector: u32 = 2048;
     const esp_end_sector: u32 = esp_start_sector + ESP_SIZE_SECTORS - 1;
     const afs_start_sector: u32 = esp_end_sector + 1;
@@ -85,12 +72,10 @@ fn create_disk_image(
 fn write_protective_mbr(file: std.fs.File, total_sectors: u32) !void {
     var mbr: [512]u8 = [_]u8{0} ** 512;
 
-    // Protective MBR partition entry at offset 0x1BE
-    mbr[0x1BE + 4] = 0xEE; // GPT protective type
+    mbr[0x1BE + 4] = 0xEE;
     std.mem.writeInt(u32, mbr[0x1BE + 8 ..][0..4], 1, .little);
     std.mem.writeInt(u32, mbr[0x1BE + 12 ..][0..4], total_sectors - 1, .little);
 
-    // Boot signature
     mbr[510] = 0x55;
     mbr[511] = 0xAA;
 
@@ -123,30 +108,23 @@ fn write_gpt(
     afs_end: u32,
     total_sectors: u32,
 ) !void {
-    // Partition entries (128 entries * 128 bytes = 16KB)
     var partition_entries: [16384]u8 = [_]u8{0} ** 16384;
 
-    // ESP partition entry
     @memcpy(partition_entries[0..16], &ESP_TYPE_GUID);
-    // Unique partition GUID
     const esp_unique_guid = [16]u8{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
     @memcpy(partition_entries[16..32], &esp_unique_guid);
     std.mem.writeInt(u64, partition_entries[32..40], esp_start, .little);
     std.mem.writeInt(u64, partition_entries[40..48], esp_end, .little);
-    // Name: strings.names.esp_partition_name
     const esp_name = strings.names.esp_partition_name;
     for (esp_name, 0..) |char, index| {
         partition_entries[56 + index * 2] = char;
     }
 
-    // AFS partition entry
     @memcpy(partition_entries[128..144], &afs.constants.partition_type_guid);
-    // Unique partition GUID
     const afs_unique_guid = [16]u8{ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20 };
     @memcpy(partition_entries[144..160], &afs_unique_guid);
     std.mem.writeInt(u64, partition_entries[160..168], afs_start, .little);
     std.mem.writeInt(u64, partition_entries[168..176], afs_end, .little);
-    // Name: strings.names.afs_partition_name
     const afs_name = strings.names.afs_partition_name;
     for (afs_name, 0..) |char, index| {
         partition_entries[184 + index * 2] = char;
@@ -154,39 +132,33 @@ fn write_gpt(
 
     const entries_crc = calculate_crc32(&partition_entries);
 
-    // GPT Header
     var gpt_header: [512]u8 = [_]u8{0} ** 512;
     @memcpy(gpt_header[0..8], strings.names.gpt_signature);
-    std.mem.writeInt(u32, gpt_header[8..12], 0x00010000, .little); // Revision
-    std.mem.writeInt(u32, gpt_header[12..16], 92, .little); // Header size
-    // CRC at offset 16 - filled in later
-    std.mem.writeInt(u64, gpt_header[24..32], 1, .little); // Current LBA
-    std.mem.writeInt(u64, gpt_header[32..40], @as(u64, total_sectors) - 1, .little); // Backup LBA
-    std.mem.writeInt(u64, gpt_header[40..48], 34, .little); // First usable LBA
-    std.mem.writeInt(u64, gpt_header[48..56], @as(u64, total_sectors) - 34, .little); // Last usable LBA
-    // Disk GUID
+    std.mem.writeInt(u32, gpt_header[8..12], 0x00010000, .little);
+    std.mem.writeInt(u32, gpt_header[12..16], 92, .little);
+    std.mem.writeInt(u64, gpt_header[24..32], 1, .little);
+    std.mem.writeInt(u64, gpt_header[32..40], @as(u64, total_sectors) - 1, .little);
+    std.mem.writeInt(u64, gpt_header[40..48], 34, .little);
+    std.mem.writeInt(u64, gpt_header[48..56], @as(u64, total_sectors) - 34, .little);
     const disk_guid = [16]u8{ 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 };
     @memcpy(gpt_header[56..72], &disk_guid);
-    std.mem.writeInt(u64, gpt_header[72..80], 2, .little); // Partition entries LBA
-    std.mem.writeInt(u32, gpt_header[80..84], 128, .little); // Number of entries
-    std.mem.writeInt(u32, gpt_header[84..88], 128, .little); // Entry size
-    std.mem.writeInt(u32, gpt_header[88..92], entries_crc, .little); // Entries CRC
+    std.mem.writeInt(u64, gpt_header[72..80], 2, .little);
+    std.mem.writeInt(u32, gpt_header[80..84], 128, .little);
+    std.mem.writeInt(u32, gpt_header[84..88], 128, .little);
+    std.mem.writeInt(u32, gpt_header[88..92], entries_crc, .little);
 
     const header_crc = calculate_crc32(gpt_header[0..92]);
     std.mem.writeInt(u32, gpt_header[16..20], header_crc, .little);
 
-    // Write primary GPT
     try file.seekTo(SECTOR_SIZE);
     try file.writeAll(&gpt_header);
     try file.seekTo(2 * SECTOR_SIZE);
     try file.writeAll(&partition_entries);
 
-    // Write backup GPT (entries before header at end of disk)
     const backup_entries_lba = total_sectors - 33;
     try file.seekTo(@as(u64, backup_entries_lba) * SECTOR_SIZE);
     try file.writeAll(&partition_entries);
 
-    // Backup GPT header
     var backup_header = gpt_header;
     std.mem.writeInt(u64, backup_header[24..32], @as(u64, total_sectors) - 1, .little);
     std.mem.writeInt(u64, backup_header[32..40], 1, .little);
@@ -220,7 +192,6 @@ fn create_esp(
     const data_sectors = available_sectors - (fat_size_sectors * fat_count);
     const total_clusters = data_sectors / sectors_per_cluster;
 
-    // FAT32 Boot Sector
     var boot_sector: [512]u8 = [_]u8{0} ** 512;
     boot_sector[0] = 0xEB;
     boot_sector[1] = 0x58;
@@ -255,7 +226,6 @@ fn create_esp(
     try file.seekTo(esp_start_byte);
     try file.writeAll(&boot_sector);
 
-    // FSInfo
     var fsinfo: [512]u8 = [_]u8{0} ** 512;
     std.mem.writeInt(u32, fsinfo[0..4], 0x41615252, .little);
     std.mem.writeInt(u32, fsinfo[484..488], 0x61417272, .little);
@@ -266,11 +236,9 @@ fn create_esp(
     try file.seekTo(esp_start_byte + SECTOR_SIZE);
     try file.writeAll(&fsinfo);
 
-    // Backup boot sector
     try file.seekTo(esp_start_byte + 6 * SECTOR_SIZE);
     try file.writeAll(&boot_sector);
 
-    // FAT table
     const fat_bytes = fat_size_sectors * SECTOR_SIZE;
     var fat_table = try allocator.alloc(u8, fat_bytes);
     defer allocator.free(fat_table);
@@ -284,24 +252,19 @@ fn create_esp(
     const fat2_offset = fat1_offset + fat_bytes;
     const data_start = fat2_offset + fat_bytes;
 
-    // Copy EFI/BOOT/BOOTX64.EFI from source
     var current_cluster: u32 = 3;
 
-    // Origin stack (root)
     var origin_stack: [512]u8 = [_]u8{0} ** 512;
 
-    // EFI stack entry in origin
     @memcpy(origin_stack[0..11], strings.names.dir_entry_efi);
     origin_stack[11] = 0x10;
     std.mem.writeInt(u16, origin_stack[26..28], @intCast(current_cluster), .little);
     const efi_cluster = current_cluster;
     current_cluster += 1;
 
-    // Write origin stack at cluster 2
     try file.seekTo(data_start);
     try file.writeAll(&origin_stack);
 
-    // EFI stack
     var efi_stack: [512]u8 = [_]u8{0} ** 512;
     @memcpy(efi_stack[0..11], strings.names.dir_entry_current);
     efi_stack[11] = 0x10;
@@ -318,7 +281,6 @@ fn create_esp(
     try file.writeAll(&efi_stack);
     std.mem.writeInt(u32, fat_table[efi_cluster * 4 ..][0..4], 0x0FFFFFFF, .little);
 
-    // BOOT stack
     var boot_stack: [512]u8 = [_]u8{0} ** 512;
     @memcpy(boot_stack[0..11], strings.names.dir_entry_current);
     boot_stack[11] = 0x10;
@@ -327,7 +289,6 @@ fn create_esp(
     boot_stack[43] = 0x10;
     std.mem.writeInt(u16, boot_stack[58..60], @intCast(efi_cluster), .little);
 
-    // Try to find and copy BOOTX64.EFI
     const bootloader_location = try std.fs.path.join(allocator, &.{ source_location, strings.names.stack_efi, strings.names.stack_boot, strings.names.unit_bootloader });
     defer allocator.free(bootloader_location);
 
@@ -349,7 +310,6 @@ fn create_esp(
 
     std.debug.print(strings.messages.bootloader_adding, .{ bootloader_size, bootloader_clusters });
 
-    // Add BOOTX64.EFI entry
     @memcpy(boot_stack[64..75], strings.names.dir_entry_bootloader);
     boot_stack[75] = 0x20;
     std.mem.writeInt(u16, boot_stack[90..92], @intCast(current_cluster), .little);
@@ -360,7 +320,6 @@ fn create_esp(
     try file.writeAll(&boot_stack);
     std.mem.writeInt(u32, fat_table[boot_cluster * 4 ..][0..4], 0x0FFFFFFF, .little);
 
-    // Copy bootloader data
     var cluster_index: u32 = 0;
     while (cluster_index < bootloader_clusters) : (cluster_index += 1) {
         var buffer: [512]u8 = [_]u8{0} ** 512;
@@ -375,7 +334,6 @@ fn create_esp(
         std.mem.writeInt(u32, fat_table[cluster_number * 4 ..][0..4], next_cluster, .little);
     }
 
-    // Write FAT tables
     try file.seekTo(fat1_offset);
     try file.writeAll(fat_table);
     try file.seekTo(fat2_offset);