chore: normalize panic messages

40 files changed, 610 insertions, 112 deletions

diff --git a/arch/x86_64/arch/bus/cpu.cpp b/arch/x86_64/arch/bus/cpu.cpp
index 4b9edffc..a21d910d 100644
--- a/arch/x86_64/arch/bus/cpu.cpp
+++ b/arch/x86_64/arch/bus/cpu.cpp
@@ -36,7 +36,7 @@ namespace arch::bus
         auto madt = kapi::acpi::get_table<::acpi::table_signature_v<::acpi::madt>>();
         if (!madt)
         {
-          kstd::println("[x86_64:BUS] Failed to find ACPI APIC table");
+          kstd::println("[ARCH:BUS] Failed to find ACPI APIC table");
           return;
         }
 
diff --git a/arch/x86_64/arch/cpu/initialization.cpp b/arch/x86_64/arch/cpu/initialization.cpp
index 49870eb7..83493fe3 100644
--- a/arch/x86_64/arch/cpu/initialization.cpp
+++ b/arch/x86_64/arch/cpu/initialization.cpp
@@ -123,10 +123,10 @@ namespace arch::cpu
       gdt_user_code_descriptor, gdt_user_data_descriptor,   tss_descriptor,
     };
 
-    kstd::println("[x86_64:SYS] Reloading Global Descriptor Table.");
+    kstd::println("[ARCH:SYS] Reloading Global Descriptor Table.");
     gdt.load(1, 2);
 
-    kstd::println("[x86_64:SYS] Initializing Interrupt Descriptor Table.");
+    kstd::println("[ARCH:SYS] Initializing Interrupt Descriptor Table.");
     auto static idt = interrupt_descriptor_table{};
     idt.load();
   }
diff --git a/arch/x86_64/arch/cpu/interrupts.cpp b/arch/x86_64/arch/cpu/interrupts.cpp
index 99186e2d..c825e8ab 100644
--- a/arch/x86_64/arch/cpu/interrupts.cpp
+++ b/arch/x86_64/arch/cpu/interrupts.cpp
@@ -141,11 +141,11 @@ namespace arch::cpu
           if (has_error_code(static_cast<exception>(number)))
           {
             kstd::println(kstd::print_sink::stderr,
-                          "[x86_64:CPU] Unhandled exception number {:#04x} received with code {:#04x}", number, code);
+                          "[ARCH:CPU] Unhandled exception number {:#04x} received with code {:#04x}", number, code);
           }
           else
           {
-            kstd::println(kstd::print_sink::stderr, "[x86_64:CPU] Unhandled exception number {:#04x} received", number);
+            kstd::println(kstd::print_sink::stderr, "[ARCH:CPU] Unhandled exception number {:#04x} received", number);
           }
         }
       }
@@ -155,7 +155,7 @@ namespace arch::cpu
 
         if (kapi::interrupts::dispatch(irq_number) == kapi::interrupts::status::unhandled)
         {
-          kstd::println(kstd::print_sink::stderr, "[x86_64:CPU] Unhandled interrupt {:#04x} (IRQ{})", number,
+          kstd::println(kstd::print_sink::stderr, "[ARCH:CPU] Unhandled interrupt {:#04x} (IRQ{})", number,
                         irq_number);
         }
 
diff --git a/arch/x86_64/arch/devices/init.cpp b/arch/x86_64/arch/devices/init.cpp
index 9c20d413..639e8870 100644
--- a/arch/x86_64/arch/devices/init.cpp
+++ b/arch/x86_64/arch/devices/init.cpp
@@ -46,7 +46,7 @@ namespace arch::devices
     {
       if (kapi::acpi::init(*acpi_root_pointer))
       {
-        kstd::println("[x86_64:DEV] ACPI subsystem initialized.");
+        kstd::println("[ARCH:DEV] ACPI subsystem initialized.");
       }
     }
 
@@ -55,7 +55,7 @@ namespace arch::devices
 
   auto init_legacy_devices() -> void
   {
-    kstd::println("[x86_64:DEV] Initializing ISA bus...");
+    kstd::println("[ARCH:DEV] Initializing ISA bus...");
 
     auto root_bus = kapi::devices::get_root_bus();
     auto isa_bus = kstd::make_shared<arch::bus::isa>();
diff --git a/arch/x86_64/arch/drivers/cpu/lapic.cpp b/arch/x86_64/arch/drivers/cpu/lapic.cpp
index f8aa8e90..c02c3df6 100644
--- a/arch/x86_64/arch/drivers/cpu/lapic.cpp
+++ b/arch/x86_64/arch/drivers/cpu/lapic.cpp
@@ -126,7 +126,7 @@ namespace arch::drivers::cpu
       if (!kapi::memory::map_mmio_region(m_mapped_region, kapi::memory::physical_address{mmio->start},
                                          kapi::memory::page_mapper::flags::writable))
       {
-        kstd::println(kstd::print_sink::stderr, "[x86_64:DRV] LAPIC {} MMIO mapping failed!", signature->hardware_id());
+        kstd::println(kstd::print_sink::stderr, "[ARCH:DRV] LAPIC {} MMIO mapping failed!", signature->hardware_id());
         return kstd::failure(make_error_code(kstd::errc::io_error));
       }
 
@@ -142,12 +142,12 @@ namespace arch::drivers::cpu
 
       write_register(registers::spurious_interrupt_vector, lapic_enable_bit | spurious_interrupt_vector);
 
-      kstd::println("[x86_64:DRV] LAPIC initialized. version: {#x} | max_lvt_entry: {} | eoi_suppression: {:s}",
+      kstd::println("[ARCH:DRV] LAPIC initialized. version: {#x} | max_lvt_entry: {} | eoi_suppression: {:s}",
                     version, highest_lvt_entry_index, supports_eoi_broadcast_suppression);
     }
     else
     {
-      kstd::println("[x86_64:DRV] LAPIC {} is not on the BSP, deferring initialization.", signature->hardware_id());
+      kstd::println("[ARCH:DRV] LAPIC {} is not on the BSP, deferring initialization.", signature->hardware_id());
     }
 
     return kstd::success();
diff --git a/arch/x86_64/arch/memory/higher_half_mapper.cpp b/arch/x86_64/arch/memory/higher_half_mapper.cpp
index 75adb3c5..974b00a0 100644
--- a/arch/x86_64/arch/memory/higher_half_mapper.cpp
+++ b/arch/x86_64/arch/memory/higher_half_mapper.cpp
@@ -33,7 +33,7 @@ namespace arch::memory
 
     if (entry.present())
     {
-      kapi::system::panic("[x86_64:MEM] Tried to map a page that is already mapped!");
+      kapi::system::panic("[ARCH:MEM] Tried to map a page that is already mapped!");
     }
 
     entry.frame(frame, to_table_flags(flags) | page_table::entry::flags::present);
@@ -45,7 +45,7 @@ namespace arch::memory
   {
     if (!try_unmap(page))
     {
-      kapi::system::panic("[x86_64:MEM] Tried to unmap a page that is not mapped!");
+      kapi::system::panic("[ARCH:MEM] Tried to unmap a page that is not mapped!");
     }
   }
 
diff --git a/arch/x86_64/arch/memory/kernel_mapper.cpp b/arch/x86_64/arch/memory/kernel_mapper.cpp
index a15a1d9e..070a7866 100644
--- a/arch/x86_64/arch/memory/kernel_mapper.cpp
+++ b/arch/x86_64/arch/memory/kernel_mapper.cpp
@@ -50,7 +50,7 @@ namespace arch::memory
     auto elf_information = m_mbi->maybe_elf_symbols<elf::format::elf64>();
     if (!elf_information)
     {
-      kapi::system::panic("[x86_64:MEM] ELF section information is not available.");
+      kapi::system::panic("[ARCH:MEM] ELF section information is not available.");
     }
 
     auto sections = *elf_information;
@@ -64,7 +64,7 @@ namespace arch::memory
 
     if (allocated_sections.empty())
     {
-      kapi::system::panic("[x86_64:MEM] No allocated ELF sections were found.");
+      kapi::system::panic("[ARCH:MEM] No allocated ELF sections were found.");
     }
 
     std::ranges::for_each(allocated_sections,
@@ -78,7 +78,7 @@ namespace arch::memory
     auto linear_start_address = kapi::memory::linear_address{section.virtual_load_address};
     auto physical_start_address = kapi::memory::physical_address{section.virtual_load_address & ~m_kernel_load_base};
 
-    kstd::println("[x86_64:MEM] mapping {}"
+    kstd::println("[ARCH:MEM] mapping {}"
                   "\n  {} bytes -> page count: {}"
                   "\n  {} @ {}",
                   name, section.size, number_of_pages, linear_start_address, physical_start_address);
diff --git a/arch/x86_64/kapi/boot_modules.cpp b/arch/x86_64/kapi/boot_modules.cpp
index 607aca4e..95ed0287 100644
--- a/arch/x86_64/kapi/boot_modules.cpp
+++ b/arch/x86_64/kapi/boot_modules.cpp
@@ -25,7 +25,7 @@ namespace kapi::boot_modules
 
   auto init(kapi::devices::bus & bus) -> void
   {
-    kstd::println("[x86_64:BOOT_MODULES] Attaching boot modules.");
+    kstd::println("[ARCH:BOOT_MODULES] Attaching boot modules.");
 
     auto modules = boot::bootstrap_information.mbi->modules();
 
diff --git a/arch/x86_64/kapi/cpu.cpp b/arch/x86_64/kapi/cpu.cpp
index 2bec841c..11a12656 100644
--- a/arch/x86_64/kapi/cpu.cpp
+++ b/arch/x86_64/kapi/cpu.cpp
@@ -15,7 +15,7 @@ namespace kapi::cpu
 
     if (is_initialized.test_and_set())
     {
-      system::panic("[x86_64] CPU has already been initialized.");
+      system::panic("[ARCH:CPU] CPU has already been initialized.");
     }
 
     arch::cpu::initialize_descriptors();
diff --git a/arch/x86_64/kapi/devices.cpp b/arch/x86_64/kapi/devices.cpp
index 1e2fedd6..39dbc010 100644
--- a/arch/x86_64/kapi/devices.cpp
+++ b/arch/x86_64/kapi/devices.cpp
@@ -39,7 +39,7 @@ namespace kapi::devices
     for (auto driver : descriptors)
     {
       auto instance = driver->make_instance();
-      kstd::println("[x86_64:DRV] registering driver '{}' ({})", instance->name(), driver->name());
+      kstd::println("[ARCH:DRV] registering driver '{}' ({})", instance->name(), driver->name());
       kapi::devices::driver_registry::get().add(std::move(instance));
     }
   }
@@ -54,7 +54,7 @@ namespace kapi::devices
   {
     if (!cpu_bus)
     {
-      system::panic("[x86_64:DEV] The CPU topology has not yet been initialized!");
+      system::panic("[ARCH:DEV] The CPU topology has not yet been initialized!");
     }
 
     return cpu_bus;
@@ -64,7 +64,7 @@ namespace kapi::devices
   {
     if (cpu_bus)
     {
-      system::panic("[x86_64:DEV] The CPU topology has already been initialized!");
+      system::panic("[ARCH:DEV] The CPU topology has already been initialized!");
     }
 
     cpu_bus = kstd::make_shared<arch::bus::cpu>();
diff --git a/arch/x86_64/kapi/memory.cpp b/arch/x86_64/kapi/memory.cpp
index 37b4c7f3..9cf955e5 100644
--- a/arch/x86_64/kapi/memory.cpp
+++ b/arch/x86_64/kapi/memory.cpp
@@ -45,7 +45,7 @@ namespace kapi::memory
       auto memory_map = boot::bootstrap_information.mbi->maybe_memory_map();
       if (!memory_map)
       {
-        system::panic("[x86_64] Failed to create early allocator, no memory map available.");
+        system::panic("[ARCH:MEM] Failed to create early allocator, no memory map available.");
       }
 
       auto const & mbi = boot::bootstrap_information.mbi;
@@ -157,7 +157,7 @@ namespace kapi::memory
       auto next_free_frame = region_based_allocator->next_free_frame();
       if (!next_free_frame)
       {
-        system::panic("[x86_64:MEM] No more free memory!");
+        system::panic("[ARCH:MEM] No more free memory!");
       }
 
       std::ranges::for_each(std::views::iota(kapi::memory::frame{}, *next_free_frame),
@@ -196,26 +196,26 @@ namespace kapi::memory
 
     if (is_initialized.test_and_set())
     {
-      system::panic("[x86_64] Memory management has already been initialized.");
+      system::panic("[ARCH:MEM] Memory management has already been initialized.");
     }
 
-    kstd::println("[x86_64:MEM] Enabling additional CPU protection features.");
+    kstd::println("[ARCH:MEM] Enabling additional CPU protection features.");
 
     enable_cpu_protections();
 
     region_based_allocator.emplace(collect_memory_information());
     set_frame_allocator(*region_based_allocator);
 
-    kstd::println("[x86_64:MEM] Establishing higher-half direct mapping.");
+    kstd::println("[ARCH:MEM] Establishing higher-half direct mapping.");
 
     establish_higher_half_direct_mapping();
 
-    kstd::println("[x86_64:MEM] Preparing new paging hierarchy.");
+    kstd::println("[ARCH:MEM] Preparing new paging hierarchy.");
 
     auto new_pml4_frame = kapi::memory::allocate_frame();
     if (!new_pml4_frame)
     {
-      system::panic("[x86_64:MEM] Failed to allocate new PML4!");
+      system::panic("[ARCH:MEM] Failed to allocate new PML4!");
     }
     auto new_pml4 = arch::memory::to_higher_half_pointer<arch::memory::page_table>(new_pml4_frame->start_address());
     std::construct_at(new_pml4);
@@ -232,7 +232,7 @@ namespace kapi::memory
     auto old_pml4 = static_cast<arch::memory::page_table *>(current_cr3.address());
     (*new_pml4)[256] = (*old_pml4)[256];
 
-    kstd::println("[x86_64:MEM] Switching to new paging hierarchy.");
+    kstd::println("[ARCH:MEM] Switching to new paging hierarchy.");
 
     auto cr3 = arch::cpu::cr3::read();
     cr3.frame(*new_pml4_frame);
@@ -246,7 +246,7 @@ namespace kapi::memory
 
     init_pmm(frame::containing(physical_address{highest_byte}).number() + 1, handoff_to_kernel_pmm);
 
-    kstd::println("[x86_64:MEM] Releasing bootstrap memory allocators.");
+    kstd::println("[ARCH:MEM] Releasing bootstrap memory allocators.");
     region_based_allocator.reset();
   }
 
diff --git a/docs/code_style.md b/docs/code_style.md
new file mode 100644
index 00000000..f417a047
--- /dev/null
+++ b/docs/code_style.md
@@ -0,0 +1,498 @@
+# TeachOS C++ Code Style Guide
+
+This document codifies the C++ coding idioms used throughout the TeachOS kernel.
+It covers language usage, ownership and lifetime models, algorithm selection, error
+propagation, class design, and naming conventions. It does **not** cover token-level
+formatting, which is enforced automatically by the `.clang-format` configuration.
+
+---
+
+## 1. Language Standard and Vocabulary
+
+TeachOS targets **C++23** without compiler extensions (`CMAKE_CXX_EXTENSIONS NO`).
+Standard library features may be used freely where a hosted implementation is
+available (i.e., in `libs/`, `kapi/`, and `kernel/`), but the project ships its own
+standard library subset in `libs/kstd/`. **kstd types must be preferred over their
+`std::` equivalents** wherever a kstd equivalent exists.
+
+| Concept | Preferred | Avoid |
+|---|---|---|
+| Dynamic array | `kstd::vector<T>` | `std::vector<T>` |
+| String (owning) | `kstd::string` | `std::string` |
+| String view | `std::string_view` | (kstd has no alias; use `std::string_view` directly) |
+| Non-owning pointer | `kstd::observer_ptr<T>` | raw `T*` for ownership-neutral access |
+| Shared ownership | `kstd::shared_ptr<T>` | `std::shared_ptr<T>` |
+| Unique ownership | `kstd::unique_ptr<T>` | `std::unique_ptr<T>` |
+| Failable results | `kstd::result<T>` | exceptions, output parameters, `std::optional` for errors |
+| Printing | `kstd::println(...)` | `std::println(...)`, `printf` |
+
+`std::string_view`, `std::span`, `std::array`, `std::optional`, `std::byte`, and the
+`std::ranges` and `std::views` namespaces are used directly from the standard library
+because they have no kstd equivalents.
+
+---
+
+## 2. Function Declarations — Trailing Return Types
+
+**All** functions and member functions use trailing return type syntax, including those
+returning `void`.
+
+```cpp
+// Correct
+auto device_registry::get() -> device_registry &;
+auto bitmap_is_set(std::span<std::byte const> bitmap, std::size_t index) -> bool;
+auto init() -> void;
+
+// Wrong
+device_registry & device_registry::get();
+bool bitmap_is_set(std::span<std::byte const> bitmap, std::size_t index);
+void init();
+```
+
+This rule applies to: free functions, member functions, lambdas with explicit return
+types, and virtual functions. The only exception is constructors and destructors,
+which have no return type at all.
+
+---
+
+## 3. Parameter Passing Conventions
+
+The choice of passing convention encodes intent and must be consistent.
+
+### 3.1 View and cheaply copyable types — pass by value
+
+Types that are designed to be non-owning views or are trivially copyable must be
+passed and returned **by value**. Passing them by `const &` is redundant and adds
+a pointer indirection with no benefit.
+
+This applies to:
+- `std::string_view`
+- `std::span<T>`
+- `kstd::observer_ptr<T>`
+- `kstd::bytes`, `kstd::pages` and similar unit wrappers
+- `kapi::capabilities::facet_id`
+- `kapi::memory::page`, `kapi::memory::frame`, `kapi::memory::physical_address`, `kapi::memory::linear_address`
+
+```cpp
+// Correct
+auto resolve(kapi::capabilities::facet_id id, std::string_view name) -> void *;
+auto has(std::span<std::byte const> data) -> bool;
+
+// Wrong
+auto resolve(kapi::capabilities::facet_id const & id, std::string_view const & name) -> void *;
+```
+
+### 3.2 Large or non-trivial types — pass by `const &`
+
+For types that own heap memory or are non-trivially copyable, use `const &` when the
+callee does not take ownership.
+
+```cpp
+auto do_publish(kstd::string const & name) -> kstd::result<void>;
+auto add_child(kstd::string const & child_name) -> void;
+```
+
+### 3.3 Sink parameters — pass by value and move
+
+When a function is designed to take **ownership** of an argument, accept it by value
+and move it into its destination. This makes the transfer explicit at the call site.
+
+```cpp
+// In the header
+auto add_child(kstd::shared_ptr<device> child) -> void;
+auto do_publish(kstd::shared_ptr<device> device, kstd::string name, ...) -> kstd::result<void>;
+
+// In the implementation
+auto bus::add_child(kstd::shared_ptr<device> child) -> void
+{
+  m_devices.push_back(std::move(child));  // ownership transferred here
+}
+```
+
+### 3.4 Mutable subsystem references — pass by non-const reference
+
+Services and subsystems that are mutated in-place (e.g., `page_mapper &`,
+`driver_state &`, `kapi::devices::bus &`) are passed by non-const reference. This
+expresses that the function operates on a shared, mutable context.
+
+```cpp
+auto remap_kernel(kapi::memory::page_mapper & mapper) -> void;
+auto add_directory_entry(inode & directory, inode & child, driver_state & state, write_batch & batch) -> kstd::result<void>;
+```
+
+---
+
+## 4. Error Handling
+
+### 4.1 Recoverable errors — `kstd::result<T>`
+
+Functions that can fail in an expected, recoverable way must return `kstd::result<T>`
+(an alias for `std::expected<T, kstd::error_code>`). Use the `kstd::success()` and
+`kstd::failure()` helpers consistently.
+
+```cpp
+auto mount(kstd::shared_ptr<inode> parent)
+    -> kstd::result<std::pair<kstd::shared_ptr<inode>, state *>>;
+
+// In the implementation
+if (!device)
+{
+  return kstd::failure(make_error_code(kstd::errc::invalid_argument));
+}
+return kstd::success(result_value);
+```
+
+Callers must check the result before using its value. The idiomatic check is:
+
+```cpp
+auto result = some_function();
+if (!result)
+{
+  return kstd::failure(result.error());  // propagate
+}
+// use *result
+```
+
+Monadic composition (`transform`, `and_then`, `or_else`) is preferred over
+manual if-check-and-return chains when it produces clearer code.
+
+### 4.2 Unrecoverable errors — `kapi::system::panic`
+
+Violations of kernel invariants (e.g., a subsystem used before being initialized,
+OOM during boot) call `kapi::system::panic(...)`. `panic` is `[[noreturn]]`. It must
+not be used for recoverable errors.
+
+Log prefix convention: `[SUBSYSTEM:TAG] message`. Examples: `[OS:DEV]`,
+`[OS:VFS]`, `[ARCH:DRV]`.
+
+```cpp
+if (!instance)
+{
+  system::panic("[OS:DEV] Device registry has not been initialized.");
+}
+```
+
+### 4.3 No exceptions
+
+The kernel does not use C++ exceptions. Do not write `throw` or `try`/`catch` in
+kernel code.
+
+---
+
+## 5. Ownership and Lifetime
+
+### 5.1 Shared ownership — `kstd::shared_ptr`
+
+Use `kstd::shared_ptr<T>` when a resource is co-owned by multiple subsystems and
+its lifetime must be extended by any of them (e.g., `device`, `inode`, `dentry`).
+Weak back-references that must not extend lifetime use `kstd::weak_ptr<T>`.
+
+### 5.2 Non-owning references — `kstd::observer_ptr` and raw references
+
+Use `kstd::observer_ptr<T>` to express a non-owning pointer where null is a valid
+state and the holder has no say in the lifetime of the target. Use a raw reference
+(`T &` or `T const &`) when null is not valid and the reference is short-lived (i.e.,
+a function parameter or a local alias).
+
+Never use raw `T *` to mean "sometimes I own this, sometimes I don't". Ownership must
+be expressed unambiguously through the pointer type.
+
+### 5.3 Driver data — `kstd::shared_ptr<void>`
+
+Drivers attach their state to a `device` using an untyped `kstd::shared_ptr<void>`
+via `device::set_driver_data`. A driver retrieves its state via `device::driver_data`.
+This allows the device tree to destroy driver data automatically when the device is
+released, without the device knowing the concrete driver type.
+
+---
+
+## 6. Algorithm and Range Usage
+
+### 6.1 Prefer `std::ranges` algorithms over manual loops
+
+When processing a range to search, filter, transform, or reduce, use the appropriate
+`std::ranges` algorithm or view pipeline instead of writing a raw `for` loop.
+
+```cpp
+// Correct
+auto already_published = std::ranges::any_of(
+    m_entries, [&](auto const & entry) {
+      return entry.id() == id && entry.device().get() == device.get();
+    });
+
+std::ranges::for_each(observers, [&](auto observer) { /* ... */ });
+
+// Wrong — manual linear scan for a boolean result
+for (auto const & entry : m_entries)
+{
+  if (entry.id() == id && entry.device().get() == device.get())
+  {
+    return true;
+  }
+}
+return false;
+```
+
+Acceptable uses of explicit loops include:
+- Accumulation or mutation that modifies state in-place and cannot be cleanly
+  expressed with a ranges algorithm.
+- Low-level routines dealing with raw memory arithmetic (allocators, page mappers).
+- Iterator-pair loops in library internals (`kstd::vector`, `kstd::basic_string`).
+
+### 6.2 Prefer view composition over intermediate containers
+
+Build processing pipelines using `std::views::filter`, `std::views::transform`,
+`std::views::reverse`, `std::views::split`, and `std::ranges::subrange` rather than
+materialising intermediate vectors.
+
+```cpp
+// Correct
+auto descriptors = std::span{&__start_platform_drivers, &__stop_platform_drivers}
+                   | std::views::filter([](auto p) { return p != nullptr; });
+
+auto modules_view = std::ranges::subrange(begin(), end())
+                    | std::views::filter(filter_modules)
+                    | std::views::transform(transform_module);
+```
+
+### 6.3 Do not call the same function twice to avoid storing the result
+
+If an intermediate value is needed more than once, store it in a local variable. This
+applies especially to factory calls and heap allocations.
+
+```cpp
+// Wrong — double invocation, two allocations, different objects
+for (auto driver : descriptors)
+{
+  kstd::println("registering driver '{}'", driver->make_instance()->name());
+  registry.add(driver->make_instance());
+}
+
+// Correct
+for (auto driver : descriptors)
+{
+  auto instance = driver->make_instance();
+  kstd::println("registering driver '{}'", instance->name());
+  registry.add(std::move(instance));
+}
+```
+
+---
+
+## 7. Class and Struct Design
+
+### 7.1 Prefer `struct` over `class`
+
+The entire codebase uses `struct` for all type definitions with explicit `private:`
+sections where necessary. Do not introduce `class`.
+
+### 7.2 Member ordering within a type
+
+Follow this ordering within a `struct`:
+
+1. Nested types and type aliases.
+2. Static data members and static constexpr constants (e.g., `static constexpr auto id = ...`).
+3. Constructors and destructor.
+4. Public member functions.
+5. `protected:` section with virtual hooks.
+6. `private:` section with helper functions, then data members.
+
+Data members are always in the `private` section and always prefixed with `m_`.
+
+```cpp
+struct facet_registry
+{
+  struct entry { /* ... */ };          // 1. nested type
+
+  facet_registry() = default;          // 3. constructor
+
+  auto static init() -> void;          // 4. public interface
+  auto static get() -> facet_registry &;
+  auto publish(...) -> kstd::result<void>;
+
+private:
+  auto do_publish(...) -> kstd::result<void>;  // 6a. private helpers
+
+  mutable tracked_mutex m_lock{};      // 6b. data members, m_ prefix
+  kstd::vector<entry> m_entries;
+};
+```
+
+### 7.3 `explicit` on single-argument constructors
+
+Mark every single-argument constructor `explicit` unless an implicit conversion is
+intentional and documented. A deliberate implicit constructor must be accompanied by
+a comment explaining the decision.
+
+```cpp
+// Correct
+explicit device(kstd::string const & name);
+constexpr explicit facet_id(std::string_view name);
+
+// Intentional implicit — documented at the declaration
+//! This constructor allows implicit conversion from chunk<...> to page for
+//! convenience. It is deliberately not explicit.
+constexpr page(chunk other) : chunk{other} {}
+```
+
+### 7.4 Declare deleted special members explicitly
+
+If a type is not copyable or not movable, declare the deleted special members
+explicitly rather than relying on implicit suppression.
+
+```cpp
+device(device const &) = delete;
+auto operator=(device const &) -> device & = delete;
+```
+
+### 7.5 Virtual destructors
+
+Every base class with virtual member functions must have a `virtual` destructor,
+defaulted if not otherwise needed.
+
+```cpp
+virtual ~driver_descriptor() = default;
+virtual ~facet_registry_observer() = default;
+```
+
+---
+
+## 8. Static Singletons
+
+Several subsystems expose a single global instance via an `init()`/`get()` pair.
+Follow this pattern:
+
+- Store the instance in an anonymous namespace as a `constinit std::optional<T>`.
+- `init()` asserts the instance is not yet constructed, then `emplace()`s it.
+- `get()` asserts the instance exists and returns a reference to it.
+- Both functions panic on violation rather than returning an error code, because
+  incorrect call order is a programming error, not a recoverable runtime condition.
+
+```cpp
+namespace
+{
+  auto constinit instance = std::optional<device_registry>{};
+}
+
+auto device_registry::init() -> void
+{
+  if (instance)
+  {
+    system::panic("[OS:DEV] Device registry has already been initialized.");
+  }
+  instance.emplace();
+}
+
+auto device_registry::get() -> device_registry &
+{
+  if (!instance)
+  {
+    system::panic("[OS:DEV] Device registry has not been initialized.");
+  }
+  return *instance;
+}
+```
+
+---
+
+## 9. Enumerations
+
+All enumerations use `enum struct` (scoped enums), never plain `enum`. Specify the
+underlying type explicitly when the representation matters (e.g., for hardware
+register fields).
+
+```cpp
+// Correct
+enum struct state
+{
+  uninitialized,
+  present,
+  bound,
+};
+
+// Wrong
+enum state { uninitialized, present, bound };
+```
+
+---
+
+## 10. Naming
+
+| Symbol | Convention | Example |
+|---|---|---|
+| Types (struct, enum) | `lower_case` | `device_registry`, `facet_id` |
+| Functions and methods | `lower_case` | `add_child`, `make_instance` |
+| Local variables | `lower_case` | `entry`, `block_index` |
+| Private data members | `m_` prefix, `lower_case` | `m_entries`, `m_driver_data` |
+| Template type parameters | `CamelCase` | `ValueType`, `FacetType` |
+| Constants and constexpr variables | `lower_case` | `page_size`, `direct_block_count` |
+| Type aliases | `lower_case` | `value_type`, `size_type` |
+| Namespaces | `lower_case` | `kapi::devices`, `kernel::vfs` |
+
+Namespaces reflect directory structure: `kernel::vfs`, `kernel::filesystems::ext2`,
+`arch::devices`, etc.
+
+---
+
+## 11. `[[nodiscard]]`
+
+Mark any function `[[nodiscard]]` whose return value the caller should not silently
+discard. This includes in particular:
+
+- All functions returning `kstd::result<T>`.
+- All query functions (getters, lookups) that return computed data.
+- Factory functions and builder utilities.
+
+```cpp
+[[nodiscard]] auto resolve(kapi::capabilities::facet_id id, std::string_view name) -> void *;
+[[nodiscard]] auto children() const -> kstd::vector<kstd::shared_ptr<device>>;
+[[nodiscard]] auto request_resource(resource_type type, std::size_t index = 0) const -> kstd::result<resource>;
+```
+
+---
+
+## 12. `constexpr` and `constinit`
+
+Mark functions `constexpr` whenever they can be evaluated at compile time or in
+constant expressions, even if they are also called at runtime. Mark module-scope
+variables `constinit` to guarantee zero-initialization before any dynamic
+initialization runs — important in a kernel with no well-defined global
+initialization order.
+
+---
+
+## 13. Documentation
+
+Every non-trivial public type, function, and data member must be documented with a
+Doxygen comment using the `//!` line style.
+
+```cpp
+//! A brief one-line description.
+//!
+//! Optional longer description providing context.
+//!
+//! @param name Description of the parameter.
+//! @return Description of the return value.
+//! @warning Any important warnings or preconditions.
+auto add_child(kstd::shared_ptr<device> child) -> void;
+```
+
+Doxygen grouping (`@addtogroup`, `@{`, `@}`) is used to organise the API surface into
+logical sections visible in generated documentation.
+
+---
+
+## 14. Header Guards
+
+All headers use traditional include guards, not `#pragma once`. The guard name follows
+the pattern `TEACHOS_<SUBPACKAGE>_<PATH>_HPP`, where each path component is
+uppercased and separators are replaced by `_`.
+
+```cpp
+#ifndef TEACHOS_KAPI_DEVICES_BUS_HPP
+#define TEACHOS_KAPI_DEVICES_BUS_HPP
+// ...
+#endif
+```
+
+The closing `#endif` carries no comment with the guard name.
diff --git a/kernel/kapi/cpu.cpp b/kernel/kapi/cpu.cpp
index 44331908..61f13edc 100644
--- a/kernel/kapi/cpu.cpp
+++ b/kernel/kapi/cpu.cpp
@@ -16,7 +16,7 @@ namespace kapi::cpu
       kstd::println(kstd::print_sink::stderr, "\tWrite: {}", context.is_write_access);
       kstd::println(kstd::print_sink::stderr, "\tUser: {}", context.is_user_mode);
 
-      kapi::system::panic("Halting the system due to an unrecoverable page fault.");
+      kapi::system::panic("[OS:CPU] Halting the system due to an unrecoverable page fault.");
     }
   }  // namespace
 
diff --git a/kernel/kapi/devices/driver_registry.cpp b/kernel/kapi/devices/driver_registry.cpp
index 7abb121f..405596cd 100644
--- a/kernel/kapi/devices/driver_registry.cpp
+++ b/kernel/kapi/devices/driver_registry.cpp
@@ -38,7 +38,7 @@ namespace kapi::devices
   {
     if (registry.has_value())
     {
-      system::panic("[kernel] Device driver registry has already been initialized.");
+      system::panic("[OS:DRV] Device driver registry has already been initialized.");
     }
 
     registry.emplace();
@@ -48,7 +48,7 @@ namespace kapi::devices
   {
     if (!registry)
     {
-      system::panic("[kernel] Device driver registry has not been initialized.");
+      system::panic("[OS:DRV] Device driver registry has not been initialized.");
     }
 
     return *registry;
diff --git a/kernel/kapi/devices/facet_registry.cpp b/kernel/kapi/devices/facet_registry.cpp
index b2d12c86..2974c71e 100644
--- a/kernel/kapi/devices/facet_registry.cpp
+++ b/kernel/kapi/devices/facet_registry.cpp
@@ -29,7 +29,7 @@ namespace kapi::devices
   {
     if (registry.has_value())
     {
-      system::panic("[kernel] Device facet registry has already been initialized.");
+      system::panic("[OS:DEV] Device facet registry has already been initialized.");
     }
 
     registry.emplace();
@@ -39,7 +39,7 @@ namespace kapi::devices
   {
     if (!registry)
     {
-      system::panic("[kernel] Device facet registry has not been initialized.");
+      system::panic("[OS:DEV] Device facet registry has not been initialized.");
     }
 
     return *registry;
diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index a0445645..1c6fa2c8 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -27,17 +27,17 @@ namespace kapi::memory
 
       auto allocate_many(std::size_t) noexcept -> std::optional<std::pair<frame, std::size_t>> override
       {
-        system::panic("Tried to allocate frames without an active allocator.");
+        system::panic("[OS:MEM] Tried to allocate frames without an active allocator.");
       }
 
       auto mark_used(frame) -> void override
       {
-        system::panic("Tried to mark frame as used without an active allocator.");
+        system::panic("[OS:MEM] Tried to mark frame as used without an active allocator.");
       }
 
       auto release_many(std::pair<frame, std::size_t>) -> void override
       {
-        system::panic("Tried to release frames without an active allocator.");
+        system::panic("[OS:MEM] Tried to release frames without an active allocator.");
       }
     };
 
@@ -47,12 +47,12 @@ namespace kapi::memory
 
       auto map(page, frame, flags) -> std::byte * override
       {
-        system::panic("Tried to map a page without an active mapper.");
+        system::panic("[OS:MEM] Tried to map a page without an active mapper.");
       }
 
       auto unmap(page) -> void override
       {
-        system::panic("Tried to unmap a page without an active mapper.");
+        system::panic("[OS:MEM] Tried to unmap a page without an active mapper.");
       }
 
       auto try_unmap(page) noexcept -> bool override
diff --git a/kernel/kernel/filesystems/ext2/directory_iterator.cpp b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
index 2d5a2fe4..b1bb8b4f 100644
--- a/kernel/kernel/filesystems/ext2/directory_iterator.cpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
@@ -26,7 +26,7 @@ namespace kernel::filesystems::ext2
   {
     if (!inode.is_directory())
     {
-      kapi::system::panic("[FS:ext2] Tried perform directory iteration on non-directory inode {}", inode.number());
+      kapi::system::panic("[FS:EXT2] Tried perform directory iteration on non-directory inode {}", inode.number());
     }
 
     if (m_file_offset >= data_size(*m_inode, *m_state))
@@ -84,7 +84,7 @@ namespace kernel::filesystems::ext2
   {
     if (auto result = do_read(*m_inode, m_buffer, m_file_offset, *m_state); !result)
     {
-      kapi::system::panic("[FS:ext2] failed to read directory entry", result.error());
+      kapi::system::panic("[FS:EXT2] failed to read directory entry", result.error());
     }
 
     auto entry = reinterpret_cast<pointer>(m_buffer.data());
@@ -97,7 +97,7 @@ namespace kernel::filesystems::ext2
 
       if (auto result = do_read(*m_inode, m_buffer, m_file_offset, *m_state); !result)
       {
-        kapi::system::panic("[FS:ext2] failed to read directory entry", result.error());
+        kapi::system::panic("[FS:EXT2] failed to read directory entry", result.error());
       }
 
       entry = reinterpret_cast<pointer>(m_buffer.data());
diff --git a/kernel/kernel/filesystems/ext2/filesystem.cpp b/kernel/kernel/filesystems/ext2/filesystem.cpp
index 1785c0d7..eefd658c 100644
--- a/kernel/kernel/filesystems/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.cpp
@@ -166,7 +166,7 @@ namespace kernel::filesystems::ext2
           case kapi::filesystem::file_type::socket:
             return constants::mode_socket;
           default:
-            kapi::system::panic("[EXT2] Not implemented.");
+            kapi::system::panic("[FS:EXT2] Not implemented.");
         }
       }();
     }
diff --git a/kernel/kernel/filesystems/ext2/inode.cpp b/kernel/kernel/filesystems/ext2/inode.cpp
index 4abf8599..5bdd7871 100644
--- a/kernel/kernel/filesystems/ext2/inode.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.cpp
@@ -93,7 +93,7 @@ namespace kernel::filesystems::ext2
   {
     if (!is_regular())
     {
-      kapi::system::panic("[EXT2] ext2::inode write called on inode that is not of type regular");
+      kapi::system::panic("[FS:EXT2] ext2::inode write called on inode that is not of type regular");
     }
 
     // TODO check maximum file size of filesystem
diff --git a/kernel/kernel/filesystems/ext2/write_batch.cpp b/kernel/kernel/filesystems/ext2/write_batch.cpp
index 0bec30f4..76865a47 100644
--- a/kernel/kernel/filesystems/ext2/write_batch.cpp
+++ b/kernel/kernel/filesystems/ext2/write_batch.cpp
@@ -25,7 +25,7 @@ namespace kernel::filesystems::ext2
 
       if (!result)
       {
-        kapi::system::panic("[FS:ext2] failed to write block groups descriptor", result.error());
+        kapi::system::panic("[FS:EXT2] failed to write block groups descriptor", result.error());
       }
     });
 
@@ -34,7 +34,7 @@ namespace kernel::filesystems::ext2
       auto result = ext2::write_superblock(m_state);
       if (!result)
       {
-        kapi::system::panic("[FS:ext2] failed to write superblock", result.error());
+        kapi::system::panic("[FS:EXT2] failed to write superblock", result.error());
       }
     }
 
@@ -42,7 +42,7 @@ namespace kernel::filesystems::ext2
       auto result = ext2::write_inode(inode->number(), inode->data(), m_state);
       if (!result)
       {
-        kapi::system::panic("[FS:ext2] failed to write inode", result.error());
+        kapi::system::panic("[FS:EXT2] failed to write inode", result.error());
       }
     });
   }
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index f59b4ad7..ac2e18b8 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -32,7 +32,7 @@ auto run_demo() -> void
   auto fd_1 = kapi::filesystem::open("/entrance/tickets.txt");
   if (!fd_1)
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[demo failed]");
   }
   else
   {
diff --git a/kernel/kernel/memory/block_list_allocator.cpp b/kernel/kernel/memory/block_list_allocator.cpp
index 993dd470..b5afd1d8 100644
--- a/kernel/kernel/memory/block_list_allocator.cpp
+++ b/kernel/kernel/memory/block_list_allocator.cpp
@@ -130,7 +130,7 @@ namespace kernel::memory
       auto frame = kapi::memory::allocate_frame();
       if (!frame)
       {
-        kapi::system::panic("[OS:Heap] OOM when expanding heap.");
+        kapi::system::panic("[OS:MEM] OOM when expanding heap.");
         return false;
       }
 
diff --git a/kernel/kernel/memory/operators.cpp b/kernel/kernel/memory/operators.cpp
index 45ba5152..8c60bb63 100644
--- a/kernel/kernel/memory/operators.cpp
+++ b/kernel/kernel/memory/operators.cpp
@@ -20,7 +20,7 @@
 
   if (pointer == nullptr)
   {
-    kapi::system::panic("[OS:Heap] Out of memory!");
+    kapi::system::panic("[OS:MEM] Out of memory!");
   }
 
   return pointer;
diff --git a/kernel/kernel/vfs.cpp b/kernel/kernel/vfs.cpp
index 42e98219..cbabda82 100644
--- a/kernel/kernel/vfs.cpp
+++ b/kernel/kernel/vfs.cpp
@@ -44,7 +44,7 @@ namespace kernel::vfs
   {
     if (active_vfs)
     {
-      kapi::system::panic("[FILESYSTEM] vfs has already been initialized.");
+      kapi::system::panic("[OS:VFS] vfs has already been initialized.");
     }
 
     active_vfs.emplace();
@@ -56,13 +56,13 @@ namespace kernel::vfs
     auto rootfs = driver_registry::get().find("rootfs");
     if (!rootfs)
     {
-      kapi::system::panic("[OS:FS] rootfs driver is missing!");
+      kapi::system::panic("[OS:VFS] rootfs driver is missing!");
     }
 
     auto root_mount_result = (*rootfs)->mount(nullptr);
     if (!root_mount_result)
     {
-      kapi::system::panic("[FILESYSTEM] failed to mount root FS", root_mount_result.error());
+      kapi::system::panic("[OS:VFS] failed to mount root FS", root_mount_result.error());
     }
 
     auto [root_inode, root_state] = *root_mount_result;
@@ -74,13 +74,13 @@ namespace kernel::vfs
     auto devfs = driver_registry::get().find("devfs");
     if (!devfs)
     {
-      kapi::system::panic("[OS:FS] devfs driver is missing!");
+      kapi::system::panic("[OS:VFS] devfs driver is missing!");
     }
 
     auto device_fs_mount_result = (*devfs)->mount(nullptr);
     if (!device_fs_mount_result)
     {
-      kapi::system::panic("[FILESYSTEM] failed to mount device FS", device_fs_mount_result.error());
+      kapi::system::panic("[OS:VFS] failed to mount device FS", device_fs_mount_result.error());
     }
 
     auto [device_fs_root, device_fs_data] = *device_fs_mount_result;
@@ -95,13 +95,13 @@ namespace kernel::vfs
 
     if (!root_devfs_mount)
     {
-      kapi::system::panic("[OS:FS] failed to mount initial devfs!", root_devfs_mount.error());
+      kapi::system::panic("[OS:VFS] failed to mount initial devfs!", root_devfs_mount.error());
     }
 
     auto resolved = resolve_path_internal("/dev/ram0");
     if (!resolved)
     {
-      kapi::system::panic("[OS:FS] Failed to resolve boot disk!", resolved.error());
+      kapi::system::panic("[OS:VFS] Failed to resolve boot disk!", resolved.error());
     }
 
     auto [boot_device_dentry, boot_device_mount_context] = *resolved;
@@ -109,14 +109,14 @@ namespace kernel::vfs
     auto driver = driver_registry::get().match(boot_device_dentry->inode());
     if (!driver)
     {
-      kstd::println(kstd::print_sink::stderr, "[OS:FS] Missing driver for root disk!");
+      kstd::println(kstd::print_sink::stderr, "[OS:VFS] Missing driver for root disk!");
       return;
     }
 
     auto mount = mount::create(nullptr, *driver, nullptr, boot_device_mount_context, boot_device_dentry->inode());
     if (!mount)
     {
-      kapi::system::panic("[OS:FS] failed to mount boot FS", mount.error());
+      kapi::system::panic("[OS:VFS] failed to mount boot FS", mount.error());
     }
     m_mount_table.add_mount(*mount);
 
@@ -125,7 +125,7 @@ namespace kernel::vfs
     {
       if (auto result = mkdir("/dev"); !result)
       {
-        kapi::system::panic("[OS:FS] Failed to create devfs mount point!", result.error());
+        kapi::system::panic("[OS:VFS] Failed to create devfs mount point!", result.error());
       }
       real_dev_dentry = resolve_path("/dev");
     }
@@ -133,7 +133,7 @@ namespace kernel::vfs
     m_mount_table.move_mount(*root_devfs_mount, *real_dev_dentry, *mount);
     if (auto result = m_mount_table.remove_mount(root_mount); !result)
     {
-      kapi::system::panic("[OS:FS] Failed to unmount early rootfs!", result.error());
+      kapi::system::panic("[OS:VFS] Failed to unmount early rootfs!", result.error());
     }
   }
 
@@ -141,7 +141,7 @@ namespace kernel::vfs
   {
     if (!active_vfs)
     {
-      kapi::system::panic("[FILESYSTEM] vfs has not been initialized.");
+      kapi::system::panic("[OS:VFS] vfs has not been initialized.");
     }
 
     return *active_vfs;
@@ -343,7 +343,7 @@ namespace kernel::vfs
     auto current_mount = m_mount_table.find_mount("/");
     if (!current_mount)
     {
-      kapi::system::panic("[FILESYSTEM] no root mount found.");
+      kapi::system::panic("[OS:VFS] no root mount found.");
     }
 
     auto current_dentry = current_mount->root_dentry();
@@ -410,7 +410,7 @@ namespace kernel::vfs
         current_mount = m_mount_table.find_mount(next_dentry->absolute_path());
         if (!current_mount)
         {
-          kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
+          kapi::system::panic("[OS:VFS] mount for dentry with mounted flag not found.");
         }
 
         next_dentry = current_mount->root_dentry();
diff --git a/kernel/kernel/vfs/dentry.cpp b/kernel/kernel/vfs/dentry.cpp
index d9cb835a..092cab7c 100644
--- a/kernel/kernel/vfs/dentry.cpp
+++ b/kernel/kernel/vfs/dentry.cpp
@@ -22,11 +22,11 @@ namespace kernel::vfs
   {
     if (!m_inode)
     {
-      kapi::system::panic("[FILESYSTEM] dentry constructed with null inode.");
+      kapi::system::panic("[OS:VFS] dentry constructed with null inode.");
     }
     if (m_name.empty())
     {
-      kapi::system::panic("[FILESYSTEM] dentry constructed with empty name.");
+      kapi::system::panic("[OS:VFS] dentry constructed with empty name.");
     }
   }
 
diff --git a/kernel/kernel/vfs/device_inode.cpp b/kernel/kernel/vfs/device_inode.cpp
index ebb39541..e9c70f15 100644
--- a/kernel/kernel/vfs/device_inode.cpp
+++ b/kernel/kernel/vfs/device_inode.cpp
@@ -25,7 +25,7 @@ namespace kernel::vfs
   {
     if (!device)
     {
-      kapi::system::panic("[FILESYSTEM] device_inode constructed with null device.");
+      kapi::system::panic("[OS:VFS] device_inode constructed with null device.");
     }
   }
 
@@ -36,7 +36,7 @@ namespace kernel::vfs
   {
     if (!device)
     {
-      kapi::system::panic("[FILESYSTEM] device_inode constructed with null device.");
+      kapi::system::panic("[OS:VFS] device_inode constructed with null device.");
     }
   }
 
diff --git a/kernel/kernel/vfs/driver_registry.cpp b/kernel/kernel/vfs/driver_registry.cpp
index 16d048bf..736cfcbc 100644
--- a/kernel/kernel/vfs/driver_registry.cpp
+++ b/kernel/kernel/vfs/driver_registry.cpp
@@ -42,7 +42,7 @@ namespace kernel::vfs
   {
     if (instance)
     {
-      kapi::system::panic("[OS:FS] The filesystem driver registry was already initialized!");
+      kapi::system::panic("[OS:VFS] The filesystem driver registry was already initialized!");
     }
 
     instance.emplace();
@@ -55,7 +55,7 @@ namespace kernel::vfs
 
     std::ranges::for_each(instances, [](auto entry) {
       auto [descriptor, driver] = entry;
-      kstd::println("[OS:FS] Registering filesystem driver '{}'", descriptor->name());
+      kstd::println("[OS:VFS] Registering filesystem driver '{}'", descriptor->name());
       instance->add(descriptor->name(), driver);
     });
   }
@@ -64,7 +64,7 @@ namespace kernel::vfs
   {
     if (!instance)
     {
-      kapi::system::panic("[OS:FS] The filesystem driver registry has not been initialized!");
+      kapi::system::panic("[OS:VFS] The filesystem driver registry has not been initialized!");
     }
 
     return *instance;
@@ -84,7 +84,7 @@ namespace kernel::vfs
     auto result = m_drivers.emplace(name, driver);
     if (!result.second)
     {
-      kstd::println(kstd::print_sink::stderr, "[OS:FS] Tried to register duplicate filesystem driver '{}'!", name);
+      kstd::println(kstd::print_sink::stderr, "[OS:VFS] Tried to register duplicate filesystem driver '{}'!", name);
     }
 
     return result.second;
diff --git a/kernel/kernel/vfs/mount.cpp b/kernel/kernel/vfs/mount.cpp
index 3f99f733..a48558f1 100644
--- a/kernel/kernel/vfs/mount.cpp
+++ b/kernel/kernel/vfs/mount.cpp
@@ -28,7 +28,7 @@ namespace kernel::vfs
   {
     if (!m_filesystem)
     {
-      kapi::system::panic("[FILESYSTEM] mount initialized with null filesystem.");
+      kapi::system::panic("[OS:VFS] mount initialized with null filesystem.");
     }
   }
 
@@ -59,7 +59,7 @@ namespace kernel::vfs
   {
     if (!fs)
     {
-      kapi::system::panic("[OS:FS] Tried to mount a null filesystem!");
+      kapi::system::panic("[OS:VFS] Tried to mount a null filesystem!");
     }
 
     auto mount_result = fs->mount(backing_inode);
@@ -123,7 +123,7 @@ namespace kernel::vfs
   {
     if (m_ref_count == 0)
     {
-      kapi::system::panic("[FILESYSTEM] decrement_ref_count() was called but ref_count is 0");
+      kapi::system::panic("[OS:VFS] decrement_ref_count() was called but ref_count is 0");
     }
 
     m_ref_count -= 1;
diff --git a/kernel/kernel/vfs/open_file_descriptor.cpp b/kernel/kernel/vfs/open_file_descriptor.cpp
index 4f0581d2..985aab50 100644
--- a/kernel/kernel/vfs/open_file_descriptor.cpp
+++ b/kernel/kernel/vfs/open_file_descriptor.cpp
@@ -4,9 +4,9 @@
 #include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
+#include <kapi/system.hpp>
 
 #include <kstd/memory.hpp>
-#include <kstd/os/error.hpp>
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
 
@@ -20,7 +20,7 @@ namespace kernel::vfs
   {
     if (!dentry)
     {
-      kstd::os::panic("[FILESYSTEM] open_file_descriptor constructed with null dentry.");
+      kapi::system::panic("[OS:VFS] open_file_descriptor constructed with null dentry.");
     }
   }
 
diff --git a/kernel/kernel/vfs/open_file_table.cpp b/kernel/kernel/vfs/open_file_table.cpp
index 108f4e11..c2f0465a 100644
--- a/kernel/kernel/vfs/open_file_table.cpp
+++ b/kernel/kernel/vfs/open_file_table.cpp
@@ -24,7 +24,7 @@ namespace kernel::vfs
   {
     if (global_open_file_table)
     {
-      kapi::system::panic("[FILESYSTEM] Open file table has already been initialized.");
+      kapi::system::panic("[OS:VFS] Open file table has already been initialized.");
     }
 
     global_open_file_table.emplace(open_file_table{});
@@ -34,7 +34,7 @@ namespace kernel::vfs
   {
     if (!global_open_file_table)
     {
-      kapi::system::panic("[FILESYSTEM] Open file table has not been initialized.");
+      kapi::system::panic("[OS:VFS] Open file table has not been initialized.");
     }
 
     return *global_open_file_table;
diff --git a/libs/acpi/acpi/data/madt.hpp b/libs/acpi/acpi/data/madt.hpp
index 2bff7470..4a929a42 100644
--- a/libs/acpi/acpi/data/madt.hpp
+++ b/libs/acpi/acpi/data/madt.hpp
@@ -61,7 +61,7 @@ namespace acpi
     {
       if (type() != EntryType::this_type)
       {
-        kstd::os::panic("Invalid cast");
+        kstd::os::panic("[ACPI:DATA] Invalid cast");
       }
       return reinterpret_cast<EntryType const &>(*this);
     }
diff --git a/libs/kstd/kstd/bits/basic_string.hpp b/libs/kstd/kstd/bits/basic_string.hpp
index a718bccc..1f8b60af 100644
--- a/libs/kstd/kstd/bits/basic_string.hpp
+++ b/libs/kstd/kstd/bits/basic_string.hpp
@@ -137,7 +137,7 @@ namespace kstd
     {
       if (!source && count)
       {
-        os::panic("Tried to construct string from null pointer!");
+        os::panic("[KSTD:STR] Tried to construct string from null pointer!");
       }
 
       if (count > capacity())
@@ -333,7 +333,7 @@ namespace kstd
     {
       if (string == nullptr)
       {
-        os::panic("Tried to construct string from null pointer!");
+        os::panic("[KSTD:STR] Tried to construct string from null pointer!");
       }
 
       auto incoming_length = traits_type::length(string);
@@ -454,7 +454,7 @@ namespace kstd
     {
       if (position >= size())
       {
-        os::panic("Invalid index in string element access");
+        os::panic("[KSTD:STR] Invalid index in string element access");
       }
 
       return m_data[position];
@@ -468,7 +468,7 @@ namespace kstd
     {
       if (position >= size())
       {
-        os::panic("Invalid index in string element access");
+        os::panic("[KSTD:STR] Invalid index in string element access");
       }
 
       return m_data[position];
@@ -673,7 +673,7 @@ namespace kstd
     {
       if (new_capacity > max_size())
       {
-        os::panic("Tried to allocate more memory than possible");
+        os::panic("[KSTD:STR] Tried to allocate more memory than possible");
       }
 
       if (new_capacity <= capacity())
@@ -733,7 +733,7 @@ namespace kstd
     {
       if (index > size())
       {
-        os::panic("Index out of bounds while inserting into string");
+        os::panic("[KSTD:STR] Index out of bounds while inserting into string");
       }
 
       if (count == 0uz)
@@ -770,7 +770,7 @@ namespace kstd
     {
       if (string == nullptr)
       {
-        os::panic("Tried to insert nullptr string");
+        os::panic("[KSTD:STR] Tried to insert nullptr string");
       }
 
       return do_insert(index, std::basic_string_view<value_type, traits_type>{string});
@@ -788,7 +788,7 @@ namespace kstd
     {
       if (range == nullptr)
       {
-        os::panic("Tried to insert nullptr range");
+        os::panic("[KSTD:STR] Tried to insert nullptr range");
       }
 
       return do_insert(index, std::basic_string_view<value_type, traits_type>{range, length});
@@ -880,7 +880,7 @@ namespace kstd
     {
       if (string == nullptr)
       {
-        os::panic("Attempted to append nullptr string");
+        os::panic("[KSTD:STR] Attempted to append nullptr string");
       }
 
       if (count == 0)
@@ -1312,7 +1312,7 @@ namespace kstd
     {
       if (rhs == nullptr)
       {
-        os::panic("Tried to compare a string with nullptr");
+        os::panic("[KSTD:STR] Tried to compare a string with nullptr");
       }
 
       return lhs == std::basic_string_view<value_type, traits_type>{rhs};
@@ -1322,7 +1322,7 @@ namespace kstd
     {
       if (rhs == nullptr)
       {
-        os::panic("Tried to compare a string with nullptr");
+        os::panic("[KSTD:STR] Tried to compare a string with nullptr");
       }
 
       return std::basic_string_view<value_type, traits_type>{lhs} == rhs;
@@ -1349,7 +1349,7 @@ namespace kstd
     {
       if (rhs == nullptr)
       {
-        os::panic("Tried to compare a string with nullptr");
+        os::panic("[KSTD:STR] Tried to compare a string with nullptr");
       }
 
       return lhs <=> std::basic_string_view<value_type, traits_type>{rhs};
@@ -1359,7 +1359,7 @@ namespace kstd
     {
       if (rhs == nullptr)
       {
-        os::panic("Tried to compare a string with nullptr");
+        os::panic("[KSTD:STR] Tried to compare a string with nullptr");
       }
 
       return std::basic_string_view<value_type, traits_type>{lhs} <=> rhs;
@@ -1381,7 +1381,7 @@ namespace kstd
     {
       if (count > max_size())
       {
-        os::panic("Tried to allocate more memory than possible");
+        os::panic("[KSTD:STR] Tried to allocate more memory than possible");
       }
 
       auto to_allocate = (exact ? count : std::min(std::max(count, 2 * capacity()), max_size())) + 1;
@@ -1397,7 +1397,7 @@ namespace kstd
     {
       if (index > size())
       {
-        os::panic("Index out of bounds while inserting into string");
+        os::panic("[KSTD:STR] Index out of bounds while inserting into string");
       }
 
       if (view.size() == 0uz)
diff --git a/libs/kstd/kstd/bits/format/context.hpp b/libs/kstd/kstd/bits/format/context.hpp
index d5f2f4d9..69766592 100644
--- a/libs/kstd/kstd/bits/format/context.hpp
+++ b/libs/kstd/kstd/bits/format/context.hpp
@@ -41,7 +41,7 @@ namespace kstd
     {
       if (id >= args.size())
       {
-        kstd::os::panic("[kstd:format] argument index out of range!");
+        kstd::os::panic("[KSTD:FMT] argument index out of range!");
       }
       return args[id];
     }
diff --git a/libs/kstd/kstd/bits/format/error.hpp b/libs/kstd/kstd/bits/format/error.hpp
index c0cb53d7..30cb7523 100644
--- a/libs/kstd/kstd/bits/format/error.hpp
+++ b/libs/kstd/kstd/bits/format/error.hpp
@@ -15,7 +15,7 @@ namespace kstd::bits::format
     }
     else
     {
-      kstd::os::panic("Error while formatting a string.");
+      kstd::os::panic("[KSTD:FMT] Error while formatting a string.");
     }
   }
 
diff --git a/libs/kstd/kstd/bits/format/formatter/ordering.hpp b/libs/kstd/kstd/bits/format/formatter/ordering.hpp
index 78322262..73d2cac6 100644
--- a/libs/kstd/kstd/bits/format/formatter/ordering.hpp
+++ b/libs/kstd/kstd/bits/format/formatter/ordering.hpp
@@ -40,7 +40,7 @@ namespace kstd
       {
         return context.push(specifiers.alternative_form ? "<" : "less");
       }
-      kstd::os::panic("[kstd:format] Invalid strong ordering value!");
+      kstd::os::panic("[KSTD:FMT] Invalid strong ordering value!");
     }
   };
 
@@ -69,7 +69,7 @@ namespace kstd
       {
         return context.push(specifiers.alternative_form ? "<" : "less");
       }
-      kstd::os::panic("[kstd:format] Invalid weak ordering value!");
+      kstd::os::panic("[KSTD:FMT] Invalid weak ordering value!");
     }
   };
 
@@ -102,7 +102,7 @@ namespace kstd
       {
         return context.push(specifiers.alternative_form ? "<=>" : "unordered");
       }
-      kstd::os::panic("[kstd:format] Invalid partial ordering value!");
+      kstd::os::panic("[KSTD:FMT] Invalid partial ordering value!");
     }
   };
 
diff --git a/libs/kstd/kstd/bits/mutex/mutex.cpp b/libs/kstd/kstd/bits/mutex/mutex.cpp
index f1f43141..6dabb5dd 100644
--- a/libs/kstd/kstd/bits/mutex/mutex.cpp
+++ b/libs/kstd/kstd/bits/mutex/mutex.cpp
@@ -13,7 +13,7 @@ namespace kstd
   {
     if (m_locked.test(std::memory_order_relaxed))
     {
-      os::panic("[KSTD] Tried to destroy a locked mutex.");
+      os::panic("[KSTD:THR] Tried to destroy a locked mutex.");
     }
   }
 
diff --git a/libs/kstd/kstd/bits/observer_ptr.hpp b/libs/kstd/kstd/bits/observer_ptr.hpp
index e63e5d77..260d9d33 100644
--- a/libs/kstd/kstd/bits/observer_ptr.hpp
+++ b/libs/kstd/kstd/bits/observer_ptr.hpp
@@ -130,7 +130,7 @@ namespace kstd
     {
       if (m_ptr == nullptr)
       {
-        os::panic("[kstd:observer_ptr] Dereferencing a null observer pointer");
+        os::panic("[KSTD:MEM] Dereferencing a null observer pointer");
       }
     }
 
diff --git a/libs/kstd/kstd/flat_map.hpp b/libs/kstd/kstd/flat_map.hpp
index e140f7dd..c9a33b4a 100644
--- a/libs/kstd/kstd/flat_map.hpp
+++ b/libs/kstd/kstd/flat_map.hpp
@@ -112,7 +112,7 @@ namespace kstd
       {
         if (m_index >= m_containers->keys.size())
         {
-          os::panic("[kstd::flat_map] Iterator out of range");
+          os::panic("[KSTD:FLM] Iterator out of range");
         }
         return {m_containers->keys[m_index], m_containers->values[m_index]};
       }
@@ -199,7 +199,7 @@ namespace kstd
       {
         if (it.m_index >= it.m_containers->keys.size())
         {
-          os::panic("[kstd::flat_map] Iterator out of range");
+          os::panic("[KSTD:FLM] Iterator out of range");
         }
 
         return rvalue_reference{static_cast<rvalue_reference::first_type>(it.m_containers->keys[it.m_index]),
@@ -470,7 +470,7 @@ namespace kstd
       {
         return found->second;
       }
-      os::panic("[kstd::flat_map] Key not found");
+      os::panic("[KSTD:FLM] Key not found");
     }
 
     //! Get a reference to the mapped value associated with the given key.
@@ -487,7 +487,7 @@ namespace kstd
       {
         return found->second;
       }
-      os::panic("[kstd::flat_map] Key not found");
+      os::panic("[KSTD:FLM] Key not found");
     }
 
     //! Get a reference to the mapped value associated with the given key, or insert a default one if none exists.
diff --git a/libs/kstd/kstd/libc/stdlib.cpp b/libs/kstd/kstd/libc/stdlib.cpp
index 7ed051fa..098bcd25 100644
--- a/libs/kstd/kstd/libc/stdlib.cpp
+++ b/libs/kstd/kstd/libc/stdlib.cpp
@@ -12,7 +12,7 @@ namespace kstd::libc
 
     [[noreturn, gnu::weak]] auto free(void *) -> void
     {
-      kstd::os::panic("Tried to call free.");
+      kstd::os::panic("[KSTD:MEM] Tried to call free.");
     }
   }
 
diff --git a/libs/kstd/kstd/vector.hpp b/libs/kstd/kstd/vector.hpp
index 71c380fc..5a56381b 100644
--- a/libs/kstd/kstd/vector.hpp
+++ b/libs/kstd/kstd/vector.hpp
@@ -551,7 +551,7 @@ namespace kstd
 
       if (new_capacity > max_size())
       {
-        kstd::os::panic("[kstd:vector] Tried to reserve more space than theoretically possible.");
+        kstd::os::panic("[KSTD:VEC] Tried to reserve more space than theoretically possible.");
       }
 
       reallocate_exactly(new_capacity);
@@ -580,7 +580,7 @@ namespace kstd
 
       if (new_size > max_size())
       {
-        kstd::os::panic("[kstd:vector] Tried to resize more space than theoretically possible.");
+        kstd::os::panic("[KSTD:VEC] Tried to resize more space than theoretically possible.");
       }
 
       if (new_size > capacity())
@@ -744,7 +744,7 @@ namespace kstd
     {
       if (position == end())
       {
-        os::panic("[kstd:vector] Attempted to erase end()!");
+        os::panic("[KSTD:VEC] Attempted to erase end()!");
       }
 
       auto prefix_size = std::ranges::distance(cbegin(), position);
@@ -959,7 +959,7 @@ namespace kstd
     {
       if (index >= m_size)
       {
-        os::panic("[kstd:vector] Attempted to read element at invalid index");
+        os::panic("[KSTD:VEC] Attempted to read element at invalid index");
       }
     }