Phase 1: Notch-Shell, Design-System, Menüleisten-Infrastruktur

Zustandsmaschine und Geometrie sind testgetrieben entstanden und tragen 40
Tests — sie sind frei von AppKit, damit jeder Übergang ohne Fenster und ohne
Warten prüfbar ist. Zeit kommt nur als Ereignis herein.

Zwei Entscheidungen, die im Code begründet sind:

Der Zeiger wird über einen globalen Ereignismonitor verfolgt, nicht über ein
unsichtbares Fenster auf der Notch. Ein solches Fenster müsste Mausereignisse
annehmen, um sie zu bemerken, und würde damit Menüleiste und Fensterknöpfe
darunter unbenutzbar machen.

"Nur internes Display" fällt auf ein externes zurück, wenn kein eingebautes da
ist. Am Dock mit geschlossenem Deckel hieße die Einstellung wörtlich genommen,
dass Onyx unerreichbar wird.

Design: NSVisualEffectView mit eigenem Tint statt Liquid Glass — Onyx ist Stein,
kein Glas. Alle Farben und Maße liegen als Tokens in OnyxDesign.

Menüleiste: jedes Modul bekommt ein eigenes NSStatusItem. Elemente, denen macOS
mangels Platz keine Breite gibt, werden erkannt und gemeldet, statt still zu
verschwinden.

App-Target über XcodeGen, damit die Projektdefinition im Diff lesbar bleibt.
Nicht sandboxed, mit App-Group-Entitlement — baut, startet, signiert mit
PP34X97WS3.

Spikes/smc-dump.swift

@@ -315,6 +315,99 @@ for (key, note) in [("PSTR", "Systemleistung W"), ("PDTR", "DC-Eingang W"),
 
 // --- Vollständiger Dump ---------------------------------------------------
 
+// --- Wächter: Änderungen an den Ladekandidaten protokollieren -------------
+//
+// Findet den Ladelimit-Key durch Beobachtung, nicht durch Raten: es wird nur
+// gelesen, während macOS selbst die Ladegrenze umstellt.
+
+if CommandLine.arguments.contains("--watch") {
+    let interval = 2.0
+    let deadline = Date().addingTimeInterval(45 * 60)
+
+    // Alle Keys, die für die Ladesteuerung in Frage kommen, plus Kontext.
+    var watched: [String] = []
+    if let total = try? smc.keyCount() {
+        for i in 0..<total {
+            guard let name = try? smc.key(atIndex: i) else { continue }
+            if name.hasPrefix("CH") || name.hasPrefix("bf") || name.hasPrefix("AC")
+                || name.hasPrefix("B0") || name.hasPrefix("BC") || name.hasPrefix("BR") {
+                watched.append(name)
+            }
+        }
+    }
+
+    func snapshotNow() -> [String: String] {
+        var out: [String: String] = [:]
+        for key in watched {
+            if let v = try? smc.read(key: key) { out[key] = v.hex }
+        }
+        return out
+    }
+
+    let stamp = { () -> String in
+        let f = DateFormatter(); f.dateFormat = "HH:mm:ss"; return f.string(from: Date())
+    }
+
+    // --- Selbstkalibrierung ------------------------------------------------
+    //
+    // Eine feste Ausschlussliste ist zwecklos: Spannungen, Ströme, Temperaturen
+    // und Zähler ändern sich im Sekundentakt und begraben das eine Ereignis,
+    // auf das es ankommt. Stattdessen erst zusehen, was von allein zappelt.
+
+    let calibrationSeconds = 60.0
+    print("KALIBRIERUNG — \(watched.count) Kandidaten, \(Int(calibrationSeconds)) s")
+    print("Bitte in dieser Zeit NICHTS umstellen. Nur lesend.")
+    print(String(repeating: "─", count: 72))
+
+    var baseline = snapshotNow()
+    var noisy = Set<String>()
+    let calibrationEnd = Date().addingTimeInterval(calibrationSeconds)
+
+    while Date() < calibrationEnd {
+        Thread.sleep(forTimeInterval: interval)
+        let current = snapshotNow()
+        for (key, value) in current where baseline[key] != value {
+            noisy.insert(key)
+            baseline[key] = value
+        }
+    }
+
+    let stable = watched.filter { !noisy.contains($0) }
+    print("[\(stamp())] \(noisy.count) Keys zappeln von allein und werden ignoriert.")
+    print("[\(stamp())] \(stable.count) Keys sind stabil und werden beobachtet:")
+    print("   \(stable.sorted().joined(separator: " "))")
+    print(String(repeating: "─", count: 72))
+    print("JETZT: Netzteil anstecken, dann die Ladegrenze umschalten.")
+    fflush(stdout)
+
+    watched = stable
+    var previous = snapshotNow()
+    var lastPower: String? = nil
+
+    while Date() < deadline {
+        Thread.sleep(forTimeInterval: interval)
+        let current = snapshotNow()
+
+        // Netzteilzustand getrennt mitschreiben, damit die Ereignisse
+        // zeitlich einzuordnen sind.
+        if let ac = try? smc.read(key: "AC-W"), ac.hex != lastPower {
+            print("[\(stamp())] ⚡︎ NETZTEIL: AC-W \(lastPower ?? "—") → \(ac.hex)")
+            lastPower = ac.hex
+            fflush(stdout)
+        }
+
+        for (key, value) in current where previous[key] != value {
+            let old = previous[key] ?? "—"
+            let v = try? smc.read(key: key)
+            print("[\(stamp())] ★ \(key) (\(v?.type ?? "?")): \(old) → \(value)   = \(v?.decoded ?? "—")")
+            fflush(stdout)
+        }
+        previous = current
+    }
+    print("[\(stamp())] Wächter beendet.")
+    exit(0)
+}
+
 if CommandLine.arguments.contains("--all") {
     section("ALLE KEYS")
     guard let total = try? smc.keyCount() else {