# Befehle

Jeder lockpick-Befehl und seine Optionen, direkt aus der CLI erzeugt.

{/* Generated by scripts/docs-generate.mts. Do not edit; run `pnpm docs:generate`. */}

Lockpick aus deinem Terminal: schnelle Prüfungen, Sites, Status, Befunde, Reparaturbriefe, Pulse-Scans, Deep-Scans, die du freigibst, und Neuprüfungen für dich und deine Coding-Agenten.

Führe `lockpick <command> --help` aus, um dieselben Optionen in deinem Terminal zu sehen. Jeder Befehl akzeptiert außerdem `--host` und `--json`.

## lockpick login

Im Browser anmelden und einen Schlüssel für einen Workspace speichern

```bash title="Aufruf"
lockpick login [options]
```

| Argument       | Was er macht                                                                                                                   |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `--no-browser` | Den Anmeldelink ausgeben, ohne den Browser zu öffnen                                                                           |
| `--pulse`      | Erneut um Erlaubnis bitten, Pulse-Scans, Schnellchecks und kostenlose DNS-Prüfungen zu starten (du setzt den Haken im Browser) |
| `--sites`      | Um Erlaubnis bitten, Sites hinzuzufügen und deine kostenlose Site zu wechseln (du setzt den Haken im Browser)                  |
| `--deep`       | Um Erlaubnis bitten, Deep-Scans vorzubereiten, die du in Lockpick freigibst (du setzt den Haken im Browser)                    |
| `--local`      | Berechtigung für lokale Prüfungen anfordern                                                                                    |

## lockpick logout

Den Schlüssel dieses Terminals widerrufen und vergessen

```bash title="Aufruf"
lockpick logout
```

## lockpick whoami

Den Benutzer, den Workspace und den Schlüssel anzeigen, die dieses Terminal verwendet

```bash title="Aufruf"
lockpick whoami
```

## lockpick doctor

CLI, Host, Verbindung, Authentifizierung und Workspace-Zugriff prüfen, ohne einen Scan zu starten

```bash title="Aufruf"
lockpick doctor [options]
```

| Argument          | Was er macht                                        |
| ----------------- | --------------------------------------------------- |
| `--scope <value>` | Zu prüfender Bereich: pulse, sites, deep oder local |

## lockpick projects

Projekte mit ihren letzten Pulse- und Deep-Scans auflisten

```bash title="Aufruf"
lockpick projects
```

## lockpick status

Statusbericht für ein Projekt (oder eine Übersicht aller Projekte)

```bash title="Aufruf"
lockpick status [project]
```

| Argument    | Was er macht         |
| ----------- | -------------------- |
| `<project>` | Projekt-ID oder Name |

## lockpick sites

Sites auflisten, eine mit `lockpick sites add \<url\>` hinzufügen oder den kostenlosen Pulse mit `lockpick sites switch \<siteId\> --yes` verschieben

```bash title="Aufruf"
lockpick sites
```

## lockpick sites add

Eine Site hinzufügen, die dir gehört oder die du testen darfst (benötigt einen Schlüssel, der Sites hinzufügen darf). Das Hinzufügen scannt sie nicht.

```bash title="Aufruf"
lockpick sites add <url> [options]
```

| Argument         | Was er macht                                                       |
| ---------------- | ------------------------------------------------------------------ |
| `<url>`          | Site-Adresse, z. B. [https://atlas.example](https://atlas.example) |
| `--name <value>` | Name, der in Lockpick angezeigt wird                               |

## lockpick sites switch

Die Site entfernen, die den kostenlosen Pulse dieses Monats belegt, damit eine andere Site ihn nutzen kann (benötigt einen Schlüssel, der Sites hinzufügen und Pulse starten darf). Mit --check startet der Befehl zusätzlich einen Pulse auf der Site dieses Schnellchecks und verbraucht dabei einen kostenlosen Pulse.

```bash title="Aufruf"
lockpick sites switch <site> [options]
```

| Argument          | Was er macht                                                                                                 |
| ----------------- | ------------------------------------------------------------------------------------------------------------ |
| `<site>`          | ID der Site zum Entfernen (aus `lockpick sites`)                                                             |
| `--check <value>` | Schnellcheck-ID der neuen Site. Ihr Pulse startet mit dem Wechsel                                            |
| `--yes`           | Das Entfernen bestätigen. Die Site wird nicht mehr überwacht, kann in Lockpick aber wiederhergestellt werden |

## lockpick runs

Pulse- und Deep-Scans auflisten, neueste zuerst

```bash title="Aufruf"
lockpick runs [options]
```

| Argument            | Was er macht                                                                      |
| ------------------- | --------------------------------------------------------------------------------- |
| `--project <value>` | Projekt-ID oder Name                                                              |
| `--kind <value>`    | pulse \| box                                                                      |
| `--status <value>`  | queued \| running \| cancelling \| succeeded \| incomplete \| failed \| cancelled |
| `--limit <value>`   | Wie viele (Standard 20, maximal 100)                                              |

## lockpick run

Einen Lauf anzeigen

```bash title="Aufruf"
lockpick run <runId>
```

| Argument  | Was er macht |
| --------- | ------------ |
| `<runId>` | Lauf-ID      |

## lockpick watch

Einem Lauf folgen, bis er endet (Exit-Code 3, außer er ist erfolgreich)

```bash title="Aufruf"
lockpick watch <runId> [options]
```

| Argument             | Was er macht                                                                                                       |
| -------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `<runId>`            | Lauf-ID                                                                                                            |
| `--fail-on <value>`  | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI) |
| `--interval <value>` | Sekunden zwischen den Prüfungen (Standard 5, steigt bis auf 30)                                                    |
| `--timeout <value>`  | Maximale Wartezeit in Sekunden (Standard 600, maximal 3600)                                                        |

## lockpick pulse

Einen Pulse-Scan für ein Projekt starten und auf das Ergebnis warten (benötigt einen Schlüssel, der Pulse-Scans starten darf)

```bash title="Aufruf"
lockpick pulse <project> [options]
```

| Argument             | Was er macht                                                                                                                                   |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `<project>`          | Projekt-ID oder Name                                                                                                                           |
| `--no-wait`          | Sofort zurückkehren, sobald der Scan startet, ohne auf das Ergebnis zu warten                                                                  |
| `--interval <value>` | Sekunden zwischen den Prüfungen beim Warten (Standard 5)                                                                                       |
| `--timeout <value>`  | Maximale Wartezeit in Sekunden (Standard 600, maximal 3600)                                                                                    |
| `--fail-on <value>`  | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI)                             |
| `--lockfile`         | Die Paketnamen und Versionen dieses Ordners für diesen Lauf senden (oder mit --no-lockfile nie senden). Sonst fragt Lockpick einmal pro Ordner |

## lockpick recheck

Vollständige Neuprüfung einer Site: ein neuer Pulse, der einen Pulse-Scan aus dem Kontingent verbraucht. Mit --dns \<findingId> wird ein Befund eines Scans kostenlos per DNS erneut geprüft. Die Note ändert sich dabei nie.

```bash title="Aufruf"
lockpick recheck <target> [options]
```

| Argument             | Was er macht                                                                                                                                   |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `<target>`           | Site-ID oder Name. Mit --dns die Scan-ID                                                                                                       |
| `--dns <value>`      | Befund-ID, die kostenlos anhand öffentlicher DNS-Einträge erneut geprüft wird (kontaktiert die Site nie)                                       |
| `--no-wait`          | Sofort zurückkehren, sobald der Scan startet, ohne auf das Ergebnis zu warten                                                                  |
| `--interval <value>` | Sekunden zwischen den Prüfungen beim Warten (Standard 5)                                                                                       |
| `--timeout <value>`  | Maximale Wartezeit in Sekunden (Standard 600, maximal 3600)                                                                                    |
| `--fail-on <value>`  | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI)                             |
| `--lockfile`         | Die Paketnamen und Versionen dieses Ordners für diesen Lauf senden (oder mit --no-lockfile nie senden). Sonst fragt Lockpick einmal pro Ordner |

## lockpick deps

Die Paketnamen und genauen Versionen dieses Projekts (nie Code) an eine Site senden und die Sicherheitshinweise auflisten, die sie betreffen. Liest package-lock.json, npm-shrinkwrap.json, pnpm-lock.yaml, yarn.lock, requirements.txt und poetry.lock (benötigt einen Schlüssel, der Sites verwalten darf).

```bash title="Aufruf"
lockpick deps <site> [options]
```

| Argument                 | Was er macht                                                                                           |
| ------------------------ | ------------------------------------------------------------------------------------------------------ |
| `<site>`                 | Site-ID oder Name                                                                                      |
| `--path <value>`         | Projektordner mit den Lockfiles (Standard: dieser Ordner)                                              |
| `--completeness <value>` | complete, partial oder unknown (Standard unknown. complete nur für ein vollständiges Inventar angeben) |
| `--revision <value>`     | Optionale Quellrevision. Sie belegt keine Bereitstellung                                               |
| `--environment <value>`  | production, staging, development oder unknown                                                          |
| `--dry-run`              | Nur ausgeben, was gesendet würde                                                                       |
| `--forget`               | Die Paketliste der Site in Lockpick vergessen                                                          |

## lockpick monitor

Aktuelle Sicherheitshinweise und Treffer für Sites durchsuchen, die du lesen darfst.

```bash title="Aufruf"
lockpick monitor [options]
```

| Argument              | Was er macht                                   |
| --------------------- | ---------------------------------------------- |
| `--site <value>`      | Auf eine Site-ID oder einen Namen filtern      |
| `--query <value>`     | Hinweis-IDs, Titel oder Paketnamen durchsuchen |
| `--ecosystem <value>` | all, npm, pypi, composer oder wordpress        |
| `--kind <value>`      | all, vulnerability oder malicious_package      |
| `--view <value>`      | latest, sites, exploited oder following        |
| `--severity <value>`  | all, critical, high, medium, low oder unknown  |
| `--days <value>`      | 7, 30, 90, 365 oder 0 für die gesamte Historie |
| `--cursor <value>`    | Nächster Cursor aus einer vorherigen Antwort   |
| `--advisory <value>`  | Eine Hinweis-ID lesen                          |

## lockpick check

Kostenloser Schnellcheck einer Website (Startseite und öffentliches DNS) oder eines öffentlichen GitHub-Repositorys, bevor Sie es installieren: ein Skill, ein Plugin, ein MCP-Server oder eine App (benötigt einen Schlüssel, der Pulse-Scans starten darf)

```bash title="Aufruf"
lockpick check <url> [options]
```

| Argument            | Was er macht                                                                                                                                                                                                                               |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `<url>`             | Website-Adresse (atlas.example) oder GitHub-Repository (github.com/owner/repo, owner/repo)                                                                                                                                                 |
| `--no-wait`         | Sofort zurückkehren, sobald der Scan startet, ohne auf das Ergebnis zu warten                                                                                                                                                              |
| `--timeout <value>` | Maximale Wartezeit in Sekunden (Standard 90, maximal 3600)                                                                                                                                                                                 |
| `--deep`            | Für ein GitHub-Repository: eine Deep-Prüfung des Repositorys. Sie liest zusätzlich jede Lockfile und die letzten 50 Commits auf geleakte Schlüssel, mit einer gründlicheren Prüfung. Braucht den Deep-Plan und verbraucht einen Deep-Scan. |

## lockpick verify

Einmal bestätigen, dass dir eine Site gehört. Gibt den Wert der Site und den Ort aus, an dem du ihn veröffentlichst. --wait sucht danach (benötigt einen Schlüssel, der Deep-Scans vorbereiten darf)

```bash title="Aufruf"
lockpick verify <site> [options]
```

| Argument           | Was er macht                                                                     |
| ------------------ | -------------------------------------------------------------------------------- |
| `<site>`           | Site-ID oder Name                                                                |
| `--method <value>` | dns (Standard), file oder meta (ein Tag im Head der Startseite). Standard `dns`. |
| `--wait`           | Etwa fünf Minuten lang danach suchen (nutzt die Prüfungen des Nachweises)        |

## lockpick deep local

Deterministische lokale Repository-Prüfungen nach Projektfreigabe ausführen

```bash title="Aufruf"
lockpick deep local <path> [options]
```

| Argument                      | Was er macht                                                                                                        |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `<path>`                      | Physischer Repository-Pfad (pwd -P); keine Symlink-Wurzeln                                                          |
| `--project <value>`           | Projekt-ID oder eindeutiger Name                                                                                    |
| `--browser-artifacts <value>` | Verzeichnis der Browser-Artefakte relativ zum Repository; mehrfach verwendbar                                       |
| `--env-file <value>`          | Explizite Umgebungsdatei relativ zum Repository; mehrfach verwendbar                                                |
| `--dockerfile <value>`        | Dockerfile-Pfad relativ zum Repository; wiederholbar                                                                |
| `--migration-file <value>`    | SQL-Migrationsdatei relativ zum Repository; in Ausführungsreihenfolge wiederholen                                   |
| `--build-context <value>`     | Build-Kontext relativ zum Repository; in gleicher Reihenfolge mit --dockerfile angeben (. für das Stammverzeichnis) |
| `--checks <value>`            | Kommagetrennte Prüfungs-IDs; angeforderte nicht unterstützte Prüfungen bleiben unvollständig                        |
| `--history`                   | Begrenzte Prüfung des Git-Verlaufs einschließen                                                                     |
| `--source-maps`               | Eingebettete Quellen in angegebenen Browser-Source-Maps prüfen                                                      |
| `--fail-on <value>`           | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI)  |

## lockpick deep verify

Einen Eigentumsnachweis für einen Deep-Scan starten: ein DNS-TXT-Eintrag, eine Datei oder ein Meta-Tag im Head der Startseite, das du veröffentlichst (benötigt einen Schlüssel, der Deep-Scans vorbereiten darf)

```bash title="Aufruf"
lockpick deep verify <site> [options]
```

| Argument           | Was er macht                                                                     |
| ------------------ | -------------------------------------------------------------------------------- |
| `<site>`           | Site-ID oder Name                                                                |
| `--method <value>` | dns (Standard), file oder meta (ein Tag im Head der Startseite). Standard `dns`. |
| `--wait`           | Etwa fünf Minuten lang danach suchen (nutzt die Prüfungen des Nachweises)        |

## lockpick deep check

Einmal nach einem veröffentlichten Eigentumsnachweis suchen (jede Prüfung verbraucht einen seiner Versuche)

```bash title="Aufruf"
lockpick deep check <site> <verificationId>
```

| Argument           | Was er macht                    |
| ------------------ | ------------------------------- |
| `<site>`           | Site-ID oder Name               |
| `<verificationId>` | Die ID aus lockpick deep verify |

## lockpick deep prepare

Einen Deep-Scan mit einem bestätigten Nachweis vorbereiten und seine Freigabeseite öffnen. Nichts startet, bis du es in Lockpick freigibst

```bash title="Aufruf"
lockpick deep prepare <site> <verificationId> [options]
```

| Argument           | Was er macht                                          |
| ------------------ | ----------------------------------------------------- |
| `<site>`           | Site-ID oder Name                                     |
| `<verificationId>` | Die ID des bestätigten Nachweises                     |
| `--no-browser`     | Den Freigabelink ausgeben, ohne den Browser zu öffnen |

## lockpick deep start

Einen Deep-Scan starten, den du in Lockpick freigegeben hast, und auf ihn warten (ein Deep-Scan aus dem Kontingent, wie beim Vorbereiten angezeigt)

```bash title="Aufruf"
lockpick deep start <operationId> [options]
```

| Argument             | Was er macht                                                                                                       |
| -------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `<operationId>`      | Die ID aus lockpick deep prepare                                                                                   |
| `--no-wait`          | Sofort zurückkehren, sobald der Scan startet, ohne auf das Ergebnis zu warten                                      |
| `--interval <value>` | Sekunden zwischen den Prüfungen beim Warten (Standard 5)                                                           |
| `--timeout <value>`  | Maximale Wartezeit in Sekunden (Standard 600, maximal 3600)                                                        |
| `--fail-on <value>`  | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI) |

## lockpick findings

Befunde eines Laufs, die Aufmerksamkeit brauchen

```bash title="Aufruf"
lockpick findings <runId> [options]
```

| Argument             | Was er macht                                                                                                       |
| -------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `<runId>`            | Lauf-ID                                                                                                            |
| `--severity <value>` | critical \| high \| medium \| low \| info                                                                          |
| `--all`              | Bestandene und nicht bewertete Prüfungen einschließen                                                              |
| `--fail-on <value>`  | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI) |

## lockpick report

Eine bestehende Bewertung und ihre bereinigten Befunde als Markdown oder JSON exportieren

```bash title="Aufruf"
lockpick report <runId> [options]
```

| Argument        | Was er macht                                                                 |
| --------------- | ---------------------------------------------------------------------------- |
| `<runId>`       | Lauf-ID                                                                      |
| `--out <value>` | Eine neue Berichtsdatei anlegen. Bestehende Dateien werden nie überschrieben |

## lockpick finding

Einen Befund mit seinen Nachweisen anzeigen

```bash title="Aufruf"
lockpick finding <runId> <findingId>
```

| Argument      | Was er macht               |
| ------------- | -------------------------- |
| `<runId>`     | Lauf-ID                    |
| `<findingId>` | Befund-ID oder ihr LP-Code |

## lockpick brief

Markdown-Reparaturbrief, der alles in einem Lauf behebt, das Aufmerksamkeit braucht (oder einen einzelnen Befund)

```bash title="Aufruf"
lockpick brief <runId> [options]
```

| Argument            | Was er macht                                                                                         |
| ------------------- | ---------------------------------------------------------------------------------------------------- |
| `<runId>`           | Lauf-ID                                                                                              |
| `--finding <value>` | Nur dieser Befund                                                                                    |
| `--agent <value>`   | Für diesen Agenten anpassen: claude-code, codex, cursor, vscode, opencode, lovable, bolt, replit, v0 |
| `--out <value>`     | Das Markdown in diese Datei schreiben                                                                |

## lockpick fix

Den Reparaturbrief für alle Befunde in lockpick-fixes.md speichern und den Befehl ausgeben, der deinen Agenten damit startet

```bash title="Aufruf"
lockpick fix <runId> [options]
```

| Argument          | Was er macht                                                                                         |
| ----------------- | ---------------------------------------------------------------------------------------------------- |
| `<runId>`         | Lauf-ID                                                                                              |
| `--agent <value>` | Für diesen Agenten anpassen: claude-code, codex, cursor, vscode, opencode, lovable, bolt, replit, v0 |
| `--out <value>`   | Wo der Brief gespeichert wird (Standard: lockpick-fixes.md)                                          |

## lockpick compare

Eine Pulse-Neuprüfung mit ihrer Ausgangsbasis vergleichen

```bash title="Aufruf"
lockpick compare <runId>
```

| Argument  | Was er macht           |
| --------- | ---------------------- |
| `<runId>` | Lauf-ID der Neuprüfung |

## lockpick import

Eine findings.json- oder SARIF-Datei von Codex Security lesen und sie auf deinem Rechner mit einem Lauf abgleichen

```bash title="Aufruf"
lockpick import <file> [options]
```

| Argument        | Was er macht                                                                                                    |
| --------------- | --------------------------------------------------------------------------------------------------------------- |
| `<file>`        | Pfad zu findings.json oder zu einer SARIF-2.1.0-Datei                                                           |
| `--run <value>` | Mit dieser Lauf-ID abgleichen (weglassen, um die Datei nur zu lesen)                                            |
| `--upload`      | Die minimalen Abgleichsschlüssel (Routenpfade, Regel-IDs, Schweregrade) zum Teilen erstellen. Standardmäßig aus |

## lockpick open

Einen Lauf oder ein Projekt im Browser öffnen

```bash title="Aufruf"
lockpick open <id>
```

| Argument | Was er macht                         |
| -------- | ------------------------------------ |
| `<id>`   | Lauf-ID, Projekt-ID oder Projektname |

## lockpick mcp

Den MCP-Server über stdio für einen Coding-Agenten starten

```bash title="Aufruf"
lockpick mcp [options]
```

| Argument               | Was er macht                                                  |
| ---------------------- | ------------------------------------------------------------- |
| `--local-root <value>` | Absolutes Stammverzeichnis für lokale MCP-Scans; wiederholbar |

## lockpick mcp config

MCP-Einrichtung für claude, cursor, vscode oder codex ausgeben

```bash title="Aufruf"
lockpick mcp config <client> [options]
```

| Argument               | Was er macht                                                                              |
| ---------------------- | ----------------------------------------------------------------------------------------- |
| `<client>`             | claude \| cursor \| vscode \| codex                                                       |
| `--local-root <value>` | Absolutes Stammverzeichnis für lokale MCP-Scans; wiederholbar                             |
| `--hosted`             | Den gehosteten OAuth-Connector statt des lokalen stdio-Servers verwenden                  |
| `--apply`              | In eine Cursor-, VS-Code- oder Codex-Konfiguration einfügen, mit einer privaten Sicherung |
| `--file <value>`       | Konfigurationsdatei, die mit --apply aktualisiert wird (Standard: der übliche Ort)        |

## lockpick mcp rollback

Eine Sicherung der Lockpick-MCP-Konfiguration wiederherstellen, wenn sie seit der Einrichtung nicht geändert wurde

```bash title="Aufruf"
lockpick mcp rollback <backup>
```

| Argument   | Was er macht                                   |
| ---------- | ---------------------------------------------- |
| `<backup>` | Sicherungspfad, den mcp config --apply ausgibt |

## lockpick skills

Die Lockpick-Skills zu deinem Coding-Agenten hinzufügen (npx skills add promptadvisers/lockpick-skills)

```bash title="Aufruf"
lockpick skills [options]
```

| Argument          | Was er macht                                                                             |
| ----------------- | ---------------------------------------------------------------------------------------- |
| `--agent <value>` | Agenten, zu denen sie hinzugefügt werden, z. B. claude-code,codex (Standard: nachfragen) |
| `--global`        | Für dein Benutzerkonto statt für dieses Projekt hinzufügen                               |

## lockpick docs

Die Lockpick-Dokumentation im Terminal durchsuchen oder die CLI-Anleitungen auflisten (--open öffnet den ersten Treffer)

```bash title="Aufruf"
lockpick docs [query] [options]
```

| Argument  | Was er macht                                                  |
| --------- | ------------------------------------------------------------- |
| `<query>` | Wonach gesucht wird, z. B. „eine fehlende CSP beheben“        |
| `--open`  | Den besten Treffer (oder die CLI-Anleitung) im Browser öffnen |

## lockpick ci init

Einen GitHub-Actions-Workflow (.github/workflows/lockpick.yml) schreiben, der bei jedem Release einen Pulse-Scan startet und bei schwerwiegenden Befunden fehlschlägt

```bash title="Aufruf"
lockpick ci init <site> [options]
```

| Argument            | Was er macht                                                                                                                              |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `<site>`            | Site-ID oder Name, die geprüft werden soll                                                                                                |
| `--fail-on <value>` | Den Workflow bei diesem Schweregrad oder einem höheren fehlschlagen lassen: critical, high, medium, low (Standard high). Standard `high`. |
| `--file <value>`    | Wo er geschrieben wird (Standard .github/workflows/lockpick.yml)                                                                          |
| `--action`          | Die Lockpick-GitHub-Action statt der CLI über npx verwenden (Vorschau)                                                                    |
| `--force`           | Eine bestehende Workflow-Datei ersetzen                                                                                                   |
| `--dry-run`         | Den Workflow ausgeben, statt ihn zu schreiben                                                                                             |

## lockpick ci check

Eine bestehende Bewertung prüfen, ohne einen Scan zu starten oder Kontingent zu verbrauchen

```bash title="Aufruf"
lockpick ci check <runId> [options]
```

| Argument                  | Was er macht                                                                                                       |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `<runId>`                 | Genau die Lauf-ID, die bewertet werden soll                                                                        |
| `--max-age-hours <value>` | Maximales Alter seit Abschluss in Stunden (optional)                                                               |
| `--min-coverage <value>`  | Mindestabdeckung in Prozent laut Bericht. Unbekannt schlägt fehl (optional)                                        |
| `--fail-on <value>`       | Exit-Code 8, wenn offene Befunde diesen Schweregrad oder einen höheren haben: critical, high, medium, low (für CI) |