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.

Packages/OnyxKit/Sources/OnyxDesign/OnyxSurface.swift

@@ -0,0 +1,72 @@
+import SwiftUI
+import AppKit
+
+/// Die Vibrancy-Ebene hinter dem Panel.
+///
+/// `.hudWindow` mit `behindWindow` lässt den Hintergrund durchscheinen, ohne ihn
+/// lesbar zu lassen. Der Tint darüber macht daraus schwarzen Stein statt grauem Glas.
+public struct OnyxVisualEffect: NSViewRepresentable {
+    public init() {}
+
+    public func makeNSView(context: Context) -> NSVisualEffectView {
+        let view = NSVisualEffectView()
+        view.material = .hudWindow
+        view.blendingMode = .behindWindow
+        view.state = .active
+        view.appearance = NSAppearance(named: .darkAqua)
+        return view
+    }
+
+    public func updateNSView(_ view: NSVisualEffectView, context: Context) {}
+}
+
+/// Der Hintergrund des Panels: Vibrancy, Tint, ein sehr flacher Glanz von oben
+/// und eine Haarlinie als Innenkante.
+public struct OnyxSurface: View {
+    private let cornerRadius: CGFloat
+
+    public init(cornerRadius: CGFloat = Onyx.Metric.panelCornerRadius) {
+        self.cornerRadius = cornerRadius
+    }
+
+    public var body: some View {
+        let shape = RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
+
+        shape
+            .fill(Onyx.Color.surface.opacity(Onyx.Color.surfaceOpacity))
+            .background(OnyxVisualEffect().clipShape(shape))
+            .overlay {
+                // Die Bänderung des Steins: oben ein Hauch heller, nach 40 %
+                // vollständig verlaufen. Mehr wirkt sofort billig.
+                shape.fill(
+                    LinearGradient(
+                        stops: [
+                            .init(color: .white.opacity(0.02), location: 0),
+                            .init(color: .clear, location: 0.4),
+                        ],
+                        startPoint: .top, endPoint: .bottom))
+            }
+            .overlay {
+                shape.strokeBorder(Onyx.Color.hairline, lineWidth: Onyx.Metric.hairlineWidth)
+            }
+    }
+}
+
+/// Eine Kachel auf der Panelfläche.
+public struct OnyxTile<Content: View>: View {
+    private let content: Content
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    public var body: some View {
+        let shape = RoundedRectangle(cornerRadius: Onyx.Metric.tileCornerRadius, style: .continuous)
+
+        content
+            .padding(12)
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+            .background(shape.fill(Onyx.Color.elevated))
+            .overlay(shape.strokeBorder(Onyx.Color.hairline, lineWidth: Onyx.Metric.hairlineWidth))
+    }
+}

Packages/OnyxKit/Sources/OnyxDesign/OnyxTokens.swift

@@ -0,0 +1,67 @@
+import SwiftUI
+
+/// Die einzige Quelle für Farben, Maße und Bewegung in Onyx.
+///
+/// Onyx ist ein tiefschwarzer Stein mit feiner Bänderung und mattem Glanz — kein
+/// Glas. Das Panel benutzt deshalb bewusst **nicht** die Liquid-Glass-APIs von
+/// macOS 26, sondern eine dunkle Vibrancy-Ebene mit eigenem Tint darüber.
+public enum Onyx {
+
+    // MARK: - Farben
+
+    public enum Color {
+        /// Grundfläche des Panels.
+        public static let surface = SwiftUI.Color(red: 0.043, green: 0.043, blue: 0.051)
+        /// Kacheln auf der Grundfläche.
+        public static let elevated = SwiftUI.Color(red: 0.078, green: 0.078, blue: 0.090)
+        /// Innenkante — der halbe „edle" Effekt steckt in dieser einen Linie.
+        public static let hairline = SwiftUI.Color.white.opacity(0.08)
+
+        public static let textPrimary = SwiftUI.Color(red: 0.949, green: 0.949, blue: 0.957)
+        public static let textSecondary = SwiftUI.Color.white.opacity(0.58)
+        public static let textTertiary = SwiftUI.Color.white.opacity(0.34)
+
+        /// Kühl und entsättigt. Farbe ist in Onyx ein Signal, keine Dekoration.
+        public static let accent = SwiftUI.Color(red: 0.498, green: 0.659, blue: 1.0)
+        public static let positive = SwiftUI.Color(red: 0.435, green: 0.812, blue: 0.592)
+        public static let warning = SwiftUI.Color(red: 0.910, green: 0.706, blue: 0.290)
+        public static let critical = SwiftUI.Color(red: 0.898, green: 0.404, blue: 0.361)
+
+        /// Deckkraft des Tints über der Vibrancy-Ebene. Darunter liest man den
+        /// Hintergrund durch, darüber wirkt das Panel wie eine schwarze Platte.
+        public static let surfaceOpacity: Double = 0.74
+    }
+
+    // MARK: - Maße
+
+    public enum Metric {
+        public static let panelCornerRadius: CGFloat = 26
+        public static let tileCornerRadius: CGFloat = 16
+        public static let panelPadding: CGFloat = 16
+        public static let tileSpacing: CGFloat = 10
+        public static let hairlineWidth: CGFloat = 1
+    }
+
+    // MARK: - Bewegung
+
+    public enum Motion {
+        /// Ein einziger Spring für alles Ausfahren. Mehrere Kurven im selben
+        /// Panel wirken unruhig, egal wie gut jede für sich ist.
+        public static let expand = Animation.spring(response: 0.34, dampingFraction: 0.86)
+        /// Für Messwerte: sichtbar, aber ohne Pulsieren.
+        public static let value = Animation.easeOut(duration: 0.25)
+    }
+
+    // MARK: - Typografie
+
+    public enum Font {
+        public static let title = SwiftUI.Font.system(size: 13, weight: .semibold)
+        public static let body = SwiftUI.Font.system(size: 12, weight: .regular)
+        public static let caption = SwiftUI.Font.system(size: 10, weight: .medium)
+        /// Für alle Messwerte — ohne feste Ziffernbreite zappeln die Zahlen.
+        public static let metric = SwiftUI.Font.system(size: 20, weight: .medium)
+            .monospacedDigit()
+        public static let metricSmall = SwiftUI.Font.system(size: 11, weight: .medium)
+            .monospacedDigit()
+    }
+}