Einzelinstanz erzwingen: die zuletzt gestartete gewinnt

Zwei Onyx-Instanzen sind kein Schönheitsfehler. Jede bringt eine eigene
Zustandsmaschine, eigene Timer und eine eigene Animation auf dieselbe Notch —
das Ergebnis sieht aus wie ein Ruckler und ist keiner. Genau das ist beim
Testen passiert, mit zwei Builds aus verschiedenen Ordnern.

Die zuletzt gestartete Instanz gewinnt, nicht die erste. Beim Entwickeln ist
das die frisch gebaute; die andere Reihenfolge hieße, nach jedem Build weiter
die alte Fassung zu testen, ohne es zu merken. Im normalen Gebrauch ist der
Unterschied unsichtbar, weil Onyx kein Fenster hat, das man stattdessen in den
Vordergrund holen könnte.

Erkannt wird über die Bundle-Kennung, nicht über den Pfad: die Instanzen, die
sich real in die Quere kommen, stammen aus verschiedenen Build-Ordnern und
teilen sich nur die Kennung.

Erst terminate(), nach 1,5 s forceTerminate(). Überlebt eine trotzdem — der
reale Fall ist eine aus Xcode gestartete Instanz, die im Debugger hängt und
selbst SIGKILL übersteht — tritt die neue Instanz zurück und sagt per Dialog,
warum und was zu tun ist. Ein stiller Rücktritt sähe aus wie ein Startfehler.

Die Entscheidungsregel liegt als reine Funktion in OnyxCore und ist getestet,
inklusive des Falls, dass die eigene PID mehrfach in der Liste steht —
sich selbst zu beenden wäre der denkbar schlechteste Ausgang.

In der Praxis geprüft: `open -n` erzwingt einen Zweitstart, danach läuft genau
eine Instanz. 80 Tests grün.

Packages/OnyxKit/Sources/OnyxCore/SingleInstanceGuard.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+/// Sorgt dafür, dass immer nur eine Onyx-Instanz läuft.
+///
+/// Zwei Instanzen sind kein Schönheitsfehler: jede bringt eine eigene
+/// Zustandsmaschine, eigene Timer und eine eigene Animation auf dieselbe Notch
+/// mit. Das Ergebnis sieht aus wie ein Ruckler und ist keiner — es sind zwei
+/// Panels, die gegeneinander arbeiten.
+///
+/// **Die zuletzt gestartete Instanz gewinnt.** Beim Entwickeln ist das die
+/// frisch gebaute. Die andere Reihenfolge — erste gewinnt — würde bedeuten,
+/// dass man nach jedem Build weiter die alte Fassung testet, ohne es zu merken.
+/// Für den normalen Gebrauch ist der Unterschied unsichtbar: Onyx hat kein
+/// Fenster, das man in den Vordergrund holen könnte.
+public enum SingleInstanceGuard {
+
+    public enum Decision: Equatable, Sendable {
+        /// Kein Konkurrent — weiterlaufen.
+        case proceed
+        /// Diese Instanzen zum Beenden auffordern, danach erneut prüfen.
+        case terminateOthers([pid_t])
+        /// Ließen sich nicht beenden — diese Instanz tritt zurück.
+        case standDown([pid_t])
+    }
+
+    /// Alle fremden Instanzen. Die eigene fällt zuverlässig heraus, auch wenn
+    /// sie mehrfach in der Liste steht — sich selbst zu beenden wäre der
+    /// denkbar schlechteste Ausgang.
+    public static func others(from allPIDs: [pid_t], selfPID: pid_t) -> [pid_t] {
+        allPIDs.filter { $0 != selfPID }
+    }
+
+    public static func decide(otherPIDs: [pid_t]) -> Decision {
+        otherPIDs.isEmpty ? .proceed : .terminateOthers(otherPIDs)
+    }
+
+    public static func decideAfterTermination(remainingPIDs: [pid_t]) -> Decision {
+        remainingPIDs.isEmpty ? .proceed : .standDown(remainingPIDs)
+    }
+}