feat: add kernel ACPI support for querying battery percentage, add battery indicator to desktop, move log state to 0:/state directory

kernel/src/Api/BuildNo.hpp

@@ -12,4 +12,4 @@
 
 #pragma once
 
-#define MONTAUK_BUILD_NUMBER 185
+#define MONTAUK_BUILD_NUMBER 220

kernel/src/Api/Power.hpp

@@ -13,6 +13,7 @@
 #include <ACPI/AcpiShutdown.hpp>
 #include <ACPI/AcpiSleep.hpp>
 #include <ACPI/CpuIdle.hpp>
+#include <ACPI/Battery.hpp>
 #include <Hal/CpuPower.hpp>
 #include <Sched/Scheduler.hpp>
 #include <Terminal/Terminal.hpp>
@@ -114,4 +115,30 @@ namespace montauk::abi {
         out->apIdleHint  = Hal::CpuIdle::GetApIdleHint();
         return 0;
     }
+
+    // SYS_BATTERYINFO. Fills a battery snapshot. Returns -1 on a machine with
+    // no ACPI battery device, which is how a desktop-class caller learns not to
+    // draw an indicator at all.
+    static int64_t Sys_BatteryInfo(BatteryInfo* out) {
+        Hal::Battery::Status s{};
+        if (!Hal::Battery::GetStatus(s)) {
+            return -1;
+        }
+
+        out->present            = s.Present ? 1 : 0;
+        out->charging           = s.Charging ? 1 : 0;
+        out->discharging        = s.Discharging ? 1 : 0;
+        out->critical           = s.Critical ? 1 : 0;
+        out->acOnline           = s.AcOnline ? 1 : 0;
+        out->hasAcAdapter       = s.HasAcAdapter ? 1 : 0;
+        out->percent            = s.Percent;
+        out->powerUnitMilliAmps = s.PowerUnitMilliAmps ? 1 : 0;
+        out->remainingCapacity  = s.RemainingCapacity;
+        out->fullCapacity       = s.FullCapacity;
+        out->designCapacity     = s.DesignCapacity;
+        out->presentRate        = s.PresentRate;
+        out->voltageMv          = s.VoltageMv;
+        out->minutesRemaining   = s.MinutesRemaining;
+        return 0;
+    }
 };

kernel/src/Api/Syscall.cpp

@@ -504,6 +504,12 @@ namespace montauk::abi {
             case SYS_POWERINFO:
                 if (!UserMemory::Writable<PowerInfo>(frame->arg1)) return -1;
                 return Sys_PowerInfo((PowerInfo*)frame->arg1);
+            case SYS_BATTERYINFO:
+                // Read-only power telemetry, ungated like SYS_POWERINFO: the
+                // panel indicator has to work in an unprivileged session, which
+                // holds no device capability to spend on it.
+                if (!UserMemory::Writable<BatteryInfo>(frame->arg1)) return -1;
+                return Sys_BatteryInfo((BatteryInfo*)frame->arg1);
             case SYS_THREAD_SPAWN:
                 return Sys_ThreadSpawn(frame->arg1, frame->arg2, frame->arg3);
             case SYS_THREAD_EXIT:

kernel/src/Api/Syscall.hpp

@@ -343,6 +343,9 @@ namespace montauk::abi {
        touch in full (image decode, heap slabs). */
     static constexpr uint64_t SYS_ALLOC_EAGER          = 187;  // (bytes) -> va, 0 on failure
 
+    /* Battery.hpp -- ACPI battery status */
+    static constexpr uint64_t SYS_BATTERYINFO          = 188;  // (BatteryInfo*) -> 0, -1 no battery device
+
     /* Kernel-owned process capabilities. User identities may namespace
        per-user resources, but never participate in authorization decisions. */
     static constexpr uint64_t CAP_PROCESS_ADMIN = 1ULL << 0;
@@ -881,6 +884,26 @@ namespace montauk::abi {
         uint32_t apIdleHint;     // MWAIT hint used for AP deep idle
     };
 
+    // Battery status (returned by SYS_BATTERYINFO). A machine with no battery
+    // device fails the call outright; `present` distinguishes a laptop with the
+    // pack removed from one that is running on it.
+    struct BatteryInfo {
+        uint8_t  present;            // a battery is installed
+        uint8_t  charging;
+        uint8_t  discharging;
+        uint8_t  critical;
+        uint8_t  acOnline;           // AC adapter connected
+        uint8_t  hasAcAdapter;       // an AC adapter device exists at all
+        uint8_t  percent;            // 0..100, 0 when capacity is unknown
+        uint8_t  powerUnitMilliAmps; // capacities are mAh/mA, not mWh/mW
+        uint32_t remainingCapacity;
+        uint32_t fullCapacity;       // last full charge capacity
+        uint32_t designCapacity;
+        uint32_t presentRate;        // mW or mA, 0 when unknown
+        uint32_t voltageMv;
+        int32_t  minutesRemaining;   // -1 when not estimable (e.g. charging)
+    };
+
     // Crash report (filled by kernel on process fault, returned via SYS_CRASH_REPORT)
     struct CrashReportInfo {
         int pid;