fix(security, core): Auth-Pflicht für Ingest-APIs, 500er-Ursachen beheben, Agenten-Workflow

Sicherheit
- install_db.php war ohne Authentifizierung erreichbar und setzte bei jedem
  Aufruf das Admin-Passwort auf einen fest im Code stehenden Wert zurück.
  Jetzt Auth-Pflicht; ein Konto wird nur bei leerer Benutzertabelle angelegt.
- Stored XSS im Bugtracker-Detail-Modal: Titel, Beschreibung, Fehlermeldung,
  Stacktrace und Kommentare gingen ungefiltert durch innerHTML.
- report.php, projects.php und das Veröffentlichen von Releases verlangen jetzt
  zwingend ein Token. Publish war zuvor völlig ungeschützt.
- CSRF-Token in allen Formularen, Session-Regenerierung nach Login,
  Drosselung fehlgeschlagener Anmeldeversuche.
- Zugangsdaten aus der Versionskontrolle entfernt (Serverdaten.txt,
  config.php, .htpasswd, deploy_config.json). Historie enthält sie weiterhin,
  Rotation erforderlich (siehe docs/UPGRADE.md).
- Token-Validierung nur noch über SHA-256-Hash; expires_at wird ausgewertet.

Behobene 500er
- Audit::log() war in index.php weder eingebunden noch importiert. Jeder
  Klick auf "Aktivierung freigeben" endete in einem Fatal Error.
- Derselbe benannte PDO-Platzhalter mehrfach je Statement (:id in
  revokeToken/deleteToken, :q siebenfach in der Volltextsuche). Bei
  EMULATE_PREPARES=false ist das nicht zulässig und warf HY093.
- Migration 005 nutzte dynamisches SQL, dessen Semikolons in String-Literalen
  vom alten explode(';')-Installer als Statement-Ende gelesen wurden. Sie
  schlug still fehl, wodurch push_id/target_agent/tags dauerhaft fehlten.
- Monitor-Umbenennung ohne Transaktion, verschachtelte Transaktionen im
  RateLimiter.

Funktionale Korrekturen
- Der Watchdog-Evaluator fehlte vollständig: Monitor-Zustände änderten sich nur
  beim Eintreffen eines Heartbeats, ein ausgefallenes System blieb dauerhaft
  "up". Erster Lauf auf dem Produktivsystem: 7 von 10 Monitoren waren
  tatsächlich seit über einem Tag nicht erreichbar.
- Das Feld "os" fehlte im Monitor-Dialog, wurde aber gespeichert und löschte
  damit bei jedem Speichern das Betriebssystem.
- Der Resolve-Dialog existierte im HTML nicht; der Button war funktionslos.
- Versionsvergleich erfolgte lexikografisch, wodurch 1.9.0 als neuer galt
  als 1.10.0.
- Schreiboperationen meldeten Erfolg auch für nicht existierende IDs.
- Post/Redirect/Get gegen doppelte Einträge beim Neuladen.

Neue Struktur
- src/bootstrap.php mit PSR-4-Autoloader ersetzt die require-Ketten.
- Core: Config, Http, Csrf, ApiAuth, Logger, Migrator, ErrorReporter.
- Migrator mit zeichenweisem SQL-Parser, dc_migrations und Baseline-Verfahren,
  damit bestehende Installationen keine Beispieldaten zurückbekommen.

Agenten-Workflow
- Claim/Lease: Items werden exklusiv übernommen, damit nicht zwei Agenten am
  selben Problem arbeiten. action=next holt und reserviert in einem Zug.
- Idempotenz über client_ref, Deduplizierung auch für Feature Requests,
  Erkennung von Regressionen, automatische Eskalation des Schweregrads.
- Strukturierter Code-Kontext (repo_url, commit_sha, file_path, line_no).
- Delta-Abfragen über updated_since, Pagination, Bulk-Update.
- Beim Veröffentlichen eines Releases schließen sich Items mit passendem
  resolved_in_build selbst.
- Ausgehende Webhooks mit HMAC-Signatur, /api/health, /api/openapi.json.
- Unbehandelte Fehler meldet die Plattform in ihren eigenen Bugtracker.

WebUI
- Serverseitige Filterung mit Pagination statt Rendern aller Datensätze.
- Migrations-Schranke, Evaluator-Warnung, Übersicht aktiver Agenten.

Zeitstempel liegen in der Datenbank durchgängig in UTC und werden für die
Anzeige in die App-Zeitzone umgerechnet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/Modules/UpdateService/Version.php

@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Deploymentcenter\Modules\UpdateService;
+
+/**
+ * Semantischer Versionsvergleich.
+ *
+ * Der frueher genutzte SQL-Ausdruck "version > :ver" verglich lexikografisch.
+ * Damit galt '1.9.0' als neuer als '1.10.0' und Clients bekamen ein Downgrade
+ * als Update angeboten. Der .NET-Client verglich bereits korrekt - Server und
+ * Client waren sich also uneinig.
+ *
+ * Unterstuetzt: "1.2.3", "v1.2.3", "1.2.3-beta.1", "1.2.3+build.5", "1.2".
+ */
+final class Version
+{
+    /**
+     * @return int -1 wenn $a < $b, 0 bei Gleichstand, 1 wenn $a > $b
+     */
+    public static function compare(string $a, string $b): int
+    {
+        [$coreA, $preA] = self::parse($a);
+        [$coreB, $preB] = self::parse($b);
+
+        $length = max(count($coreA), count($coreB));
+        for ($i = 0; $i < $length; $i++) {
+            $partA = $coreA[$i] ?? 0;
+            $partB = $coreB[$i] ?? 0;
+            if ($partA !== $partB) {
+                return $partA <=> $partB;
+            }
+        }
+
+        // Eine Version ohne Vorabkennung ist hoeher als dieselbe mit
+        // (1.0.0 > 1.0.0-rc.1), so verlangt es die Semver-Spezifikation.
+        if ($preA === [] && $preB === []) {
+            return 0;
+        }
+        if ($preA === []) {
+            return 1;
+        }
+        if ($preB === []) {
+            return -1;
+        }
+
+        return self::comparePrerelease($preA, $preB);
+    }
+
+    public static function isNewer(string $candidate, string $current): bool
+    {
+        return self::compare($candidate, $current) > 0;
+    }
+
+    /**
+     * Waehlt die hoechste Version aus einer Liste von Release-Datensaetzen.
+     *
+     * @param list<array<string,mixed>> $releases
+     * @return array<string,mixed>|null
+     */
+    public static function highest(array $releases, string $versionKey = 'version'): ?array
+    {
+        $best = null;
+        foreach ($releases as $release) {
+            if (!isset($release[$versionKey]) || !is_string($release[$versionKey])) {
+                continue;
+            }
+            if ($best === null || self::compare($release[$versionKey], (string)$best[$versionKey]) > 0) {
+                $best = $release;
+            }
+        }
+        return $best;
+    }
+
+    /**
+     * Zerlegt eine Version in numerischen Kern und Vorabkennung.
+     *
+     * @return array{0:list<int>,1:list<string>}
+     */
+    private static function parse(string $version): array
+    {
+        $version = trim($version);
+        $version = ltrim($version, 'vV');
+
+        // Build-Metadaten sind fuer die Rangfolge irrelevant.
+        $plus = strpos($version, '+');
+        if ($plus !== false) {
+            $version = substr($version, 0, $plus);
+        }
+
+        $prerelease = [];
+        $dash = strpos($version, '-');
+        if ($dash !== false) {
+            $preString = substr($version, $dash + 1);
+            $version = substr($version, 0, $dash);
+            $prerelease = $preString === '' ? [] : explode('.', $preString);
+        }
+
+        $core = [];
+        foreach (explode('.', $version) as $part) {
+            $core[] = (int)preg_replace('/\D/', '', $part);
+        }
+
+        if ($core === []) {
+            $core = [0];
+        }
+
+        return [$core, $prerelease];
+    }
+
+    /**
+     * @param list<string> $a
+     * @param list<string> $b
+     */
+    private static function comparePrerelease(array $a, array $b): int
+    {
+        $length = max(count($a), count($b));
+
+        for ($i = 0; $i < $length; $i++) {
+            // Weniger Bestandteile = niedrigere Rangfolge (rc < rc.1)
+            if (!isset($a[$i])) {
+                return -1;
+            }
+            if (!isset($b[$i])) {
+                return 1;
+            }
+
+            $partA = $a[$i];
+            $partB = $b[$i];
+
+            $numericA = ctype_digit($partA);
+            $numericB = ctype_digit($partB);
+
+            if ($numericA && $numericB) {
+                $cmp = (int)$partA <=> (int)$partB;
+                if ($cmp !== 0) {
+                    return $cmp;
+                }
+                continue;
+            }
+
+            // Rein numerische Bestandteile rangieren unter alphanumerischen.
+            if ($numericA !== $numericB) {
+                return $numericA ? -1 : 1;
+            }
+
+            $cmp = strcmp($partA, $partB);
+            if ($cmp !== 0) {
+                return $cmp > 0 ? 1 : -1;
+            }
+        }
+
+        return 0;
+    }
+}