cuonztech-privacy-chaos-gate 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import * as playwright from 'playwright';
 
 /**
  * Chaos test scenarios as defined in PRD Section 2B
@@ -207,17 +206,19 @@ declare const EvidenceRecordSchema: z.ZodObject<{
         path: z.ZodString;
         at: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        at: string;
         path: string;
+        at: string;
         label: string;
     }, {
-        at: string;
         path: string;
+        at: string;
         label: string;
     }>, "many">>;
     screenshotPath: z.ZodOptional<z.ZodString>;
     targetUrl: z.ZodString;
     checkedAt: z.ZodString;
+    /** Nur nach `--ignore`: so viele Befunde dieses Szenarios wurden ausgenommen (bei Status «bestanden» alle). */
+    ignoredFindings: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     targetUrl: string;
     status: "passed" | "suspicious" | "not-checkable" | "not-applicable";
@@ -265,11 +266,12 @@ declare const EvidenceRecordSchema: z.ZodObject<{
     } | undefined;
     residualAfterRevoke?: string[] | undefined;
     screenshots?: {
-        at: string;
         path: string;
+        at: string;
         label: string;
     }[] | undefined;
     screenshotPath?: string | undefined;
+    ignoredFindings?: number | undefined;
 }, {
     targetUrl: string;
     status: "passed" | "suspicious" | "not-checkable" | "not-applicable";
@@ -317,11 +319,12 @@ declare const EvidenceRecordSchema: z.ZodObject<{
     } | undefined;
     residualAfterRevoke?: string[] | undefined;
     screenshots?: {
-        at: string;
         path: string;
+        at: string;
         label: string;
     }[] | undefined;
     screenshotPath?: string | undefined;
+    ignoredFindings?: number | undefined;
 }>;
 type EvidenceRecord = z.infer<typeof EvidenceRecordSchema>;
 /**
@@ -338,8 +341,13 @@ declare const TrackerViolationSchema: z.ZodObject<{
     trackerName: z.ZodString;
     trackerCategory: z.ZodEnum<["analytics", "marketing", "functional", "unknown"]>;
     requestUrl: z.ZodString;
-    /** Verletzte Regel — steuert Gate-Wortlaut und Empfehlungen */
+    /**
+     * Verletzte Regel — steuert Gate-Wortlaut und Empfehlungen
+     * (u. a. "pre-consent-tracking", "tracking-after-deny", "no-reject-option").
+     */
     ruleId: z.ZodOptional<z.ZodString>;
+    /** Hinweis ohne Gate-Wirkung (z. B. rein funktionale Drittanbieter wie Google Fonts) */
+    advisory: z.ZodOptional<z.ZodBoolean>;
     method: z.ZodDefault<z.ZodString>;
     timestamp: z.ZodString;
     domContext: z.ZodOptional<z.ZodObject<{
@@ -366,6 +374,7 @@ declare const TrackerViolationSchema: z.ZodObject<{
     timestamp: string;
     description: string;
     ruleId?: string | undefined;
+    advisory?: boolean | undefined;
     domContext?: {
         triggerElement?: string | undefined;
         consentBannerVisible?: boolean | undefined;
@@ -380,6 +389,7 @@ declare const TrackerViolationSchema: z.ZodObject<{
     timestamp: string;
     description: string;
     ruleId?: string | undefined;
+    advisory?: boolean | undefined;
     method?: string | undefined;
     domContext?: {
         triggerElement?: string | undefined;
@@ -402,8 +412,13 @@ declare const LeakReportSchema: z.ZodObject<{
         trackerName: z.ZodString;
         trackerCategory: z.ZodEnum<["analytics", "marketing", "functional", "unknown"]>;
         requestUrl: z.ZodString;
-        /** Verletzte Regel — steuert Gate-Wortlaut und Empfehlungen */
+        /**
+         * Verletzte Regel — steuert Gate-Wortlaut und Empfehlungen
+         * (u. a. "pre-consent-tracking", "tracking-after-deny", "no-reject-option").
+         */
         ruleId: z.ZodOptional<z.ZodString>;
+        /** Hinweis ohne Gate-Wirkung (z. B. rein funktionale Drittanbieter wie Google Fonts) */
+        advisory: z.ZodOptional<z.ZodBoolean>;
         method: z.ZodDefault<z.ZodString>;
         timestamp: z.ZodString;
         domContext: z.ZodOptional<z.ZodObject<{
@@ -430,6 +445,7 @@ declare const LeakReportSchema: z.ZodObject<{
         timestamp: string;
         description: string;
         ruleId?: string | undefined;
+        advisory?: boolean | undefined;
         domContext?: {
             triggerElement?: string | undefined;
             consentBannerVisible?: boolean | undefined;
@@ -444,6 +460,7 @@ declare const LeakReportSchema: z.ZodObject<{
         timestamp: string;
         description: string;
         ruleId?: string | undefined;
+        advisory?: boolean | undefined;
         method?: string | undefined;
         domContext?: {
             triggerElement?: string | undefined;
@@ -593,17 +610,19 @@ declare const LeakReportSchema: z.ZodObject<{
             path: z.ZodString;
             at: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }, {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }>, "many">>;
         screenshotPath: z.ZodOptional<z.ZodString>;
         targetUrl: z.ZodString;
         checkedAt: z.ZodString;
+        /** Nur nach `--ignore`: so viele Befunde dieses Szenarios wurden ausgenommen (bei Status «bestanden» alle). */
+        ignoredFindings: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         targetUrl: string;
         status: "passed" | "suspicious" | "not-checkable" | "not-applicable";
@@ -651,11 +670,12 @@ declare const LeakReportSchema: z.ZodObject<{
         } | undefined;
         residualAfterRevoke?: string[] | undefined;
         screenshots?: {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }[] | undefined;
         screenshotPath?: string | undefined;
+        ignoredFindings?: number | undefined;
     }, {
         targetUrl: string;
         status: "passed" | "suspicious" | "not-checkable" | "not-applicable";
@@ -703,12 +723,59 @@ declare const LeakReportSchema: z.ZodObject<{
         } | undefined;
         residualAfterRevoke?: string[] | undefined;
         screenshots?: {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }[] | undefined;
         screenshotPath?: string | undefined;
+        ignoredFindings?: number | undefined;
     }>, "many">>;
+    /** Per `--ignore` gefilterte Befunde — werden ausgewiesen, nicht verschwiegen. */
+    ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trackerName: z.ZodString;
+        requestUrl: z.ZodString;
+        scenario: z.ZodEnum<["happy-path-denied", "happy-path-accepted", "fast-click", "state-manipulation", "network-drop", "consent-revoked", "category-selective", "consent-persistence", "banner-ignored", "subpage-spa", "cmp-failure", "embed-leaks", "consent-mode-v2", "duplicate-events", "mobile-usability"]>;
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        trackerName: string;
+        scenario: "happy-path-denied" | "happy-path-accepted" | "fast-click" | "state-manipulation" | "network-drop" | "consent-revoked" | "category-selective" | "consent-persistence" | "banner-ignored" | "subpage-spa" | "cmp-failure" | "embed-leaks" | "consent-mode-v2" | "duplicate-events" | "mobile-usability";
+        requestUrl: string;
+        pattern: string;
+    }, {
+        trackerName: string;
+        scenario: "happy-path-denied" | "happy-path-accepted" | "fast-click" | "state-manipulation" | "network-drop" | "consent-revoked" | "category-selective" | "consent-persistence" | "banner-ignored" | "subpage-spa" | "cmp-failure" | "embed-leaks" | "consent-mode-v2" | "duplicate-events" | "mobile-usability";
+        requestUrl: string;
+        pattern: string;
+    }>, "many">>;
+    /**
+     * Scanner: wurde irgendwo ein Consent-Banner-Element sichtbar gesehen (auch wenn Accept/Reject nicht klickbar
+     * erkannt wurden)? `false` = Suche endete vollständig ohne Banner-Hinweis; `undefined` = nicht ermittelt.
+     */
+    bannerObserved: z.ZodOptional<z.ZodBoolean>;
+    /** Scanner: Hinweise zur Reichweite des Scans (ungültige/ungenutzte Override-Selektoren, spät erschienener Banner). */
+    scannerWarnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Szenario `subpage-spa`: so viele der verlinkten Unterseiten wurden geprüft (`checked`, HTTP < 400) von allen
+     * verlinkten (`linked`); `max` ist die Obergrenze der Stichprobe (`--max-subpages`). Fehlt, wenn das Szenario nicht lief.
+     */
+    subpageSampling: z.ZodOptional<z.ZodObject<{
+        checked: z.ZodNumber;
+        linked: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        checked: number;
+        linked: number;
+        max: number;
+    }, {
+        checked: number;
+        linked: number;
+        max: number;
+    }>>;
+    /**
+     * Warum «kein Banner» nicht belegt ist: `unstable` (Reload-Schleife, Banner nicht auswertbar), `late` (Banner erschien
+     * nach dem Wartefenster), `inoperable` (Banner vorhanden, aber nicht über Ablehnen/Akzeptieren bedienbar).
+     */
+    bannerIssue: z.ZodOptional<z.ZodEnum<["unstable", "late", "inoperable"]>>;
 }, "strip", z.ZodTypeAny, {
     targetUrl: string;
     scannedAt: string;
@@ -724,6 +791,7 @@ declare const LeakReportSchema: z.ZodObject<{
         timestamp: string;
         description: string;
         ruleId?: string | undefined;
+        advisory?: boolean | undefined;
         domContext?: {
             triggerElement?: string | undefined;
             consentBannerVisible?: boolean | undefined;
@@ -780,12 +848,27 @@ declare const LeakReportSchema: z.ZodObject<{
         } | undefined;
         residualAfterRevoke?: string[] | undefined;
         screenshots?: {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }[] | undefined;
         screenshotPath?: string | undefined;
+        ignoredFindings?: number | undefined;
+    }[] | undefined;
+    ignored?: {
+        trackerName: string;
+        scenario: "happy-path-denied" | "happy-path-accepted" | "fast-click" | "state-manipulation" | "network-drop" | "consent-revoked" | "category-selective" | "consent-persistence" | "banner-ignored" | "subpage-spa" | "cmp-failure" | "embed-leaks" | "consent-mode-v2" | "duplicate-events" | "mobile-usability";
+        requestUrl: string;
+        pattern: string;
     }[] | undefined;
+    bannerObserved?: boolean | undefined;
+    scannerWarnings?: string[] | undefined;
+    subpageSampling?: {
+        checked: number;
+        linked: number;
+        max: number;
+    } | undefined;
+    bannerIssue?: "unstable" | "late" | "inoperable" | undefined;
 }, {
     targetUrl: string;
     scannedAt: string;
@@ -800,6 +883,7 @@ declare const LeakReportSchema: z.ZodObject<{
         timestamp: string;
         description: string;
         ruleId?: string | undefined;
+        advisory?: boolean | undefined;
         method?: string | undefined;
         domContext?: {
             triggerElement?: string | undefined;
@@ -857,14 +941,31 @@ declare const LeakReportSchema: z.ZodObject<{
         } | undefined;
         residualAfterRevoke?: string[] | undefined;
         screenshots?: {
-            at: string;
             path: string;
+            at: string;
             label: string;
         }[] | undefined;
         screenshotPath?: string | undefined;
+        ignoredFindings?: number | undefined;
     }[] | undefined;
+    ignored?: {
+        trackerName: string;
+        scenario: "happy-path-denied" | "happy-path-accepted" | "fast-click" | "state-manipulation" | "network-drop" | "consent-revoked" | "category-selective" | "consent-persistence" | "banner-ignored" | "subpage-spa" | "cmp-failure" | "embed-leaks" | "consent-mode-v2" | "duplicate-events" | "mobile-usability";
+        requestUrl: string;
+        pattern: string;
+    }[] | undefined;
+    bannerObserved?: boolean | undefined;
+    scannerWarnings?: string[] | undefined;
+    subpageSampling?: {
+        checked: number;
+        linked: number;
+        max: number;
+    } | undefined;
+    bannerIssue?: "unstable" | "late" | "inoperable" | undefined;
 }>;
+type BannerIssue = NonNullable<z.infer<typeof LeakReportSchema>["bannerIssue"]>;
 type LeakReport = z.infer<typeof LeakReportSchema>;
+type IgnoredFinding = NonNullable<LeakReport["ignored"]>[number];
 /**
  * Patch proposal produced by the remediation engine
  */
@@ -933,6 +1034,17 @@ declare const ReviewVerdictSchema: z.ZodObject<{
         originalContent?: string | undefined;
         diff?: string | undefined;
     }>, "many">;
+    /** Teilfix: Score und `passed` gelten nur für den gepatchten Teil (`covered` von `total` gemeldeten Trackern). */
+    partial: z.ZodOptional<z.ZodObject<{
+        covered: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        covered: number;
+        total: number;
+    }, {
+        covered: number;
+        total: number;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     passed: boolean;
     score: number;
@@ -951,6 +1063,10 @@ declare const ReviewVerdictSchema: z.ZodObject<{
         originalContent?: string | undefined;
         diff?: string | undefined;
     }[];
+    partial?: {
+        covered: number;
+        total: number;
+    } | undefined;
 }, {
     passed: boolean;
     score: number;
@@ -969,6 +1085,10 @@ declare const ReviewVerdictSchema: z.ZodObject<{
         originalContent?: string | undefined;
         diff?: string | undefined;
     }[];
+    partial?: {
+        covered: number;
+        total: number;
+    } | undefined;
 }>;
 type ReviewVerdict = z.infer<typeof ReviewVerdictSchema>;
 /**
@@ -1060,6 +1180,17 @@ declare const RemediationResultSchema: z.ZodObject<{
             originalContent?: string | undefined;
             diff?: string | undefined;
         }>, "many">;
+        /** Teilfix: Score und `passed` gelten nur für den gepatchten Teil (`covered` von `total` gemeldeten Trackern). */
+        partial: z.ZodOptional<z.ZodObject<{
+            covered: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            covered: number;
+            total: number;
+        }, {
+            covered: number;
+            total: number;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         passed: boolean;
         score: number;
@@ -1078,6 +1209,10 @@ declare const RemediationResultSchema: z.ZodObject<{
             originalContent?: string | undefined;
             diff?: string | undefined;
         }[];
+        partial?: {
+            covered: number;
+            total: number;
+        } | undefined;
     }, {
         passed: boolean;
         score: number;
@@ -1096,6 +1231,10 @@ declare const RemediationResultSchema: z.ZodObject<{
             originalContent?: string | undefined;
             diff?: string | undefined;
         }[];
+        partial?: {
+            covered: number;
+            total: number;
+        } | undefined;
     }>>;
     commitHash: z.ZodOptional<z.ZodString>;
     commitMessage: z.ZodOptional<z.ZodString>;
@@ -1149,6 +1288,10 @@ declare const RemediationResultSchema: z.ZodObject<{
             originalContent?: string | undefined;
             diff?: string | undefined;
         }[];
+        partial?: {
+            covered: number;
+            total: number;
+        } | undefined;
     } | undefined;
     commitHash?: string | undefined;
     commitMessage?: string | undefined;
@@ -1188,6 +1331,10 @@ declare const RemediationResultSchema: z.ZodObject<{
             originalContent?: string | undefined;
             diff?: string | undefined;
         }[];
+        partial?: {
+            covered: number;
+            total: number;
+        } | undefined;
     } | undefined;
     commitHash?: string | undefined;
     commitMessage?: string | undefined;
@@ -1202,16 +1349,26 @@ declare const RemediationResultSchema: z.ZodObject<{
     error?: string | undefined;
 }>;
 type RemediationResult = z.infer<typeof RemediationResultSchema>;
+/**
+ * Rechtsräume, die `--jurisdiction` akzeptiert (siehe core/legal/jurisdictions.ts).
+ */
+declare const JurisdictionCodeSchema: z.ZodEnum<["CH", "EU", "UK", "US-CA", "BR", "ROW"]>;
 /**
  * Privacy Gate CLI & Configuration Options
  */
 declare const GateConfigSchema: z.ZodObject<{
-    targetUrl: z.ZodString;
+    targetUrl: z.ZodEffects<z.ZodString, string, string>;
+    /** LLM-Key — wird nur gesetzt, wenn `llmRemediation` aktiv ist (siehe resolveGateConfig). */
     apiKey: z.ZodOptional<z.ZodString>;
     llmProvider: z.ZodDefault<z.ZodEnum<["openai", "anthropic", "gemini"]>>;
     llmModel: z.ZodDefault<z.ZodString>;
+    /** Explizites Opt-in: Quellcode darf zur Patch-Erzeugung an den LLM-Anbieter gesendet werden. */
+    llmRemediation: z.ZodDefault<z.ZodBoolean>;
+    /** Default aus: Auto-Fix schreibt nur, wenn der Aufrufer ihn ausdrücklich anfordert. */
     autoFix: z.ZodDefault<z.ZodBoolean>;
     failOnLeak: z.ZodDefault<z.ZodBoolean>;
+    /** Kernszenarien nicht prüfbar ⇒ Exit 4 (INCONCLUSIVE) statt stiller Freigabe. */
+    failOnUncheckable: z.ZodDefault<z.ZodBoolean>;
     reportOutput: z.ZodDefault<z.ZodString>;
     sourceDir: z.ZodDefault<z.ZodString>;
     gitCommit: z.ZodDefault<z.ZodBoolean>;
@@ -1221,27 +1378,73 @@ declare const GateConfigSchema: z.ZodObject<{
     branchPrefix: z.ZodDefault<z.ZodString>;
     /** Optional: nur diese Szenarien ausführen (leer = alle). Für Tests/CI gezielt. */
     scenarios: z.ZodOptional<z.ZodArray<z.ZodEnum<["happy-path-denied", "happy-path-accepted", "fast-click", "state-manipulation", "network-drop", "consent-revoked", "category-selective", "consent-persistence", "banner-ignored", "subpage-spa", "cmp-failure", "embed-leaks", "consent-mode-v2", "duplicate-events", "mobile-usability"]>, "many">>;
+    /** Rechtsraum, der in Konsole und report.json hervorgehoben wird (der Report führt alle Räume auf). */
+    jurisdiction: z.ZodDefault<z.ZodEnum<["CH", "EU", "UK", "US-CA", "BR", "ROW"]>>;
     /** Demo-Lauf mit synthetischen Testdaten — Report wird gekennzeichnet */
     demo: z.ZodOptional<z.ZodBoolean>;
     /** Deluxe-PDF (Deckblatt + Evidence) nach dem Scan erzeugen */
     reportPdf: z.ZodOptional<z.ZodBoolean>;
-    /** Kundenname für das PDF-Deckblatt */
+    /** Kundenname für das PDF-Deckblatt (Default: Host der Ziel-URL) */
     clientName: z.ZodOptional<z.ZodString>;
     headless: z.ZodDefault<z.ZodBoolean>;
+    /** Timeout je Szenario-Navigation und für den Erreichbarkeits-Check (ms) */
     timeoutMs: z.ZodDefault<z.ZodNumber>;
+    /** Hinweise (advisory, z. B. rein funktionale Google Fonts) blockieren das Gate ebenfalls. */
+    strict: z.ZodDefault<z.ZodBoolean>;
+    /** Tracker-Namen oder Host-Muster (`fonts.googleapis.com`, `*.hotjar.com`), die als «ignoriert» ausgewiesen werden. */
+    ignore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Erlaubt sehr breite `--ignore`-Muster (`*`, `*.com`, einzelne TLD); sonst Exit 3. Nur CLI/echte Umgebung. */
+    allowBroadIgnore: z.ZodDefault<z.ZodBoolean>;
+    /** Obergrenze der Unterseiten-Stichprobe (Szenario subpage-spa), `--max-subpages` (Standard 12, höchstens 40). */
+    maxSubpages: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Wartefenster auf einen (spät erscheinenden) Banner in Sekunden, `--banner-wait` (höchstens 60). Ohne Angabe gilt das
+     * bisherige Verhalten (8 s, bei Seiten ohne Banner-Hinweis früher beendet); mit Angabe wird das Fenster ausgeschöpft.
+     */
+    bannerWaitSeconds: z.ZodOptional<z.ZodNumber>;
+    /** Hinweise zur Eingabe (z. B. leerer Selektor), die der Scanner in `scannerWarnings` übernimmt. */
+    configWarnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Scanner-Overrides für eigene Banner (CSS-Selektoren bzw. Teilstring der Banner-Frame-URL). */
+    acceptSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rejectSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    settingsSelectors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    bannerFrame: z.ZodOptional<z.ZodString>;
+    /**
+     * Lizenzstatus — wird ausschliesslich von der CLI (oder dem Aufrufer der API) gesetzt, nie aus Env/.env.
+     * Ohne gültige Lizenz laufen PDF-Report, Kundenreport (`client`), `gitCommit` und `createPr` nicht
+     * (Scan und Gate bleiben frei; Loopback-Ziele sind immer frei).
+     */
+    license: z.ZodOptional<z.ZodObject<{
+        entitled: z.ZodBoolean;
+        /** Warum nicht lizenziert: keine Lizenz gesetzt | Lizenzserver nicht erreichbar */
+        reason: z.ZodOptional<z.ZodEnum<["none", "unreachable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        entitled: boolean;
+        reason?: "none" | "unreachable" | undefined;
+    }, {
+        entitled: boolean;
+        reason?: "none" | "unreachable" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     targetUrl: string;
     llmProvider: "openai" | "anthropic" | "gemini";
     llmModel: string;
+    llmRemediation: boolean;
     autoFix: boolean;
     failOnLeak: boolean;
+    failOnUncheckable: boolean;
     reportOutput: string;
     sourceDir: string;
     gitCommit: boolean;
     createPr: boolean;
     branchPrefix: string;
+    jurisdiction: "CH" | "EU" | "UK" | "US-CA" | "BR" | "ROW";
     headless: boolean;
     timeoutMs: number;
+    strict: boolean;
+    ignore: string[];
+    allowBroadIgnore: boolean;
+    maxSubpages: number;
     apiKey?: string | undefined;
     githubToken?: string | undefined;
     baseBranch?: string | undefined;
@@ -1249,13 +1452,25 @@ declare const GateConfigSchema: z.ZodObject<{
     demo?: boolean | undefined;
     reportPdf?: boolean | undefined;
     clientName?: string | undefined;
+    bannerWaitSeconds?: number | undefined;
+    configWarnings?: string[] | undefined;
+    acceptSelectors?: string[] | undefined;
+    rejectSelectors?: string[] | undefined;
+    settingsSelectors?: string[] | undefined;
+    bannerFrame?: string | undefined;
+    license?: {
+        entitled: boolean;
+        reason?: "none" | "unreachable" | undefined;
+    } | undefined;
 }, {
     targetUrl: string;
     apiKey?: string | undefined;
     llmProvider?: "openai" | "anthropic" | "gemini" | undefined;
     llmModel?: string | undefined;
+    llmRemediation?: boolean | undefined;
     autoFix?: boolean | undefined;
     failOnLeak?: boolean | undefined;
+    failOnUncheckable?: boolean | undefined;
     reportOutput?: string | undefined;
     sourceDir?: string | undefined;
     gitCommit?: boolean | undefined;
@@ -1264,23 +1479,129 @@ declare const GateConfigSchema: z.ZodObject<{
     baseBranch?: string | undefined;
     branchPrefix?: string | undefined;
     scenarios?: ("happy-path-denied" | "happy-path-accepted" | "fast-click" | "state-manipulation" | "network-drop" | "consent-revoked" | "category-selective" | "consent-persistence" | "banner-ignored" | "subpage-spa" | "cmp-failure" | "embed-leaks" | "consent-mode-v2" | "duplicate-events" | "mobile-usability")[] | undefined;
+    jurisdiction?: "CH" | "EU" | "UK" | "US-CA" | "BR" | "ROW" | undefined;
     demo?: boolean | undefined;
     reportPdf?: boolean | undefined;
     clientName?: string | undefined;
     headless?: boolean | undefined;
     timeoutMs?: number | undefined;
+    strict?: boolean | undefined;
+    ignore?: string[] | undefined;
+    allowBroadIgnore?: boolean | undefined;
+    maxSubpages?: number | undefined;
+    bannerWaitSeconds?: number | undefined;
+    configWarnings?: string[] | undefined;
+    acceptSelectors?: string[] | undefined;
+    rejectSelectors?: string[] | undefined;
+    settingsSelectors?: string[] | undefined;
+    bannerFrame?: string | undefined;
+    license?: {
+        entitled: boolean;
+        reason?: "none" | "unreachable" | undefined;
+    } | undefined;
 }>;
-type GateConfig = z.infer<typeof GateConfigSchema>;
+/** Geparste Konfiguration (alle Defaults gesetzt). */
+type GateConfig = z.output<typeof GateConfigSchema>;
+/** Eingabe-Typ der öffentlichen API: Felder mit Default sind optional. */
+type GateConfigInput = z.input<typeof GateConfigSchema>;
+/**
+ * Exit-Codes der CLI (in `--help` dokumentiert).
+ */
+declare const EXIT: {
+    readonly OK: 0;
+    /** Offene Leaks (BLOCKED), auch bei nur vorgeschlagenem, nicht verifiziertem Fix */
+    readonly LEAKS: 1;
+    /** Lizenz ungültig/abgelaufen/gesperrt (fehlende Lizenz oder nicht erreichbarer Lizenzserver nicht) */
+    readonly LICENSE: 2;
+    /** Fehler: Ziel unerreichbar, Konfiguration, Browser fehlt */
+    readonly ERROR: 3;
+    /** Unvollständig: Kernszenarien nicht prüfbar (INCONCLUSIVE) */
+    readonly INCONCLUSIVE: 4;
+};
+/**
+ * Vollständigkeit eines Scans: «nicht prüfbar» ist kein «bestanden».
+ */
+interface GateAssessment {
+    /** Anzahl der geforderten Szenarien (z. B. 15) */
+    scenariosTotal: number;
+    /** Alle nicht prüfbaren Szenarien (inkl. «auffällig» mit Timeout/Fehler-Aktion) */
+    uncheckable: ChaosScenario[];
+    /** Davon Kernszenarien (Ablehnen-/Akzeptieren-Pfad, die den Banner bedienen) */
+    coreUncheckable: ChaosScenario[];
+    /** true, wenn kein Szenario nicht prüfbar ist und die Unterseiten-Stichprobe vollständig war */
+    complete: boolean;
+    /** Befundgruppen (Ursachen) statt Request-Zeilen — nur gate-blockierende Befunde */
+    findingGroups: {
+        ruleId: string;
+        trackerName: string;
+        count: number;
+    }[];
+    /** Hinweise (advisory), nicht gate-blockierend ausser mit `--strict` */
+    advisoryGroups: {
+        ruleId: string;
+        trackerName: string;
+        count: number;
+    }[];
+    /** Seite ohne Consent-Banner und ohne Tracker: es gibt nichts zu prüfen */
+    noBannerNoTracker: boolean;
+    /** Unterseiten-Stichprobe (Szenario subpage-spa), falls es lief */
+    sampling?: SamplingInfo;
+}
+/** Unterseiten-Stichprobe: `checked` von `linked` geprüft; `incomplete`, wenn nicht alle verlinkten Unterseiten dran waren. */
+interface SamplingInfo {
+    checked: number;
+    linked: number;
+    max: number;
+    incomplete: boolean;
+}
+/**
+ * Gate-Zustand: `clean` = PASS, `remediated` = Fix durch sauberen Re-Scan der Ziel-URL verifiziert,
+ * `fix-proposed` = Fix als Commit/PR vorgeschlagen, aber nicht verifiziert (weiterhin BLOCKED).
+ */
+type GateState = "clean" | "remediated" | "blocked" | "inconclusive" | "fix-proposed";
+/** Gate-Zustand, wie ihn der Orchestrator führt — Eingabe für Report, Deckblatt und PDF. */
+interface ReportGate {
+    state: GateState;
+    scenariosTotal: number;
+    /** Anzahl nicht prüfbarer Szenarien (laut Orchestrator) */
+    uncheckable: number;
+    coreUncheckable: ChaosScenario[];
+    /** `--strict`: Hinweise zählen als Verstoss */
+    strict?: boolean;
+    noBannerNoTracker?: boolean;
+    /** Vom Scanner gemeldet: wurde ein Consent-Banner gesehen? (undefined = unbekannt) */
+    bannerObserved?: boolean;
+    /** Warum «kein Banner» nicht belegt ist (Reload-Schleife, spät erschienen, nicht bedienbar) */
+    bannerIssue?: BannerIssue;
+    /** Unterseiten-Stichprobe (Szenario subpage-spa), falls es lief */
+    sampling?: SamplingInfo;
+    /** Warnungen des Scanners (z. B. ungültige Override-Selektoren) */
+    scannerWarnings?: string[];
+    /** `--ignore`-Muster, die sehr breit sind (nur mit `--allow-broad-ignore` überhaupt zulässig oder nur Warnung) */
+    broadIgnore?: string[];
+    /** Teilfix mit Commit/PR: so viele gemeldete Tracker bleiben manuell zu beheben */
+    partialManual?: number;
+}
 /**
  * Overall pipeline outcome
  */
 interface GateExecutionResult {
     report: LeakReport;
     remediation?: RemediationResult;
-    status: "clean" | "remediated" | "blocked" | "error";
+    status: GateState | "error";
     exitCode: number;
+    assessment?: GateAssessment;
 }
 
+/** Für `--help`: die einzigen Schlüssel, die eine `.env` setzen darf. */
+declare const ENV_FILE_KEYS_HELP: string;
+declare function isEnvKeyAllowedFromFile(key: string): boolean;
+/**
+ * Lädt eine `.env` aus dem Arbeitsverzeichnis in `process.env` — nur explizit aufgerufen (CLI),
+ * nie als Import-Seiteneffekt. Die echte Umgebung gewinnt (wie bei dotenv); übernommen wird nur die Allowlist
+ * (`isEnvKeyAllowedFromFile`).
+ */
+declare function loadProjectEnv(file?: string, env?: NodeJS.ProcessEnv): void;
 interface CliRawOptions {
     reportPdf?: boolean | string;
     client?: string;
@@ -1289,8 +1610,11 @@ interface CliRawOptions {
     apiKey?: string;
     llmProvider?: string;
     llmModel?: string;
+    /** Opt-in: Quellcode darf an den LLM-Anbieter gesendet werden */
+    llmRemediation?: string | boolean;
     autoFix?: string | boolean;
     failOnLeak?: string | boolean;
+    failOnUncheckable?: string | boolean;
     reportOutput?: string;
     sourceDir?: string;
     gitCommit?: string | boolean;
@@ -1300,128 +1624,311 @@ interface CliRawOptions {
     baseBranch?: string;
     headless?: string | boolean;
     timeoutMs?: string | number;
+    /** Szenarien-Auswahl: Array oder kommagetrennte Liste (leer = alle) */
+    scenarios?: ChaosScenario[] | string[] | string;
+    /** Rechtsraum: CH | EU | UK | US-CA | BR | ROW */
+    jurisdiction?: string;
+    /** Wird hier nicht ausgewertet — die Lizenzprüfung passiert in der CLI (src/cli.ts). */
+    license?: string;
+    /** Hinweise (advisory) blockieren ebenfalls */
+    strict?: string | boolean;
+    /** Sehr breite --ignore-Muster (`*`, `*.com`, einzelne TLD) bewusst erlauben */
+    allowBroadIgnore?: string | boolean;
+    /** Tracker-Namen oder Host-Muster, kommagetrennt oder mehrfach */
+    ignore?: string[] | string;
+    /** Scanner-Overrides: CSS-Selektoren, kommagetrennt oder mehrfach */
+    acceptSelector?: string[] | string;
+    rejectSelector?: string[] | string;
+    settingsSelector?: string[] | string;
+    /** Teilstring der URL des Banner-Frames (iframe-CMP) */
+    bannerFrame?: string;
+    /** Obergrenze der Unterseiten-Stichprobe (Standard 12, höchstens 40) */
+    maxSubpages?: string | number;
+    /** Wartefenster auf einen spät erscheinenden Banner in Sekunden (höchstens 60) */
+    bannerWait?: string | number;
 }
+/** Validiert eine Eingabe (Defaults werden gesetzt). Wirft «Invalid Configuration». */
+declare function parseGateConfig(input: GateConfigInput): GateConfig;
 declare function resolveGateConfig(cliOptions: CliRawOptions): GateConfig;
 
 interface ChaosScannerInterface {
     scan(config: GateConfig): Promise<LeakReport>;
 }
 
-/**
- * True when `pageUrl` is still on the scanned target origin (or not yet navigated).
- * Used so tracker traffic from off-site navigation (e.g. a logo link to a vendor site)
- * is not attributed to the target under test.
- */
-declare function isOnTargetOrigin(pageUrl: string, targetOrigin: string): boolean;
-/**
- * Clicks the first anchor whose resolved URL stays on `targetOrigin`.
- * Off-site links (logo/footer/vendor) are skipped to avoid leaving the page under test.
- */
-declare function clickFirstSameOriginLink(page: playwright.Page, targetOrigin: string): Promise<boolean>;
+/** Optionale Vorgaben fuer Seiten mit unbekanntem Banner; werden VOR den Standardlisten ausgewertet. */
+interface ScannerOverrides {
+    /** CSS-/Playwright-Selektoren fuer «Alle akzeptieren». */
+    acceptSelectors?: string[];
+    /** CSS-/Playwright-Selektoren fuer «Ablehnen» / «Nur notwendige». */
+    rejectSelectors?: string[];
+    /** CSS-/Playwright-Selektoren fuer «Einstellungen». */
+    settingsSelectors?: string[];
+    /** Teilstring der Frame-URL, in der der Banner liegt (cross-origin iframe-CMP). */
+    bannerFrame?: string;
+    /**
+     * Das Wartefenster ausschöpfen, statt bei Seiten ohne Banner-Hinweis früh aufzugeben (`--banner-wait`). Gilt auch
+     * ohne diese Angabe, sobald eigene Selektoren oder ein Banner-Frame angegeben sind: dann wird bis zum Ende gewartet.
+     */
+    exhaustiveWait?: boolean;
+}
+
+interface ChaosScannerOptions extends ScannerOverrides {
+    /** Zielverzeichnis fuer Screenshots (Default: `evidence/` neben dem Report aus der Config). */
+    evidenceDir?: string;
+    /** Obergrenze fuer die Gesamtgroesse der Screenshots eines Laufs in Bytes (Default 100 MB); darueber nur noch verkleinerte. */
+    evidenceMaxBytes?: number;
+}
 declare class ChaosScanner implements ChaosScannerInterface {
+    private evidenceDir?;
+    private readonly overrides;
+    /** Bannersuche des laufenden Scans (Selektoren inkl. Overrides, «kein Banner» gemerkt). */
+    private session;
+    /** Navigation je Szenario (Fail-open-Schutz: Seite endete auf fremder Origin). */
+    private watches;
+    /** GTM-/gtag-Loader mit Consent Mode (default denied) ohne Messung ist kein Pre-Consent-Leak. */
+    private gtmLoaderExempt;
+    /** Hinweise zur Reichweite des Scans (Selektor-Fehler, spaet erschienener oder nicht bedienbarer Banner). */
+    private warnings;
+    /** Wartefenster auf einen Banner (ms) und ob es ausdruecklich gesetzt wurde (`--banner-wait`). */
+    private bannerWaitMs;
+    private bannerWaitExplicit;
+    /** Obergrenze der Unterseiten-Stichprobe (`--max-subpages`). */
+    private maxSubpages;
+    /** Ergebnis der Schlusspruefung: nur `completed` belegt «kein Banner». */
+    private bannerProbe;
+    private bannerIssue?;
+    private subpageSampling?;
+    /** Bytes der in diesem Lauf geschriebenen Screenshots und deren Obergrenze. */
+    private evidenceBytes;
+    private evidenceCapNoted;
+    private readonly evidenceMaxBytes;
+    constructor(options?: ChaosScannerOptions);
+    /** Die Schlusspruefung lief das Wartefenster vollstaendig ohne Banner-Hinweis durch (Seite stabil). */
+    private probeCompleted;
+    /** Overrides plus: das Wartefenster ausschoepfen, wenn `--banner-wait` ausdruecklich gesetzt ist. */
+    private sessionOverrides;
+    /** Beobachtung der Hauptseiten-Navigation fuer `scenario` merken (nachtraegliche Bewertung in scan()). */
+    private remember;
+    /** Verhalten eines erkannten Trackers: kein Befund (GTM-Loader mit Consent Mode), Hinweis oder Verstoss. */
+    private trackerVerdict;
+    /** `{ advisory: true }` fuer rein funktionale Treffer (Hinweis ohne Gate-Wirkung). */
+    private advisoryFlag;
+    /** Zaehlt ein Timeline-Ereignis als belastbarer Tracker-Befund (nicht advisory, nicht exempt). */
+    private isBlocking;
     scan(config: GateConfig): Promise<LeakReport>;
+    /** Browser-Kontext mit blockierten Service Workern (deren Requests waeren unsichtbar) und Registrierungs-Beobachtung. */
+    private newContext;
+    /** Ungueltige Override-Selektoren (CSS-Syntaxfehler) werden gemeldet statt still verschluckt. */
+    private checkOverrideSelectors;
+    /**
+     * Schlusspruefung: War bis hierhin kein Banner sichtbar, laedt ein frischer Kontext die Zielseite und wartet
+     * ueber das normale Wartefenster hinaus. Erscheint ein Banner erst spaeter (Timer, langsames CMP), gilt
+     * «kein Banner» nicht — `bannerObserved` wird `true`, mit Hinweis.
+     */
+    private probeLateBanner;
+    /** Hinweise zum Banner-Zustand und zu nie verwendeten Override-Selektoren in `scannerWarnings`. */
+    private reportBannerState;
     private snapshotStorage;
+    /**
+     * Navigiert zur Ziel-URL und fuehrt den Zielbereich nach: die finale URL (nach Redirects)
+     * gehoert zum Ziel, auch wenn sie auf einer anderen Origin liegt. Navigiert die Seite selbst
+     * weiter (`<meta refresh>`, `location.replace`), wird auf die neue Seite gewartet statt abzubrechen.
+     * Fehlermeldungen nennen die konfigurierte Ursprungs-URL, nicht nur das Weiterleitungsziel.
+     */
+    private gotoTarget;
+    /**
+     * Scanner-Navigation zu einer verlinkten Unterseite: deren Weiterleitungen erweitern den Zielbereich nicht.
+     * Laufende Navigationen der vorigen Seite werden abgewartet; leitet die Unterseite selbst clientseitig weiter
+     * («interrupted by another navigation»), gilt der HTTP-Status der Endseite statt eines Abbruchs.
+     */
+    private gotoSubpage;
+    /**
+     * Consent Mode: Setzt die Seite VOR dem GTM-/gtag-Laden `consent default denied` und findet vor
+     * Consent keine Messung statt (keine Collect-/Pixel-Requests, keine Tracking-Cookies), ist der reine
+     * Skript-Load des Loaders kein Pre-Consent-Leak. Ohne Consent Mode bleibt er ein Verstoss.
+     */
+    private probeGtmConsentMode;
+    /** Rein funktionale Drittanbieter (z. B. Google Fonts) in der Timeline: als Hinweis in der Notiz vermerken. */
+    private annotateAdvisory;
+    /** Steht (jetzt) irgendein Consent-Banner im DOM der Zielseite? Merkt es fuer `bannerObserved`. */
+    private noteBannerHints;
+    /**
+     * Fail-open-Schutz: Lief ein Szenario ganz oder teilweise auf einer fremden Seite (Requests wurden
+     * dem Ziel nicht zugerechnet), ist ein «bestanden» nicht belastbar — dann «nicht prüfbar» mit Begruendung.
+     */
+    private applyScopeVerdicts;
     /**
      * Fünf Kern-Chaos-Szenarien mit vollständigem Evidence-Record.
      * Phasen statt Capture-Wipe: Pre-Consent-Funde bleiben immer erhalten.
      * Ergebnis: passed nur bei ausgeführter Aktion und null Illegal-Funden.
      */
     private runScenario;
+    /**
+     * Kein Ablehnen-Button gefunden: ist das ein Dark Pattern oder nur ein nicht erkannter Banner?
+     * Sehr konservativ — «Banner nicht erkannt» wird nie als Dark Pattern gemeldet. Ein Befund
+     * (`no-reject-option`) entsteht nur, wenn (1) auf der ersten Ebene ein Accept erkannt ist,
+     * (2) der Banner eindeutig als Cookie-Dialog erkennbar ist und ausser Accept nur Einstellungen/
+     * Infolinks enthaelt, (3) auch die Einstellungen (zweite Ebene) keinen Ablehnen-Weg bieten und
+     * (4) Tracking im Spiel ist (vor der Entscheidung oder nach dem Akzeptieren).
+     * `rejected`: ein Ablehnen-Weg wurde auf der zweiten Ebene gefunden und geklickt.
+     */
+    private assessMissingReject;
     private snap;
-    private logAct;
     /**
-     * Widerruf: erst akzeptieren, dann widerrufen. Prüft (a) keine neuen Tracker-Requests
-     * nach Widerruf, (b) ob Tracking-IDs in Cookies/Storage zurückbleiben.
-     * Kein Widerruf-Button — status «not-checkable» (nie grün).
+     * Screenshot fuer den Evidence-Ordner: Breite = Viewport, hoechstens SHOT_MAX_HEIGHT hoch, JPEG. Bleibt die Datei ueber
+     * SHOT_MAX_BYTES, wird mit sinkender Qualitaet und Hoehe erneut aufgenommen. Ist der evidence-Ordner des Laufs voll
+     * (evidenceMaxBytes), entstehen nur noch verkleinerte Aufnahmen, mit Hinweis in den Scanner-Warnungen.
      */
+    private captureShot;
+    /** Bricht eine noch laufende Navigation ab (Chrome `Page.stopLoading`), ohne auf deren Antwort zu warten. */
+    private stopLoading;
+    private logAct;
     /**
      * Kategorien-Granularität: Statistik erlaubt, Marketing abgelehnt.
-     * Marketing-Tracker (Meta, TikTok, LinkedIn, Criteo ⬦) dürfen danach NICHT feuern.
-     * Keine Kategorie-UI — status «not-checkable».
+     * Marketing-Tracker (Meta, TikTok, LinkedIn, Criteo, …) dürfen danach NICHT feuern.
+     * Ohne Kategorie-UI, ohne belegt abgewähltes Marketing oder ohne Speichern-Button —
+     * status «not-checkable» (nie «Alle akzeptieren» als Ersatz).
      */
     private runCategorySelectiveScenario;
     /**
-     * Entscheidung merken: nach «Ablehnen» Reload, Unterseiten-URL und Browser-Neustart
-     * (storageState). Tracker müssen ausbleiben, die Entscheidung muss erhalten bleiben.
+     * Entscheidung merken: nach «Ablehnen» Reload, Unterseite (echter verlinkter Pfad) und
+     * Browser-Neustart (storageState). Tracker müssen ausbleiben, die Entscheidung muss erhalten
+     * bleiben. Ohne erreichbare Unterseite ist die Persistenz nicht vollständig belegt — «not-checkable».
      */
     private runPersistenceScenario;
     /**
-     * Banner ignorieren: kein Klick, nur warten, scrollen, Navigation.
-     * Tracker dürfen nicht über Timer/Scroll/Input allein starten.
-     */
-    /**
-     * Unterseiten & SPA: Direkteinstieg auf Subpage, dann Client-Navigation ohne Reload.
-     * Consent-Schutz muss auch dort greifen.
-     */
-    /**
-     * CMP langsam oder defekt: CMP-Skripte verzögern/abbringen, dann beobachten,
-     * ob im Zeitfenster Tracker starten (Default-State-Leak).
+     * Mobile: iPhone-Viewport. Reject und Settings müssen sichtbar und klickbar sein.
+     * Nur Accept bedienbar — suspicious (Dark Pattern); keine Buttons — not-checkable.
      */
+    private runMobileUsabilityScenario;
     /**
-     * Eingebettete Inhalte (YouTube, Maps, Social, Chat): Drittanbieter-Requests
-     * vor Consent-Freigabe des Embeds. Inklusive iframe-src und nachgeladenen SDKs.
+     * Doppelte Events: ein Seitenaufruf nach Consent darf page_view nicht doppelt zählen
+     * (Plugin + GTM parallel) — je Property (GA4 `tid`, Pixel `id`, …): mehrere Properties mit je
+     * einem Beacon sind kein Duplikat. Ohne belegten Accept-Klick ist der Consent-Zustand nicht
+     * hergestellt — «not-checkable». First-Party-Heuristik: verdächtige same-origin Endpunkte
+     * (collect, pixel, track) werden markiert — Server-zu-Server ist von aussen begrenzt beweisbar.
      */
+    private runDuplicateEventsScenario;
     /**
-     * Consent Mode v2: dataLayer-Konsens-Zustände (ad_storage, analytics_storage, ⬦)
+     * Consent Mode v2: dataLayer-Konsens-Zustände (ad_storage, analytics_storage, …)
      * gegen tatsächliche Google-Requests und Cookies trennen.
      * Bei Basic dürfen nach Ablehnung keine Nutzungsdaten laufen; bei Advanced
      * sind cookielose Pings möglich — beides wird getrennt ausgewiesen.
      */
+    private runConsentModeV2Scenario;
     /**
-     * Doppelte Events: ein Seitenaufruf nach Consent darf page_view nicht doppelt zählen
-     * (Plugin + GTM parallel). First-Party-Heuristik: verdächtige same-origin Endpunkte
-     * (collect, pixel, track) werden markiert — Server-zu-Server ist von aussen begrenzt beweisbar.
+     * Eingebettete Inhalte (YouTube, Maps, Social): Drittanbieter-Requests vor Consent-Freigabe
+     * des Embeds. Als Embed gilt nur, was die Tracker-Datenbank als Embed-Kategorie fuehrt —
+     * nicht per Namens-Regex (sonst wuerde z. B. das Meta Pixel als «Embed» klassifiziert).
      */
+    private runEmbedScenario;
     /**
-     * Mobile: iPhone-Viewport. Reject und Settings müssen sichtbar und klickbar sein.
-     * Nur Accept bedienbar — suspicious (Dark Pattern); keine Buttons — not-checkable.
+     * CMP langsam oder defekt: CMP-Ressourcen (auch same-origin, self-hosted) verzögern, dann
+     * hart abbrechen, und beobachten, ob im Zeitfenster Tracker starten (Default-State-Leak).
+     * Ohne abgefangene CMP-Ressource gibt es keinen Nachweis eines verzögerten CMPs —
+     * dann «not-checkable» statt «passed».
      */
-    private runMobileUsabilityScenario;
-    private runDuplicateEventsScenario;
-    private runConsentModeV2Scenario;
-    private runEmbedScenario;
     private runCmpFailureScenario;
+    /** Seite, auf der ein Request ausgelöst wurde (für Befunde auf Unterseiten); leer, wenn nicht ermittelbar. */
+    private pageHint;
+    /**
+     * Unterseiten & SPA: echte, auf der Startseite verlinkte Same-Origin-Pfade (HTTP-Status geprüft)
+     * als Direkteinstieg, danach clientseitige Navigation (Link-Klick ohne Dokument-Reload,
+     * History-API) beobachten. Es wird kein Consent erteilt — jeder Tracker ist ein Verstoss.
+     * Ohne erreichbare verlinkte Unterseite «not-checkable» (erfundene Pfade ergeben keinen Beleg).
+     */
     private runSubpageSpaScenario;
+    /**
+     * Banner ignorieren: kein Klick auf den Banner, nur warten, scrollen, auf freie Flaeche tippen.
+     * Tracker dürfen nicht über Timer/Scroll/Input allein starten.
+     */
     private runBannerIgnoredScenario;
+    /**
+     * Widerruf: erst akzeptieren, dann widerrufen. Prüft (a) keine neuen Tracker-Requests
+     * nach Widerruf, (b) ob Tracking-IDs in Cookies/Storage zurückbleiben.
+     * Kein Widerruf-Button — status «not-checkable» (nie grün).
+     */
     private runRevocationScenario;
 }
 
+/** patched = no unguarded execution left; manual = an auto-fix exists but could not be applied here; unpatched = no auto-fix. */
+type TrackerPatchState = "patched" | "unpatched" | "manual";
+interface TrackerStatus {
+    trackerName: string;
+    state: TrackerPatchState;
+    /** Why the tracker is not (fully) patched, or what was done; German, shown to the user. */
+    reason?: string;
+}
+/**
+ * RemediationResult plus what the caller needs to stay honest about partial fixes. Structurally a
+ * RemediationResult (all additions are optional), so existing consumers keep working.
+ */
+interface RemediationOutcome extends RemediationResult {
+    /**
+     * Also set for a partial fix (`partial: true`, `success: false`) whenever the approved patches were committed or
+     * pushed: `commitHash` (short hash of the commit, `gitCommit`), `pullRequest` (PR result incl. `branchName`, `createPr`)
+     * and `branchName` (the fix branch of the PR, a copy of `pullRequest.branchName`). A consumer must not read
+     * `success` as "nothing was written": check these fields.
+     */
+    branchName?: string;
+    /** Some patches were applied, but not every reported tracker is covered: do NOT treat the gate as fixed. */
+    partial?: boolean;
+    /** Part of the fix has to be done by hand (unpatched trackers, unsupported consent platform, entangled code). */
+    manual?: boolean;
+    /** Reported trackers that are not covered by a patch (state "unpatched" | "manual"). */
+    unpatched?: TrackerStatus[];
+    /** Status of every reported tracker name. */
+    trackerStatus?: TrackerStatus[];
+    /** Supported consent platforms (OneTrust, Cookiebot) found in the source: their category consent is read automatically, no hook needed. */
+    cmpSupported?: string[];
+    /** How a custom consent banner talks to the injected runtime (code lines, ready to paste). */
+    integrationHooks?: string[];
+    /** Plain-text instructions for PR body and console: what to fix by hand, and the consent hooks. */
+    manualSteps?: string;
+    /** Hint when a requested commit/PR could not be made (e.g. the source dir is in no git repository); the fix stays local. */
+    gitNote?: string;
+}
 interface RemediationEngineInterface {
-    remediate(report: LeakReport, config: GateConfig): Promise<RemediationResult>;
+    remediate(report: LeakReport, config: GateConfig): Promise<RemediationOutcome>;
 }
 
 interface CodeReviewerInterface {
     review(patches: FilePatch[], report: LeakReport, config: GateConfig): Promise<ReviewVerdict>;
 }
 
+/** What the fix does NOT cover and how a custom consent banner talks to the injected runtime. */
+interface PullRequestExtras {
+    unpatched?: TrackerStatus[];
+    integrationHooks?: string[];
+    /** Set when a supported CMP (OneTrust, Cookiebot) was recognised: it is read automatically, no hook is needed. */
+    consentNote?: string;
+}
 declare class PullRequestEngine {
     private git;
     /**
      * Creates a fix branch, commits only the given files, pushes and opens a PR when a remote + token exist.
      * Always returns to the starting branch. Throws on any git/API failure (caller restores the working tree).
      */
-    createPullRequest(patches: FilePatch[], report: LeakReport, reviewVerdict: ReviewVerdict, config: GateConfig): Promise<PullRequestResult>;
+    createPullRequest(patches: FilePatch[], report: LeakReport, reviewVerdict: ReviewVerdict, config: GateConfig, extras?: PullRequestExtras): Promise<PullRequestResult>;
     private resolveBaseBranch;
-    buildPrDescription(report: LeakReport, reviewVerdict: ReviewVerdict, patches: FilePatch[], config: GateConfig): string;
+    buildPrDescription(report: LeakReport, reviewVerdict: ReviewVerdict, patches: FilePatch[], config: GateConfig, extras?: PullRequestExtras): string;
 }
 
-/**
- * Injected when trackers are deferred. Activates `script[type=text/plain][data-src]`
- * and runs registered inits once consent is granted — including late accept clicks.
- */
-declare const CONSENT_ACTIVATION_RUNTIME = "<script data-cpcg=\"consent-activation\">\n(function () {\n  if (window.__cpcgConsentRuntime) return;\n  window.__cpcgConsentRuntime = true;\n  window.__cpcgInits = window.__cpcgInits || [];\n\n  function cpcgHasConsent() {\n    try {\n      var raw;\n      // Explicit hook for custom CMPs\n      if (window.__cpcgConsentGranted === true) return true;\n      // Our own / simple stores\n      raw = localStorage.getItem(\"cpcg_consent\");\n      if (raw === \"accepted\") return true;\n      raw = localStorage.getItem(\"consent\");\n      if (raw === \"accepted\") return true;\n      raw = localStorage.getItem(\"usercentrics-consent\");\n      if (raw === \"accepted\") return true;\n      // OneTrust: OptanonConsent is a URL-encoded query string (has consentId, groups=\u2026)\n      raw = localStorage.getItem(\"OptanonConsent\");\n      if (raw) {\n        if (raw === \"accepted\") return true;\n        try {\n          var q = new URLSearchParams(raw);\n          if (q.get(\"status\") === \"accepted\" || q.get(\"groups\") && q.get(\"groups\").indexOf(\":1\") !== -1) return true;\n          if (q.has(\"consentId\") && !/isIabGlobal=false;status=-1/.test(raw)) return true;\n        } catch (e) {}\n      }\n      // Cookiebot: JSON with consented / stamp\n      raw = localStorage.getItem(\"CookieConsent\");\n      if (raw) {\n        if (raw === \"accepted\" || raw === \"true\") return true;\n        try {\n          var cb = JSON.parse(raw);\n          if (cb && (cb.consented === true || cb.necessary === true || cb.stamp)) return true;\n        } catch (e) {}\n      }\n      // OneTrust OptanonConsent cookie fallback\n      if (/(^|;s*)OptanonConsent=/.test(document.cookie)) return true;\n      return false;\n    } catch (_) {\n      return false;\n    }\n  }\n\n  function cpcgActivateDeferred() {\n    if (!cpcgHasConsent()) return false;\n    document.querySelectorAll('script[type=\"text/plain\"][data-src]').forEach(function (old) {\n      if (old.getAttribute(\"data-cpcg-activated\") === \"1\") return;\n      old.setAttribute(\"data-cpcg-activated\", \"1\");\n      var s = document.createElement(\"script\");\n      s.src = old.getAttribute(\"data-src\");\n      s.async = old.async !== false;\n      if (old.getAttribute(\"data-cookiecategory\")) {\n        s.setAttribute(\"data-cookiecategory\", old.getAttribute(\"data-cookiecategory\"));\n      }\n      old.parentNode.insertBefore(s, old.nextSibling);\n    });\n    (window.__cpcgInits || []).forEach(function (fn) {\n      try { fn(); } catch (e) { /* init failed */ }\n    });\n    window.__cpcgInits = [];\n    return true;\n  }\n\n  window.cpcgActivateTrackers = cpcgActivateDeferred;\n  window.cpcgGrantConsent = function () {\n    window.__cpcgConsentGranted = true;\n    return cpcgActivateDeferred();\n  };\n\n  [\"click\", \"storage\", \"consent\", \"usercentrics-consent\", \"OneTrustLoaded\"].forEach(function (evt) {\n    window.addEventListener(evt, function () {\n      setTimeout(cpcgActivateDeferred, 50);\n    }, true);\n  });\n  document.addEventListener(\"click\", function () {\n    setTimeout(cpcgActivateDeferred, 50);\n  }, true);\n\n  // Late accept: poll briefly while the page is open\n  var tries = 0;\n  var timer = setInterval(function () {\n    tries += 1;\n    if (cpcgActivateDeferred() || tries > 40) clearInterval(timer);\n  }, 500);\n\n  if (document.readyState === \"loading\") {\n    document.addEventListener(\"DOMContentLoaded\", cpcgActivateDeferred);\n  } else {\n    cpcgActivateDeferred();\n  }\n})();\n</script>";
 declare class RemediationEngine implements RemediationEngineInterface {
     private reviewer;
     private prEngine;
     constructor(reviewer?: CodeReviewerInterface, prEngine?: PullRequestEngine);
-    remediate(report: LeakReport, config: GateConfig): Promise<RemediationResult>;
+    remediate(report: LeakReport, config: GateConfig): Promise<RemediationOutcome>;
     private findCandidateSourceFiles;
     /**
-     * Deterministic Privacy Patcher: Analyzes violations and injects consent gates or CMP categorization attributes
+     * Deterministic Privacy Patcher: defers tracker execution until category consent.
+     * HTML is patched script block by script block (everything else stays byte-identical); SPA sources get
+     * consent guards. Anything that cannot be patched safely is returned as a manual instruction instead.
      */
     private remediateWithRuleEngine;
     /**
-     * LLM API Remediation: Queries OpenAI/Anthropic/Gemini to generate surgical code patches
+     * LLM API Remediation (OpenAI only, explicit opt-in checked by the caller): generates surgical code patches
+     * for the files that actually reference the leaking tracker. Page-controlled strings are delimited as untrusted.
      */
     private remediateWithLlm;
     /**
@@ -1431,12 +1938,61 @@ declare class RemediationEngine implements RemediationEngineInterface {
     private sanitizeLlmPatches;
 }
 
+/**
+ * Kernszenarien: Ablehnen- und Akzeptieren-Pfad bedienen den Banner.
+ * Sind sie nicht prüfbar, sagt der Scan über Consent nichts aus — das Gate darf dann nicht PASS melden.
+ */
+declare const CORE_SCENARIOS: readonly ChaosScenario[];
+/** Gruppiert Befunde zu Befundgruppen (Regel + Tracker). */
+declare function groupFindings(violations: {
+    ruleId?: string;
+    trackerName: string;
+}[]): {
+    key: string;
+    ruleId: string;
+    trackerName: string;
+    count: number;
+}[];
+/** Bewertet die Vollständigkeit des Scans. */
+declare function assessReport(report: LeakReport, scenarios?: ChaosScenario[], options?: {
+    strict?: boolean;
+}): GateAssessment;
+
+/** Prüft, ob die Zielseite antwortet und nicht mit 4xx/5xx; wirft sonst einen neutralen Fehler. */
+declare function checkTargetReachable(url: string, timeoutMs: number, fetchImpl?: typeof fetch): Promise<number>;
+type Preflight = (config: GateConfig) => Promise<unknown>;
+/** Lizenzpflichtige Funktionen, die in diesem Lauf angefordert wurden (Bezeichnung für Konsole/Summary). */
+declare function requestedLicensedFeatures(config: GateConfig): string[];
+/** Hinweistext, warum lizenzpflichtige Funktionen nicht liefen; nennt die konkret übersprungene Funktion. */
+declare function licenseSkipText(config: GateConfig, skipped: string[]): string;
+/**
+ * Gründe, warum Szenarien nicht prüfbar sind, aus deren Notiz («Nicht prüfbar: <Grund> (zuvor: …)» bzw.
+ * «Szenario nicht prüfbar — <Grund> (kein grünes Häkchen)»); identische Gründe stehen einmal mit allen Szenarien.
+ */
+declare function uncheckableReasons(report: LeakReport, scenarios: ChaosScenario[]): {
+    reason: string;
+    scenarios: ChaosScenario[];
+}[];
 declare class PrivacyChaosGate {
-    private scanner;
+    private scanner?;
     private remediationEngine;
-    constructor(scanner?: ChaosScannerInterface, remediationEngine?: RemediationEngineInterface);
-    run(config: GateConfig): Promise<GateExecutionResult>;
+    private preflight?;
+    /**
+     * @param preflight Erreichbarkeits-Check vor dem Scan. Default: HTTP-Check (nur mit dem Standard-Scanner);
+     *                  wer einen eigenen Scanner injiziert, ist selbst für die Zielseite zuständig.
+     */
+    constructor(scanner?: ChaosScannerInterface, remediationEngine?: RemediationEngineInterface, preflight?: Preflight);
+    run(input: GateConfigInput): Promise<GateExecutionResult>;
+    private printExitNotes;
+    /** Aussage zum Re-Scan, ohne mehr zu behaupten als gemessen wurde. */
+    private rescanNote;
+    private proposalOf;
+    /** Hinweise zu einem lokal angelegten Fix-Branch (kein Token/Remote): wo der Fix liegt, ob der Arbeitsbaum geändert ist. */
+    private localBranchNotes;
+    private proposalText;
     private saveReport;
+    /** Komprimierte Fassungen (data-URI) für die Screenshots, sobald deren Gesamtgrösse einbettungsrelevant ist. */
+    private embeddableScreenshots;
     private writeGitHubOutputs;
     private writeGitHubSummary;
 }
@@ -1448,9 +2004,16 @@ declare class PrivacyChaosGate {
  */
 interface EvidenceMarkdownOptions {
     demo?: boolean;
+    /** Gate-Zustand aus dem Orchestrator; ohne Angabe wird er nur aus den Befunden abgeleitet. */
+    gate?: ReportGate;
+    /** Kundenname (Kundenreport) */
+    client?: string;
 }
+
 /** Status-Lesart für beide Renderer — eine Quelle, kein Drift. */
 declare function statusLabelOf(s: EvidenceRecord["status"]): string;
+/** Status eines Szenarios samt Zusatz: «bestanden (Befunde ignoriert)», wenn alle seine Befunde per --ignore ausgenommen wurden. */
+declare function evidenceLabelOf(e: EvidenceRecord): string;
 /** Zählung und Gate-Text — von Markdown und HTML gemeinsam genutzt. */
 interface ReportFacts {
     evidenceCount: number;
@@ -1459,9 +2022,22 @@ interface ReportFacts {
     uncheckable: number;
     notApplicable: number;
     incomplete: number;
+    /** Gate-blockierende Befunde (Request-Zeilen); Hinweise stehen in `advisory` */
     findings: number;
+    advisory: number;
+    ignored: number;
     observedCount: number;
-    gate: "PASS" | "BLOCKED";
+    /** Kurzlabel: PASS | BLOCKED | UNVOLLSTÄNDIG */
+    gate: "PASS" | "BLOCKED" | "UNVOLLSTÄNDIG";
+    gateState: GateState;
+    /** Volltext hinter «Technisches Gate: » (z. B. «UNVOLLSTÄNDIG — 2 von 15 Szenarien nicht prüfbar») */
+    gateHeadline: string;
+    /** Ton der Gate-Karte: ok | blocked | warn */
+    gateTone: "ok" | "blocked" | "warn";
+    /** Geprüft = bestanden + auffällig; nicht prüfbar laut Orchestrator (sonst aus den Nachweisen) */
+    checked: number;
+    uncheckableTotal: number;
+    scenariosTotal?: number;
     findingsText: string;
     gateDisclaimer: string;
     problemCount: number;
@@ -1475,28 +2051,34 @@ interface CodeSolution {
     code: string;
 }
 /** Nur Regeln mit belegtem Befund bekommen eine Code-Lösung. */
-declare function codeSolutionsFor(report: LeakReport): CodeSolution[];
-declare function deriveReportFacts(report: LeakReport): ReportFacts;
+declare function codeSolutionsFor(report: LeakReport, strict?: boolean): CodeSolution[];
+declare function deriveReportFacts(report: LeakReport, gate?: ReportGate): ReportFacts;
+/** Gate-Zustand für Deckblatt/PDF: dieselbe Ableitung wie im Report. */
+declare function resolveReportGate(report: LeakReport, gate?: ReportGate): ReportFacts;
+/**
+ * Zusatzhinweise zum Gate-Zustand (Banner nicht erkannt, Teilfix, Scanner-Warnungen, breites Ignore-Muster).
+ * Eine Quelle für Markdown, HTML und Deckblatt.
+ */
+declare function gateNotesOf(gate: ReportGate | undefined): {
+    state: string;
+    warnings: string[];
+};
 /** 1 Befund-Zeile / N Befund-Zeilen — nie «Befund-Zeile(n)». */
 declare function findingsCountText(n: number): string;
 /** Kundennutzen: Befundgruppen statt Request-Zeilen. */
 declare function problemsTextOf(n: number): string;
-/** Gruppiert Befunde zu Befundgruppen (Regel + Tracker). */
-declare function groupFindings(violations: {
-    ruleId?: string;
-    trackerName: string;
-}[]): {
-    key: string;
-    ruleId: string;
-    trackerName: string;
-    count: number;
-}[];
 /** Zähltext: Requests, nicht vage «×». */
 declare function reproductionText(count: number): string;
 declare function buildEvidenceMarkdown(report: LeakReport, title?: string, options?: EvidenceMarkdownOptions): string;
 interface EvidenceHtmlOptions {
     /** Demo-Lauf mit synthetischen Testdaten klar kennzeichnen */
     demo?: boolean;
+    /** Gate-Zustand aus dem Orchestrator; ohne Angabe wird er nur aus den Befunden abgeleitet. */
+    gate?: ReportGate;
+    /** Kundenname (Kundenreport) */
+    client?: string;
+    /** Komprimierte Fassungen der Screenshots (Originalpfad → data-URI), siehe `compressScreenshots` */
+    shotSources?: ReadonlyMap<string, string>;
 }
 /**
  * HTML-Beweisreport im offiziellen CuonzTech-Brand (Terminal-Schwarz, Gold,
@@ -1523,6 +2105,8 @@ interface CoverOptions {
     issuedAt?: string;
     /** Demo-Lauf mit synthetischen Testdaten — muss aufs Deckblatt */
     demo?: boolean;
+    /** Gate-Zustand aus dem Orchestrator; ohne Angabe wird er nur aus den Befunden abgeleitet. */
+    gate?: ReportGate;
 }
 declare function buildCoverHtml(report: LeakReport, options?: CoverOptions): string;
 /**
@@ -1538,8 +2122,46 @@ declare function renderDeluxeCombined(coverHtml: string, evidenceHtmlPath: strin
 declare function renderDeluxePdf(coverHtml: string, evidenceHtmlPath: string, outPath: string): Promise<string>;
 
 /**
- * Programmatic convenience function to run CPCG
+ * Lizenzstatus für die lizenzpflichtigen Funktionen (PDF-Report, Kundenreport, Fix-Commit/PR).
+ * Scan und Konsolen-Gate sind lizenzfrei — nur `invalid` beendet den Lauf (Exit 2).
+ * `unreachable` (Kunden-Key, Lizenzserver weg, kein Grant im Cache) ist ausdrücklich KEIN Fehler:
+ * ein frischer CI-Runner ohne Netz zum Lizenzserver darf das Gate nicht kippen.
+ */
+type Entitlement = {
+    status: "licensed";
+    kind: "pilot" | "customer-key";
+    summary: string;
+} | {
+    status: "none";
+} | {
+    status: "unreachable";
+    detail: string;
+} | {
+    status: "invalid";
+    messages: string[];
+};
+interface EntitlementInput {
+    /** Wert von `--license` (Vorrang vor Env CPCG_LICENSE) */
+    license?: string;
+    /** Default: process.env */
+    env?: NodeJS.ProcessEnv;
+    /** Test-Stubs */
+    fetchImpl?: typeof fetch;
+    publicKey?: string;
+}
+declare const LICENSE_CONTACT = "support@cuonztech.ch bzw. cuonztech.ch/privacy-chaos-gate";
+declare function resolveEntitlement(input?: EntitlementInput): Promise<Entitlement>;
+
+/**
+ * Loopback-Ziele (Entwicklung, Fixture-Tests) sind lizenzfrei. Nur der Hostname entscheidet,
+ * nie ein Substring der URL (`https://evil.example/?localhost`, `localhost.evil.example`).
+ */
+declare function isLoopbackTarget(url: string): boolean;
+
+/**
+ * Programmatic convenience function to run CPCG.
+ * Akzeptiert CLI-artige Optionen oder eine (teilweise) Konfiguration; Defaults werden ergänzt.
  */
-declare function runGate(optionsOrConfig: CliRawOptions | GateConfig): Promise<GateExecutionResult>;
+declare function runGate(optionsOrConfig: CliRawOptions | GateConfigInput): Promise<GateExecutionResult>;
 
-export { CONSENT_ACTIVATION_RUNTIME, ChaosScanner, type ChaosScannerInterface, type ChaosScenario, ChaosScenarioSchema, type CliRawOptions, type CodeSolution, type CoverOptions, type EvidenceHtmlOptions, type EvidenceMarkdownOptions, type EvidenceRecord, EvidenceRecordSchema, type EvidenceStatus, EvidenceStatusSchema, type FilePatch, FilePatchSchema, type GateConfig, GateConfigSchema, type GateExecutionResult, type LeakReport, LeakReportSchema, PrivacyChaosGate, type PullRequestResult, PullRequestResultSchema, RemediationEngine, type RemediationEngineInterface, type RemediationResult, RemediationResultSchema, type ReportFacts, type RequestEvent, RequestEventSchema, type ReviewVerdict, ReviewVerdictSchema, type StorageSnapshot, StorageSnapshotSchema, type TrackerCategory, TrackerCategorySchema, type TrackerViolation, TrackerViolationSchema, buildCoverHtml, buildEvidenceHtml, buildEvidenceMarkdown, clickFirstSameOriginLink, codeSolutionsFor, deriveReportFacts, findingsCountText, groupFindings, isOnTargetOrigin, problemsTextOf, renderDeluxeCombined, renderDeluxePdf, reproductionText, resolveGateConfig, runGate, statusLabelOf };
+export { type BannerIssue, CORE_SCENARIOS, ChaosScanner, type ChaosScannerInterface, type ChaosScenario, ChaosScenarioSchema, type CliRawOptions, type CodeSolution, type CoverOptions, ENV_FILE_KEYS_HELP, EXIT, type Entitlement, type EntitlementInput, type EvidenceHtmlOptions, type EvidenceMarkdownOptions, type EvidenceRecord, EvidenceRecordSchema, type EvidenceStatus, EvidenceStatusSchema, type FilePatch, FilePatchSchema, type GateAssessment, type GateConfig, type GateConfigInput, GateConfigSchema, type GateExecutionResult, type GateState, type IgnoredFinding, JurisdictionCodeSchema, LICENSE_CONTACT, type LeakReport, LeakReportSchema, PrivacyChaosGate, type PullRequestResult, PullRequestResultSchema, RemediationEngine, type RemediationEngineInterface, type RemediationResult, RemediationResultSchema, type ReportFacts, type ReportGate, type RequestEvent, RequestEventSchema, type ReviewVerdict, ReviewVerdictSchema, type SamplingInfo, type StorageSnapshot, StorageSnapshotSchema, type TrackerCategory, TrackerCategorySchema, type TrackerViolation, TrackerViolationSchema, assessReport, buildCoverHtml, buildEvidenceHtml, buildEvidenceMarkdown, checkTargetReachable, codeSolutionsFor, deriveReportFacts, evidenceLabelOf, findingsCountText, gateNotesOf, groupFindings, isEnvKeyAllowedFromFile, isLoopbackTarget, licenseSkipText, loadProjectEnv, parseGateConfig, problemsTextOf, renderDeluxeCombined, renderDeluxePdf, reproductionText, requestedLicensedFeatures, resolveEntitlement, resolveGateConfig, resolveReportGate, runGate, statusLabelOf, uncheckableReasons };