# GitHub Copilot CLI-Befehlsreferenz Hier finden Sie Befehle und Tastenkombinationen, um Copilot CLI effektiv zu nutzen. ## Kommandozeilenbefehle | Befehl | Purpose | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `copilot` | Starten Sie die interaktive Benutzeroberfläche. | | `copilot app` | Öffnen Sie das GitHub Copilot app im aktuellen Verzeichnis mit einem Deep-Link direkt zu einer neuen Sitzung. Greift auf das Öffnen der Downloadseite der App in einem Browser zurück, wenn der Deep-Link nicht verarbeitet werden kann, oder druckt die URL, um manuell zu öffnen, wenn kein Browser verfügbar ist. | | `copilot completion SHELL` | Erstellen Sie ein Shellskript für die ausgewählte Shell, das zur Aktivierung der Tab-Vervollständigung für Copilot CLI verwendet werden kann. Unterstützte Shells: `bash`, `zsh`, `fish`. Siehe [Verwendung von `copilot completion`](#using-copilot-completion). | | `copilot config [KEY] [VALUE]` | Lesen oder Ändern der Copilot-Einstellungen über die Befehlszeile außerhalb einer interaktiven Sitzung. Siehe [Verwendung von `copilot config`](#using-copilot-config). | | `copilot help [TOPIC]` | Hilfeinformationen anzeigen. Hilfethemen umfassen: `billing`, , `config`, `commands`, `environment`, `logging`, `monitoring`, `permissions`, , `providers`und `sandbox`. | | `copilot init` | Initialisieren Sie Copilot benutzerdefinierte Anweisungen für dieses Repository. | | `copilot login [OPTION]` | Mit Copilot über OAuth authentifizieren. Weitere Informationen finden Sie [`copilot login` unter "Optionen](#copilot-login-options)". | | `copilot mcp` | Verwalten Sie MCP-Serverkonfigurationen über die Befehlszeile. | | `copilot memories import FILE` | Importieren Sie vorbereitete Memories aus einer JSONL-Datei. Siehe [„Erinnerungen importieren“](#importing-memories). | | `copilot plugin` | Verwalten Sie Plug-ins und Plug-in-Marktplätze, einschließlich des Auflistens, Aktivierens, Deaktivierens und Deinstallierens von Plug-ins und Plug-in-Marktplätzen. | | `copilot plugins` (Plural) ist ein veralteter Alias. Siehe [GitHub Copilot CLI-Plug-In-Referenz](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference). | | | `copilot instruction` | Nicht interaktiv benutzerdefinierte Anweisungsquellen auflisten, die für das aktuelle Arbeitsverzeichnis gefunden wurden. Siehe [Verwendung von `copilot instruction`](#using-copilot-instruction). | | `copilot lsp` | Konfigurierte Sprachserver nicht interaktiv auflisten. Siehe [Verwendung von `copilot lsp`](#using-copilot-lsp). | | `copilot sandbox ca` | Verwalten Sie die Proxyzertifizierungsstelle des Sandkastens von außerhalb einer interaktiven Sitzung. Siehe [Verwendung von `copilot sandbox ca`](#using-copilot-sandbox-ca). | | `copilot skill` | Verwalten von Agent-Fähigkeiten über die Befehlszeile (Liste, Hinzufügen, Entfernen, Aktivieren und Deaktivieren von Fähigkeiten). Siehe [Verwalten von Fähigkeiten, die nicht interaktiv sind](#managing-skills-non-interactively). | | `copilot update` | Laden Sie die neueste Version herunter, und installieren Sie sie. Informationen zur Verwendung einer bestimmten Version finden Sie unter "Anheften der CLI-Version" in [Programmgesteuerte Referenz für die GitHub Copilot-CLI](/de/copilot/reference/copilot-cli-reference/cli-programmatic-reference#pinning-the-cli-version). | | `copilot version` | Zeigen Sie Versionsinformationen an, und suchen Sie nach Updates. | | `copilot workflow run WORKFLOW-NAME` | Führen Sie einen vorhandenen dynamischen Workflow direkt aus, ohne eine Chataufforderung zu senden. Wartet, bis die Ausführung beendet oder beendet wird. Siehe [Verwendung von `copilot workflow run`](#using-copilot-workflow-run). | ### `copilot login`-Optionen | Auswahl | Purpose | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `--host HOST` | | | GitHub Host-URL (Standard: `https://github.com`). Verwenden Sie diese Methode, um sich mit einer GitHub Enterprise Cloud Instanz zu authentifizieren, die die Datenresidenz verwendet (z. B. `https://example.ghe.com`). | | | `--web-flow` | Erzwingen Sie den browserbasierten (Web)-Authentifizierungsfluss, der die Standardeinstellung für ein lokales Terminal ist. | | `--device-code` | Erzwingen Sie den OAuth-Gerätecodefluss, der die Standardeinstellung auf einem Remoteterminal oder in CI ist. | | `--with-token` | Lesen Sie ein Authentifizierungstoken aus der Standardeingabe, anstatt einen OAuth-Fluss zu starten. Aufforderungen ohne Echoeingabe, wenn die Standardeingabe ein Terminal ist. Konflikte mit `--web-flow` und `--device-code`. | Auf einem lokalen Terminal oder einem nicht TTY-lokalen Prozess, der weiterhin einen Browser erreichen kann (z. B. ein Desktopbetriebssystem oder Linux mit Anzeige oder Browsersignal), ist der Standardauthentifizierungsmodus ein browserbasierter Webfluss: Die CLI öffnet Ihren Browser zur Autorisierung und erfasst dann das Ergebnis in einem lokalen Loopbackrückruf. Auf einem Remoteterminal (z. B. SSH, GitHub Codespacesoder einem Entwicklungscontainer) oder in CI verwendet die CLI stattdessen den OAuth-Gerätecodefluss, da der Browser normalerweise den Loopbackport nicht erreichen kann. Verwenden Sie `--web-flow` oder `--device-code`, um den automatisch ausgewählten Ablauf zu überschreiben. Nach Abschluss wird ein Authentifizierungstoken sicher im Systemanmeldeinformationsspeicher gespeichert. Wenn ein Anmeldeinformationsspeicher nicht gefunden wird, wird das Token in einer Nur-Text-Konfigurationsdatei unter `~/.copilot/` (oder dem verzeichnis gespeichert, das durch `COPILOT_HOME` festgelegt wird). Alternativ wird ein Authentifizierungstoken verwendet, Copilot CLI das in Umgebungsvariablen zu finden ist. Die folgenden Punkte werden in der Reihenfolge der Rangfolge überprüft: `COPILOT_GITHUB_TOKEN`, `GH_TOKEN`, `GITHUB_TOKEN`. Diese Methode eignet sich am besten für kopflose Verwendung wie Automatisierung. Unterstützte Tokentypen sind fine-grained personal access tokens (v2 PATs) mit der Berechtigung "Copilot Requests", OAuth-Token aus der Copilot CLI-App und OAuth-Token aus der GitHub CLI (`gh`) App. Klassische personal access tokens (`ghp_`) werden nicht unterstützt. **Beispiele:** ```shell # Authenticate with github.com copilot login # Authenticate with GitHub Enterprise Cloud (data residency) copilot login --host https://example.ghe.com # Force the device code flow, for example on a remote terminal copilot login --device-code # Force the browser (web) flow, for example on a local terminal copilot login --web-flow # Read a token from standard input, bypassing the OAuth flow entirely copilot login --with-token < mytoken.txt # Use a fine-grained PAT via environment variable COPILOT_GITHUB_TOKEN=github_pat_... copilot ``` ### Verwenden von `copilot completion` Der Befehl `copilot completion SHELL` gibt ein Skript für die angegebene Shell aus (Bash, zsh oder Fisch). Durch das Laden dieses Skripts (oder Speichern im Vervollständigungs-Verzeichnis Ihrer Shell) können Sie die Registerkarte Vervollständigung in Ihrem Terminal für `copilot` Unterbefehle, Befehlsoptionen und bekannte Werte für Befehlsoptionen aktivieren. Für `copilot config` umfasst die Vervollständigung auch das Festlegen von Schlüsseln, booleschen und Enumerationswerten sowie Dateien oder Verzeichnissen für Pfadeinstellungen. #### Verwendungsbeispiele Bash (nur aktuelle Sitzung): ```bash copy source <(copilot completion bash) ``` Bash (dauerhaft, Linux): ```bash copy copilot completion bash | sudo tee /etc/bash_completion.d/copilot ``` Zsh – Schreiben Sie die Ausgabe in ein Verzeichnis in Ihrem $fpath. Starten Sie die Shell neu, nachdem Sie diesen Befehl ausgeführt haben: ```shell copy copilot completion zsh > "${fpath[1]}/_copilot" ``` Fisch: ```shell copy copilot completion fish > ~/.config/fish/completions/copilot.fish ``` ### Nicht interaktives Verwalten von Plug-Ins Verwenden Sie `copilot plugin`, um Plug-ins über die Befehlszeile zu installieren, aufzulisten, zu aktualisieren, zu aktivieren, zu deaktivieren und zu deinstallieren, ohne eine interaktive Sitzung zu öffnen. `copilot plugins` (plural) ist ein Legacyalias für denselben Befehl. Die vollständige Befehls- und Optionsreferenz finden Sie unter [GitHub Copilot CLI-Plug-In-Referenz](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference). ### Verwenden von `copilot config` Führen Sie `copilot config` aus, um Copilot-Einstellungen über die Befehlszeile außerhalb einer interaktiven Sitzung zu lesen und zu ändern. Dies ist das nicht interaktive Gegenstück zum `/settings` (oder `/config`) Schrägstrichbefehl. Weitere Informationen zur Einstellungsdatei und den zugehörigen Schlüsseln finden Sie unter [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#settingsjson). ```bash # Print a setting copilot config theme # Set a nested value (dot notation) copilot config footer.showQuota off # Append an item to a list setting (added only if not already present) copilot config allowedUrls github.com # Append an item that starts with a dash copilot config powershellFlags -- -NoProfile # Remove a key, or one list item copilot config --rm theme copilot config --rm allowedUrls github.com # List settings as key=value lines, or as JSON copilot config --list copilot config --repo --list --json ``` | Option/Argument | Beschreibung | | --------------- | ------------------------------------------------------------------------------------------------------------- | | `KEY` | Festlegen des Schlüssels in Punktnotation (z. B. `footer.showQuota`). | | `VALUE` | Wert zum Festlegen, Anfügen oder Entfernen aus einer Liste mit `--rm`. | | `--list` | Einstellungen als `key=value`-Zeilen auflisten; Konflikte mit `--rm``KEY``VALUE`//. | | `--json` | Geben Sie `--list` als JSON aus; `--list` ist erforderlich. | | `--rm` | Entfernen Sie den Schlüsselwert oder nur das angegebene Element aus einer Liste; erfordert `KEY`. | | `--global` | Verwenden Sie Ihre Benutzereinstellungsdatei (Standardeinstellung); steht in Konflikt mit `--repo`/`--local`. | | `--repo` | Verwenden Sie das `.github/copilot/settings.json` des Repositorys; Konflikte mit /`--global``--local`. | | `--local` | Verwenden Sie das `.github/copilot/settings.local.json` des Repositorys; Konflikte mit /`--global``--repo`. | Werte müssen mit dem Typ der Einstellung übereinstimmen: `on`/`off` oder `true`/`false` für Booleane, eine Zahl für numerische Einstellungen oder eine akzeptierte Auswahl für Enumerationen. Beim Lesen einer Liste wird ein Element pro Zeile gedruckt; beim Lesen einer Gruppe wird JSON gedruckt. Ein nicht gesetzter Schlüssel beendet den Vorgang mit dem Status `1`. Geheime Werte werden in der Ausgabe geschwärzt. Befehle verwenden standardmäßig die Benutzereinstellungsdatei (`settings.json` in `~/.copilot`oder in `$COPILOT_HOME` , wenn sie festgelegt ist). `--repo` und `--local` akzeptieren nur die Einstellungen, die ein Repository außer Kraft setzen kann – siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#repository-settings-githubcopilotsettingsjson). Führen Sie `copilot help config` für die verfügbaren Einstellungen aus. ### Verwenden von `copilot instruction` Führen Sie `copilot instruction list` aus, um die für das aktuelle Arbeitsverzeichnis gefundenen benutzerdefinierten Anweisungsquellen nicht interaktiv aufzulisten. Dies ersetzt den eingestellten `copilot plugins list --kind instruction`. ```bash copilot instruction list copilot instruction list --json ``` | Auswahl | Beschreibung | | | ------------------------ | -------------------------------------------------------------------------------------------------------- | ----------------------------------------- | | `--json` | Geben Sie JSON anstelle von Text aus. | | | `--config-dir=DIRECTORY` | Pfad zum Konfigurationsverzeichnis. Diese Option ist veraltet. Verwenden Sie stattdessen `COPILOT_HOME`. | | Jeder `--json` Eintrag hat die Form `{ id, label, description?, location, type, sourcePath, defaultDisabled, applyTo? }`. Diese Auflistung gleicht von Plug-ins beigesteuerte Anweisungen nur mit Ihren globalen Benutzereinstellungen ab – eine Anweisung, die durch ein vertrauenswürdiges Repository oder durch verwaltete Einstellungen aktiviert wurde, wird hier möglicherweise nicht angezeigt, obwohl sie in einer aktiven Sitzung angewendet wird. ### Verwenden von `copilot lsp` Führen Sie `copilot lsp list` aus, um konfigurierte Sprachserver nicht-interaktiv aufzulisten. Dies ersetzt den eingestellten `copilot plugins list --kind lsp`. Dieser Befehl dient nur zur Inspektion; verwenden Sie den `/lsp` Slash-Befehl in einer interaktiven Sitzung, um einen Sprachserver zu starten, zu beenden oder neu zu laden. ```bash copilot lsp list copilot lsp list --json ``` | Auswahl | Beschreibung | | | ------------------------ | -------------------------------------------------------------------------------------------------------- | ----------------------------------------- | | `--json` | Geben Sie JSON anstelle von Text aus. | | | `--config-dir=DIRECTORY` | Pfad zum Konfigurationsverzeichnis. Diese Option ist veraltet. Verwenden Sie stattdessen `COPILOT_HOME`. | | Jeder `--json` Eintrag hat die Form `{ id, fileExtensions?, sourcePlugin? }`. Benutzerdefinierte Agenten und sitzungsgebundene Hooks werden nicht von `copilot instruction`, `copilot lsp`, `copilot plugin`, `copilot mcp` oder `copilot skill` abgedeckt. Alle erfordern eine Livesitzung. ### Erinnerungen importieren Verwenden Sie `copilot memories import`, um Einstellungen auf Benutzerebene und Fakten auf Repositoryebene aus einer JSONL-Datei zu überprüfen und zu importieren. ```shell copilot memories import PATH-TO-FILE ``` | Auswahl | Beschreibung | | --------------------------- | ----------------------------------------------------------------------------------------------------------------- | | `--dry-run` | Überprüfen Sie die vollständige Datei, ohne Memories zu authentifizieren oder zu übermitteln. | | `--on-conflict skip\|error` | Überspringen Sie widersprüchliche Datensätze, oder behandeln Sie sie als Fehler. Der Standardwert lautet `error`. | | `--output json` | Gibt das Importergebnis als JSON anstelle von lesbarem Text zurück. | Wenn eine Zeile die Schemaüberprüfung nicht besteht, werden keine Datensätze übermittelt. Nachdem die Überprüfung erfolgreich war, werden Datensätze einzeln übermittelt, sodass ein Dienstfehler zu einem teilweisen Import führen kann. Überprüfen Sie die Ergebnisse pro Datensatz, und wiederholen Sie nur fehlgeschlagene Datensätze. Die `--on-conflict skip` Option überspringt doppelte IDs innerhalb der Eingabedatei und Konflikte, die vom Speicherdienst gemeldet werden. Es garantiert nicht, dass das Wiederholen eines Imports doppelte Speicherungen verhindert. Informationen zum Dateiformat und zu den Beispielen finden Sie unter [Manuelles Erstellen von Memorys für GitHub Copilot](/de/copilot/how-tos/use-copilot-agents/copilot-memory/create-memories#importing-memories-with-copilot-cli). ### Verwenden von `copilot workflow run` Führen Sie einen dynamischen Workflow aus, der von einer Erweiterung bereitgestellt wird, ohne eine interaktive Sitzung zu öffnen: ```shell copy copilot workflow run WORKFLOW-NAME [OPTIONS] ``` `WORKFLOW-NAME` ist der von der Erweiterung registrierte Name, kein Pfad zu einer Erweiterungsdatei. Der Befehl startet eine Ausführung und wartet, bis er beendet, angehalten oder anderweitig beendet wird. | Auswahl | Beschreibung | | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `--args JSON` oder `--args @PATH` | Geben Sie die Eingaben des Workflows an. Ersetzen Sie hier "JSON" durch Inline-JSON, oder ersetzen Sie "PATH" durch den Pfad zu einer UTF-8 JSON-Datei. Wird standardmäßig auf `{}` festgelegt, wenn nichts angegeben wird. Die akzeptierten Eingaben hängen vom Workflow ab. | | `--result-file PATH` | Schreiben Sie den zurückgegebenen Wert als JSON in eine Datei, anstatt ihn in die Standardausgabe einzuschlussen. Nur geschrieben, wenn der Workflow abgeschlossen ist und ein Ergebnis zurückgibt. Eine vorhandene Datei wird erst ersetzt, nachdem das neue Ergebnis erfolgreich geschrieben wurde. | | `-s`, `--silent` | Statusausgabe unterdrücken. Das Endergebnis wird weiterhin ausgegeben, es sei denn, es wird an eine Datei weitergeleitet. Fehler- und Statusdiagnose werden möglicherweise weiterhin im Standardfehler angezeigt. | | `--output-format FORMAT` | Legen Sie das Standardausgabeformat auf `text` (Standard) oder `json` (JSONL, einen JSON-Eintrag pro Zeile) fest. Kombinieren Sie `json` mit `--silent`, um nur den endgültigen Workflow-Datensatz zu erhalten. Ändert nicht das JSON-Format von `--result-file`. | Relative Argumentdatei- und Ergebnisdateipfade werden aus dem Arbeitsverzeichnis aufgelöst. Die `--silent`Ausgabe enthält Phasen und Statusmeldungen, die vom Workflow gemeldet werden. Der Befehl verwendet die Authentifizierungs-, Modell-, Berechtigungs- und Sandkasteneinstellungen der CLI. Berechtigungsoptionen wie `--allow-tool` und `--allow-url` gelten für die Agenten des Workflows. Es werden keine Berechtigungsgenehmigungsaufforderungen angezeigt. Eingabeaufforderungs- und Sitzungsmodusoptionen können nicht mit diesem Befehl kombiniert werden. Beispiele sind `-p`, `-i`, `--agent`, `--fleet`, `--autopilot`, `--resume` und `--continue`. Über Pipe übergebene Standardeingabe wird weder als Prompt noch als Workflow-Argumente verwendet. Weitere Informationen findest du unter [Verwenden dynamischer Workflows](/de/copilot/how-tos/use-copilot-agents/use-dynamic-workflows#running-a-dynamic-workflow-from-the-command-line) und [Programmgesteuerte Referenz für die GitHub Copilot-CLI](/de/copilot/reference/copilot-cli-reference/cli-programmatic-reference#running-dynamic-workflows). ### Verwenden von `copilot sandbox ca` Führen Sie `copilot sandbox ca` aus, um die Proxyzertifizierungsstelle der Sandbox außerhalb einer interaktiven Sitzung zu verwalten, z. B. beim Bereitstellen verwalteter Geräte ohne TTY. Dies entspricht den `/sandbox ca` Schrägstrichbefehlen (`create`, `trust`, `rotate`, `remove`) sowie einer `status`-Überprüfung. ```bash copilot sandbox ca status copilot sandbox ca create copilot sandbox ca trust copilot sandbox ca rotate copilot sandbox ca remove ``` | Subcommand | Beschreibung | | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | `copilot sandbox ca status` | Melden Sie den Vertrauensstatus, ohne etwas zu ändern. | | `copilot sandbox ca create` | Erstellen Sie die Zertifizierungsstelle bei Bedarf, ohne ihr zu vertrauen. | | `copilot sandbox ca trust [CA.PEM]` | Fügen Sie die Zertifizierungsstelle (Standard: Ihre eigene) dem Betriebssystem-Vertrauensspeicher hinzu. | | `copilot sandbox ca rotate` | Ersetzen Sie die Zertifizierungsstelle, indem Sie ihren aktuellen Vertrauensstatus beibehalten. | | `copilot sandbox ca remove` | Entfernen Sie den Vertrauensanker aus dem Vertrauensspeicher des Betriebssystems; der bundlebasierte Pfad funktioniert weiterhin. | Führen Sie diese Befehle als der Benutzer aus, der Copilot CLI ausführt, nicht mit erhöhten Rechten, als `SYSTEM` oder als `root`, da die Zertifizierungsstelle im Home-Verzeichnis dieses Copilot CLI Benutzers gespeichert ist. Führen Sie `copilot sandbox ca trust --help` aus, um Anleitungen zur unbeaufsichtigten Einrichtung zu erhalten. `--config-dir` (oder `COPILOT_HOME`) zielt für diese Befehle auf ein nicht standardmäßiges Copilot CLI-Home-Verzeichnis ab, dasselbe wie im Rest der CLI. ## Die Seitenleiste der Sitzungen Die Sitzungsseitenleiste ist ein Bereich, der neben Ihrer aktuellen Konversation angedockt ist und über den Sie schnell mit Ihren lokalen GitHub Copilot CLI Sitzungen arbeiten können. Wenn die Randleiste den Fokus hat, stehen die folgenden Tastenkombinationen zur Verfügung. | Verknüpfung | Purpose | | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ← | Öffnen Sie in der Unterhaltung die Seitenleiste und verschieben Sie den Fokus in diese (Vim: `h`). | | → | Setzen Sie den Fokus wieder auf die Unterhaltung. drücken Sie erneut, um die Randleiste zu schließen (Vim: `l`). | | ↑/↓ | Wechseln Sie zwischen Sitzungen in der Seitenleiste (auch `k`/`j`). | | eingeben | Öffnen Sie die ausgewählte Sitzung und setzen Sie den Fokus wieder auf die Konversation. | | `n` | Starten Sie eine neue Sitzung. | | `x` zweimal | Schließen Sie die ausgewählte Sitzung. | | ↑ dann Tab | Am oberen Rand der Sitzungsliste wechselt ↑ zu den Schaltflächen in der Kopfzeile (**←** Seitenleiste schließen, **+** neue Sitzung). Die TAB-TASTE wechselt zwischen ihnen. | | `?` | Zeigen Sie die Hilfe in der Seitenleiste an. | Die Randleiste reagiert auch auf die Maus. | Geste | Purpose | | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------ | | Klicken Sie auf eine Sitzung | Wechseln Sie zu dieser Sitzung und kehren Sie zur Konversation zurück. | | Doppelklicken Sie auf eine Sitzung | Wechseln Sie zu dieser Sitzung, und bleiben Sie auf der Randleiste. | | Ziehen Sie die Trennlinie | Ändern Sie die Größe der Randleiste. | | Zeigen Sie auf die Randleiste, und scrollen Sie | Blättern Sie in der Sitzungsliste. | | Klicken Sie auf eine Schaltfläche in der Kopfzeile | | | **←** , um die Randleiste zu schließen, **+** um eine neue Sitzung zu starten. | | | Bewegen Sie den Mauszeiger über die rechte Seite einer Sitzung. | Schaltfläche "Schließen" anzeigen (erfordert `sidebar.showCloseButton`). | ### Sitzungsstatusindikatoren Jede Sitzung in der Randleiste zeigt einen Indikator für den aktuellen Zustand an. | Indikator | Bedeutung | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Grün `●` (stabil) | Die Sitzung ist im Leerlauf. Es wartet auf die nächste Eingabeaufforderung. | | Lila `●` (pulsierend) | Eine Drehung befindet sich im Flug. Der Agent arbeitet aktiv. | | Blau `●` (stabil) | Der Agent hat einen Schritt abgeschlossen, während Sie sich in einer anderen Sitzung befanden, und Sie haben ihn seitdem nicht mehr geöffnet. Wenn Sie die Sitzung öffnen, wird dieser ungelesene Zustand gelöscht. | | Gelb `●` (stabil) | Der Agent wurde aufgrund eines Fehlers angehalten oder benötigt anderweitig Ihre Aufmerksamkeit. | | Grau `○` (stabil) | Eine fortsetzungsfähige Sitzung. Es ist gespeichert, wird aber derzeit nicht ausgeführt. | | Gelb `!` | Die Sitzung benötigt die Berechtigung, um fortzufahren. | | Gelb `?` | Die Sitzung wartet darauf, dass Sie eine Frage beantworten oder eine Auswahl treffen. | Die obigen Farbnamen dienen zur Orientierung. Die genauen Schattierungen hängen vom Farbschema Ihres Terminals und dem Theme ab, das Sie mit `/theme` festgelegt haben. Beispielsweise verwendet das `github` Design eigene feste Farben, und das `colorblind` Design verwendet Blau und Gelb anstelle von Grün und Rot. Auf Terminals ohne volle Farbunterstützung verwenden die Punkte das eigene Grün, Blau und Gelb Ihres Terminals. Die oben genannten Farben beziehen sich auf den Standardchatmodus. Im Planmodus und im Autopilotmodus werden einige Punkte unterschiedlich eingefärbt. Die Textfarbe des Sitzungsnamens ändert sich auch in diesen Modi. Da farbe sich mit Ihrem Terminal, Design und Modus verschieben kann, sind die stetige oder pulsierende Form und die `!`, `?`und `○` Marker die zuverlässigsten Hinweise. ### Einstellungen der Sitzungen-Seitenleiste Verwenden Sie den `/settings sidebar` Schrägstrichbefehl in einer interaktiven CLI-Sitzung, um diese Einstellungen für die Sitzungs-Randleiste anzupassen.
Setting Beschreibung Vorgabe
sidebar.enabled Zulassen, dass die Sitzungs-Randleiste angezeigt wird. Ein
sidebar.showResumableSessions Die Randleiste enthält vorherige Sitzungen, die Sie fortsetzen können. Bei Festlegung auf off" werden nur aktive Sitzungen aufgelistet. Änderungen an dieser Einstellung werden wirksam, wenn das nächste Mal Copilot CLI gestartet wird. Ein
sidebar.showHeaderButtons Zeigen Sie die Zeile der Schaltflächen am oberen Rand der Randleiste an, um sie zu reduzieren (←) und eine neue Sitzung zu starten (+). Ein
sidebar.showCloseButton Als Alternative zum Klicken auf X wird mit dem Mauszeiger rechts neben einer Sitzung in der Randleiste eine Schaltfläche zum Schließen der Sitzung angezeigt. Klicken Sie auf diese Option, und klicken Sie dann erneut, um dies zu bestätigen. Die Sitzung wird endgültig gelöscht, unabhängig davon, ob sie noch lief. Sie können eine Sitzung, die auf diese Weise entfernt wurde, nicht fortsetzen. Aus
sidebar.hoverFocus Der Fokus wechselt von der Haupt-CLI-Registerkarte zur Randleiste, je nachdem, wo sich der Mauszeiger befindet. Aus
sidebar.coloredHints Während die Seitenleiste geöffnet ist und der Fokus auf Ihrer Unterhaltung liegt, zeigen Sie den Hinweis Seitenleiste verwenden in der Akzentfarbe der Seitenleiste an, um darauf aufmerksam zu machen. Wenn sie deaktiviert ist, wird dieselbe Farbe wie andere Hinweise verwendet. Während die Randleiste geschlossen ist, wird immer dieselbe Farbe wie andere Hinweise verwendet. Ein
sidebar.accentActiveSession Ändern Sie die Hervorhebung der Sitzungsauswahl in der Randleiste. Ist diese Option aktiviert, wird die aktuell in Ihrer Unterhaltung geöffnete Sitzung hauptsächlich hervorgehoben. Wenn diese Option deaktiviert ist, wird die mit den Pfeiltasten nach oben und unten (oder mit der Maus) ausgewählte Sitzung hauptsächlich hervorgehoben. Ein
Weitere Informationen zur Sitzungs-Randleiste finden Sie unter [Arbeiten mit mehreren GitHub Copilot CLI Sitzungen](/de/copilot/how-tos/copilot-cli/use-copilot-cli/work-with-multiple-sessions). ## Globale Tastenkombinationen in der interaktiven Benutzeroberfläche | Verknüpfung | Purpose | | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `@ FILENAME` | Fügen Sie Dateiinhalte in den Kontext ein. | | `# NUMBER` | Schließen Sie ein Problem oder eine GitHub Pullanforderung in den Kontext ein. | | `! COMMAND` | Führen Sie einen Befehl in der lokalen Shell aus und umgehen Sie Copilot. Geben Sie bei leerer Eingabeaufforderung nur `!` ein, um in den Shell-Modus zu wechseln und mehrere Shell-Befehle nacheinander auszuführen. Drücken Sie ESC oder STRG+C auf einer leeren Eingabeaufforderung, um den Shellmodus zu beenden. | | `$` | Geben Sie an der Eingabeaufforderung ein einzelnes `$` ein und drücken Sie die Eingabetaste, um das Terminal an eine echte interaktive Shell (`$SHELL` unter Unix, `%COMSPEC%` unter Windows) zu übergeben, mit dem Arbeitsverzeichnis der Sitzung als Stammverzeichnis. Im Gegensatz zum `!` Shell-Modus wird die CLI-Benutzeroberfläche vollständig ausgesetzt, sodass Jobsteuerung, Vollbildanwendungen, Tab-Vervollständigung und Farben alle nativ funktionieren. Beenden Sie die Shell (`exit`oder STRG+D auf Unix), um zur CLI zurückzukehren. Wird nur für eine lokale, vertrauenswürdige, inaktive Sitzung auf einem echten TTY aktiviert. Kann in unternehmensverwalteten Einstellungen deaktiviert werden. Standardmäßig aktiviert. Deaktivieren Sie sie mit der `shellShortcut` Einstellung – siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). | | `?` | Öffnen Sie schnelle Hilfe (auf einem leeren Prompt). Drücken Sie erneut, um dies zu verwerfen und ein literales `?` einzufügen. | | ESC | Abbrechen des aktuellen Vorgangs. Drücken Sie zweimal, um die laufende Antwort zu unterbrechen oder Hintergrund-Agents zu stoppen, wenn der Haupt-Agent inaktiv ist. Wenn das Modell in einer lokalen Sitzung noch nicht mit der Beantwortung Ihrer Anfrage begonnen hat, wird Ihr Prompt beim zweiten Drücken zur Bearbeitung erneut im Prompt-Feld angezeigt. | | Strg+C | Vorgang abbrechen/Eingabe löschen. Drücken Sie zweimal, um zu beenden. | | STRG+D | Herunterfahren. | | STRG+G | Bearbeiten Sie die Eingabeaufforderung in einem externen Editor (`$EDITOR`). | | STRG+L | Löschen Sie den Bildschirm. | | Strg+Eingabe oder STRG+Q | Eine Nachricht in die Warteschlange stellen, die gesendet werden soll, während der Agent ausgelastet ist. | | STRG+R | Umgekehrte Suche durch den Befehlsverlauf. | | Strg+Raum | Sprachdiktat ein- oder ausschalten (Alternative für STRG+X dann `v`). Dies funktioniert nur, wenn Ihr Terminal und ihr Betriebssystem sie durchlaufen. Möglicherweise müssen Sie dies in Ihren Betriebssystem- oder Terminaltastenbindungen freigeben. Verwenden Sie Strg`v`+ dann alternativ. | | Strg+V | Fügen Sie aus der Zwischenablage als Anlage ein. | | ALT+V | Bild aus der Zwischenablage als Anlage einfügen. | | Strg+X dann `/` | Nachdem Sie mit der Eingabe einer Eingabeaufforderung begonnen haben, können Sie einen Schrägstrichbefehl ausführen, z. B. wenn Sie das Modell ändern möchten, ohne die Eingabeaufforderung erneut eingeben zu müssen. | | Strg+X dann `e` | Bearbeiten Sie die Eingabeaufforderung in einem externen Editor (`$EDITOR`). | | Strg+X dann `b` | Hochstufung der ausgeführten Aufgabe oder des Shell-Befehls in den Hintergrund. | | Strg+X dann `g` | Reduzieren oder Erweitern des Autopilot-Zielbereichs. | | Strg+X dann `h` | Blenden Sie die Randleiste der aktuellen Sitzung aus. | | Strg+X dann `o` | Öffnen Sie den neuesten Link aus der Timeline. | | Strg+X dann `v` | Ein- oder Ausschalten der Sprachdiktate. | | Strg+X dann `x` | Schließen Sie die aktuelle Sitzung. | | Strg+Z | Prozess in den Hintergrund verschieben (Unix). | | Shift+Enter oder Option+Enter (Mac) / Alt+Enter (Windows/Linux) | Fügen Sie eine neue Zeile in die Eingabe ein. | | SHIFT+TAB | Wechseln zwischen Standard-, Plan- und Autopilot-Modus. | In lokalen Sitzungen können Sie Prompts, Shell-Befehle und unterstützte Slash-Befehle in der angegebenen Reihenfolge zur Ausführung vormerken, sobald die aktuelle Aufgabe abgeschlossen ist. Drücken Sie STRG+Q, um die aktuelle Eingabe in die Warteschlange zu stellen, während der Agent läuft. In die Warteschlange eingereihte Einträge zeigen eine Bezeichnung „ausstehend“ an und können einzeln abgebrochen werden, bevor sie ausgeführt werden. Drücken Sie bei einem leeren Promptfeld ↑, um den zuletzt in die Warteschlange gestellten oder als Steuerungs-Prompt verwendeten Prompt zur Bearbeitung zurück in das Promptfeld zu holen, bevor er erneut gesendet wird. Ein Hinweis "Rückruf" wird neben der Warteschlange angezeigt, wenn dies verfügbar ist. Verwenden Sie stattdessen STRG+P für nicht destruktive Navigation über den übermittelten Befehlsverlauf. In einer lokalen Sitzung wird eine abgesendete Eingabe, auf die das Modell noch nicht zu antworten begonnen hat, durch zweimaliges Drücken von Esc wieder in das Eingabefeld eingefügt und aus der Unterhaltung entfernt. Wenn das Modell bereits mit der Beantwortung begonnen hat, unterbricht dasselbe zweite ESC-Drücken stattdessen die laufende Drehung. Anschließend wird die Eingabeaufforderung bei leerem Eingabefeld durch Drücken von ↑ wieder im Eingabefeld angezeigt. ## Zeitleistenshortcuts in der interaktiven Benutzeroberfläche | Verknüpfung | Purpose | | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | STRG+F | Öffnen Sie die Zeitleistensuche. | | Strg+O | In der Eingabeaufforderung steht zwar nichts, aber dies erweitert die letzten Einträge in der Zeitleiste von Copilot, um mehr Details anzuzeigen. | | STRG+E | Während in der Eingabeaufforderung nichts steht, werden dadurch alle Elemente in der Antwortzeitleiste von Copilot erweitert. | | Strg+T | Erweitern/Reduzieren der Anzeige der Begründung in Antworten. | | Bild hoch/Bild ab | Scrollen Sie die Zeitachse um eine Seite nach oben oder unten. | ## Tastenkombinationen für das Dialogfeld „Aufgaben“ Wenn das Dialogfeld "Aufgaben" geöffnet ist (geöffnet über `/tasks`): | Verknüpfung | Purpose | | ------------------------- | -------------------------------------------------------------------------------------------------------------- | | ↑/K | Auswahl nach oben verschieben. | | ↓/J | Auswahl nach unten verschieben. | | eingeben | Aufgabendetails anzeigen oder in die eigene Sitzungsansicht des ausgewählten Sub-Agenten wechseln. | | `a` | Schalten Sie zwischen der Anzeige aller verschachtelten Subagentenebenen und nur den Aufgaben dieser Ebene um. | | `f` | Schalten Sie die Anzeige abgeschlossener Unter-Agents und Shells um, nicht nur die aktiven. | | X | Beenden Sie die ausgewählte aktive Aufgabe. | | R | Entfernen Sie den ausgewählten abgeschlossenen Vorgang. | | B | Ausgewählte Synchronisierungsaufgabe im Hintergrund ausführen. | | ESC | Schließen Sie das Dialogfeld (oder wechseln Sie zurück zur Liste). | Unter-Agents, die ihre eigenen geschachtelten Unter-Agents aufrufen, werden als eingezogener Baum angezeigt; die Zeile, in die Sie teleportiert sind, wird als „aktuell“ hervorgehoben. Wenn Sie sich in der Ansicht eines Subagents befinden, können Sie ihm über das Promptfeld auf dieselbe Weise wie bei der Hauptsitzung eine Steuerungsnachricht senden. ## Wiederherstellen einer unterbrochenen Sitzung Wenn eine Sitzung noch geöffnet war, als der CLI-Prozess wegging – z. B. aufgrund eines Absturzes oder eines Computerneustarts – kann der nächste `copilot` Start die Wiederherstellung anbieten, sodass Sie auswählen können, welche Sitzungen sie zurückbringen oder stattdessen neu starten sollen. Eine Sitzung, deren Agent mitten in einem Bearbeitungsschritt war, setzt diese Arbeit automatisch fort, sobald sie wiederhergestellt ist. Dieses Wiederherstellungsverhalten ist vorübergehend aktiviert, während das Startdialogfeld überarbeitet wird. Setzen Sie die `COPILOT_ENABLE_INTERRUPTED_SESSION_RESTORE`-Umgebungsvariable auf `1`, um sie zu aktivieren. Weitere Informationen finden Sie unter [Umgebungsvariablen](#environment-variables). ## Tastaturkürzel für die Sitzungsauswahl Wenn die Sitzungsauswahl geöffnet ist (geöffnet über `/resume` oder `--continue`): | Verknüpfung | Purpose | | ------------------------- | ---------------------------------------------------------------------------------- | | ↑/↓ | Auswahl nach oben oder unten verschieben. | | eingeben | Öffnen Sie die ausgewählte Sitzung. | | `s` | Ändern Sie die Sortierreihenfolge: Relevanz → erstellt → Name → zuletzt verwendet. | | Tab | Wechseln Sie zwischen der lokalen und der remote Registerkarte. | | `x` | Die ausgewählte Sitzung löschen. | | ESC | Schließen Sie den Picker. | Sitzungen sortieren nach den folgenden Modi: | Modus | Beschreibung | | ----------- | -------------------------------------------------------------------------------------------------------------- | | `relevance` | Wertet Sitzungen basierend auf ihrer Übereinstimmung mit dem aktuellen Arbeitsverzeichnis aus (standardmäßig). | | `last used` | Zuletzt geänderte Sitzungen zuerst. | | `created` | Zuletzt erstellte Sitzungen zuerst. | | `name` | Alphabetisch nach Sitzungsname; ungenannte Sitzungen werden am Ende sortiert. | Sitzungen, die bereits in einem anderen Fenster geöffnet sind, werden in allen Nicht-Relevanz-Sortiermodi oben angezeigt. Wenn kein Arbeitsverzeichniskontext verfügbar ist, wird der `relevance` Modus übersprungen. ## Umgebungsauswahl vor dem Gespräch Bevor Sie die erste Nachricht in einer neuen Sitzung senden, drücken Sie STRG+E in einem leeren Eingabeaufforderungsfeld, um auszuwählen, wo die Unterhaltung ausgeführt wird: auf Ihrem lokalen Computer oder in einer Cloudumgebung. Die Umgebung wird bereitgestellt, wenn Sie Ihre erste Nachricht senden. > [!NOTE] > Die Umgebungsauswahl erfordert, dass Cloudsitzungen auf Ihrem Konto verfügbar sind – die gleichen Anforderungen wie die Optionen `--remote`, `--no-remote`, `--remote-export`, `--no-remote-export` und `--connect`. Siehe [Befehlszeilenoptionen](#command-line-options). Sobald eine Unterhaltung gestartet wurde, kehrt STRG+E zu seinen anderen Verhaltensweisen zurück: Es bewegt den Cursor während der Eingabe an das Ende der Zeile oder erweitert bei einem leeren Eingabefeld alle Elemente in der Zeitachse. Siehe [Navigationsverknüpfungen in der interaktiven Benutzeroberfläche](#navigation-shortcuts-in-the-interactive-interface) und [Zeitachsenverknüpfungen in der interaktiven Benutzeroberfläche](#timeline-shortcuts-in-the-interactive-interface). ## Tastenkombinationen für die Seitenleiste und die Registerkarte „Sitzungen“ Mit der aktuellen Sitzungs-Randleiste können Sie zwischen Sitzungen navigieren und wechseln, ohne die Sitzung verlassen zu müssen, in der Sie sich gerade befinden. Durchlaufen Sie mit einem leeren Promptfeld ←/→ einen Fokuszyklus mit drei Zuständen: geschlossen, Fokus auf der Timeline und Fokus auf der Seitenleiste. Deaktivieren Sie die Randleiste vollständig mit der `sidebar` Einstellung – siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). | Verknüpfung | Purpose | | --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | ← (Aktueller Tab, geschlossen) | Öffnen Sie die Seitenleiste; die Zeitleiste behält den Fokus. | | ← (auf die Zeitachse ausgerichtet) | Setzen Sie den Fokus auf die Randleiste. | | → (auf die Seitenleiste fokussiert) | Setzen Sie den Fokus auf die Zeitachse zurück. | | → (auf die Zeitachse ausgerichtet) | Schließen Sie die Randleiste. | | Tab/Umschalt+Tab | Wechseln Sie zwischen Registerkarten (**Aktuell**, **Sitzungen** usw.). | | ↑/↓ (seitenleistenfokussiert) | Verschieben des Auswahlcursors; `j`/`k` sind Aliase. | | Enter (bei fokussierter Seitenleiste) | Wechseln Sie die Vordergrundsitzung auf die ausgewählte Karte. | | `n` (auf die Seitenleiste fokussiert) | Starten Sie eine neue Sitzung im Hintergrund und bringen Sie sie in den Vordergrund. | | `s` (auf die Seitenleiste fokussiert) | Wechseln Sie die Sortierreihenfolge: Neueste → Erstellt → Name → Keine. | | `x`, `x` (mit Fokus auf die Seitenleiste) | Schließen Sie die ausgewählte Karte (vor dem Schließen rot angezeigt und für das Schließen mit einem Tastendruck aktiviert). | Die Trennlinie der Randleiste kann gezogen werden, um die Größe zu ändern, und sie reduziert sich automatisch unter einer minimal verwendbaren Breite. Jede Karte zeigt einen Statuspunkt, den Sitzungsnamen und den Git-Branch (oder das Arbeitsverzeichnis, wenn kein Branch vorhanden ist). Der Titel der Vordergrundsitzung wird in Akzentfarbe hervorgehoben, und die Karte trägt eine dauerhafte subtile Füllung. Punkte geben den Status einer Sitzung an. Informationen dazu, was jeder Punkt bedeutet, finden Sie unter [Sitzungsstatusindikatoren](#session-status-indicators). Die aktive Sortierreihenfolge (`recent`, `created`oder `none``name`für die Einfügereihenfolge) bleibt bei Neustarts erhalten. Mausaktionen entsprechen den Tastaturaktionen: Klicken Sie auf eine Karte, um zur Sitzung im Vordergrund zu wechseln, doppelklicken Sie auf eine Karte oder einen leeren Bereich der Leiste, um die Seitenleiste zu fokussieren, und klicken Sie bei fokussierter Seitenleiste auf den Zeitleistenbereich, um den Fokus dorthin zurückzusetzen. Auf der Registerkarte **Sitzungen** werden die aktuelle Sitzung sowie der vollständige fortsetzungsfähige Sitzungsverlauf unter einer Trennlinie „Fortsetzbar“ aufgelistet: | Verknüpfung | Purpose | | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ↑/↓ | Zwischen Zeilen navigieren. | | Shift+↑/↓ | Seite nach oben oder unten. | | eingeben | Fortsetzen der ausgewählten Sitzung. | | `n` | Starten Sie eine neue Sitzung. | | `a` | Durchlaufen Sie den Filterbereich: alle → lokale → remote (Cloud). | | `/` | Durchsuchen Sie in Echtzeit Name, Verzweigung oder Arbeitsverzeichnis, Repository und Sitzungs-ID. | | `x`, `x` | Schließen oder löschen Sie die ausgewählte Zeile (für einen einzelnen Tastendruck vorbereitet, vor der Ausführung rot angezeigt); Strg++X gefolgt von `x` funktioniert weiterhin als Zwei-Tasten-Alternative. | | ←/→ | Wechseln Sie zwischen Registerkarten. | Remote-(Cloud-)Zeilen im Tab **Sessions** zeigen ebenfalls den Online- oder Offline-Status und das Repository an. Wenn Sie `x` bei einer Zeile zweimal drücken, wird eine laufende Sitzung geschlossen oder bei einer lokal fortsetzbaren Zeile der gespeicherte Sitzungsverlauf dieser Sitzung dauerhaft gelöscht. Das Drücken von Esc, das Drücken einer anderen Taste, das Verschieben der Markierung oder ein Timeout bricht die ausstehende Bestätigung ab. ## Tastenkombinationen für den Diff-Modus Wenn der Diff-Modus geöffnet ist (eingegeben über `/diff`): | Verknüpfung | Purpose | | --------------------------------------------- | ------------------------------------------------------------------------------- | | ↑ / `k` | Verschieben der Auswahl um eine Zeile nach oben. | | ↓ / `j` | Verschieben der Auswahl um eine Zeile nach unten. | | ← / `h` | Springen sie zur vorherigen Datei. | | → / `l` | Springen Sie zur nächsten Datei. | | Startseite / `g` | Springen Sie zur ersten Zeile. | | Ende / `G` | Springen Sie zur letzten Zeile. | | Bild nach oben | Scrollen Sie um eine Seite nach oben. | | Nächste Seite | Scrollen Sie um eine Seite nach unten. | | Strg+U | Scrollen Sie eine halbe Seite nach oben. | | STRG+D | Scrollen Sie auf einer halben Seite nach unten. | | `Click` | Wählen Sie die angeklickte Diff-Zeile aus (erfordert Mausunterstützung). | | Maus-Scrollen | Scrollen Sie nach oben oder unten. | | ALT/WAHL+BILDLAUF | Scrollen Sie jeweils um eine Zeile, um eine präzisere Steuerung zu ermöglichen. | | `c` | Hinzufügen oder Bearbeiten eines Kommentars in der ausgewählten Zeile. | | `s` | Kommentarzusammenfassung anzeigen (wenn Kommentare vorhanden sind). | | `b` | Zwischen nicht gestagten Änderungen und Verzweigung-Diff umschalten. | | `w` | Änderungen, die nur Leerzeichen enthalten, ausblenden/ausblenden. | | eingeben | Alle Kommentare übermitteln (wenn Kommentare vorhanden sind). | | `r` | Aktualisieren Sie den Diff (nur Remotesitzungen). | | Esc / Strg+C | Diff-Modus verlassen. | ## Tastenkürzel in der interaktiven Benutzeroberfläche | Verknüpfung | Purpose | | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | STRG+A | Wechseln zum Anfang der Zeile (beim Eingeben). | | STRG+B | Wechseln zum vorherigen Zeichen | | STRG+E | Wechseln zum Ende der Zeile (beim Eingeben). | | STRG+F | Wechseln zum nächsten Zeichen | | STRG+H | Löschen Sie das vorherige Zeichen. | | Strg+K | Löscht vom Cursor bis zum Ende der Zeile. Wenn sich der Cursor am Ende der Zeile befindet, löschen Sie den Zeilenumbruch. | | Strg+U | Löscht vom Cursor bis zum Anfang der Zeile. | | STRG+W | Löschen Sie das vorherige Wort. | | Home | Zum Anfang der aktuellen Bildschirmzeile wechseln. | | Ende | Zum Ende der aktuellen visuellen Zeile wechseln. | | Strg+Heim | Wechseln zum Anfang des Texts. | | Strg+Ende | Wechseln zum Ende des Texts. | | ALT+←/→ (Windows/Linux)
Option+←/→ (Mac) | Bewegen sie den Cursor um ein Wort. | | ↑/↓ | Navigieren Sie im Befehlsverlauf. Mit einem leeren Prompt-Feld ruft ↑ stattdessen den zuletzt in die Warteschlange eingestellten Prompt oder Steuerungs-Prompt auf, falls ein solcher verfügbar ist. | | STRG+P | Navigieren Sie nicht destruktiv im übermittelten Befehlsverlauf, ohne das Rückrufverhalten des Prompts in der Warteschlange auszulösen. | | Tab / Strg+Y | Akzeptiert den aktuellen Vervollständigungsvorschlag. | ## Slash-Befehle auf der interaktiven Benutzeroberfläche Dies sind die Slash-Befehle, die Sie innerhalb einer interaktiven CLI-Sitzung verwenden können. Eine Teilmenge dieser Schrägstrichbefehle ist für Clients verfügbar, die die CLI über ihren ACP-Server verwenden. Weitere Informationen findest du unter [Copilot CLI ACP-Server](/de/copilot/reference/copilot-cli-reference/acp-server). | Befehl | Purpose | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `/add-dir PATH` | Dateizugriff auf ein Verzeichnis zulassen und seine Skills (`.github/`, `.agents/`, `.claude/`) und Agents (`.github/`, `.claude/`) als vertrauenswürdige Konfigurationen laden. Wenn Sandboxing aktiviert ist, gewährt sie der Sandbox auch Zugriff auf das Verzeichnis für die aktuelle Sitzung. | | `/after [DELAY PROMPT]`, `/after` | Planen Sie einen einmaligen Prompt, Skill oder planbaren Slash-Befehl für die aktuelle Sitzung (z. B. `/after 30m remind me the time` oder `/after 1h /chronicle standup`). Ohne Argumente wird der Zeitplan-Manager angezeigt. Nur im experimentellen Modus verfügbar. | | `/agent` | Durchsuchen und wählen Sie aus den verfügbaren Agents (falls vorhanden) aus. Siehe [Benutzerdefinierte Agents](/de/copilot/concepts/customizations/custom-agents). | | `/app` | Öffnen Sie die aktuelle Sitzung in der GitHub Copilot app (erfordert Version 1.1.3 oder höher), oder zeigen Sie die Download-URL an, wenn die App nicht installiert ist. | | `/ask [QUESTION]`, `/btw [QUESTION]` | Stellen Sie eine schnelle Nebenfrage, ohne sie dem Gesprächsverlauf hinzuzufügen. Die Antwort wird als Markdown gerendert. Drücken Sie im Antwortdialogfeld STRG+E , um sie zu erweitern, und STRG+Y , um die vollständige Antwort zu kopieren. Geben Sie den Befehl ohne eine Frage ein, um die letzte Antwort auf eine Seitenfrage in der aktuellen Sitzung erneut zu öffnen. Siehe [Eine zusätzliche Frage in GitHub Copilot CLI stellen](/de/copilot/how-tos/copilot-cli/use-copilot-cli/ask-a-side-question). | | `/allow-all [on\|off\|show]`, `/yolo [on\|off\|show]` | Alle Berechtigungen aktivieren (Tools, Pfade und URLs). Dies ist ein Alias für `/permissions allow-all`; siehe die `/permissions` Zeile für den kanonischen Befehl und die zugehörigen Unterbefehle. | | `/autopilot [OBJECTIVE]`, `/goal [OBJECTIVE]` | Autopilot-Modus starten oder neu ausrichten, optional mit einem expliziten Ziel (z. B `/goal Refactor the auth module`. ). Ohne ein Ziel leitet Autopilot die Absicht aus dem Kontext ab, und im Statusbereich wird Ihre letzte Eingabeaufforderung als abgeleitetes Ziel angezeigt. Sie können die Ausgaben für KI-Guthaben für das Ziel mithilfe von `--max-ai-credits N` begrenzen (z. B. `/goal Refactor the auth module --max-ai-credits 5`). Wenn die Obergrenze erreicht ist, wird Autopilot angehalten und ein Bereich geöffnet, der die bereits auf die Obergrenze angerechneten Guthaben anzeigt. Geben Sie einen neuen Betrag ein, um mit einem neuen Kreditfenster fortzufahren, oder schließen Sie das Panel, um pausiert zu bleiben. Sie können ein angehaltenes Ziel auch selbst fortsetzen, ohne das Panel zu verwenden, indem Sie die Option direkt ohne Zieltext ausführen – zum Beispiel: `/goal --max-ai-credits 5`. Dies ist dieselbe Aktion, die das Bedienfeld ausführt: Dabei wird ein neues Fenster mit dem von Ihnen angegebenen Guthaben geöffnet (die vollständige neue Obergrenze, keine Erhöhung um einen Teilbetrag), und das Ziel wird fortgesetzt. `/goal on` und `/goal off` schalten den Autopilotmodus um, ohne ein Ziel festzulegen, und akzeptieren `--max-ai-credits` nicht. Ein aktives Ziel erscheint über dem Prompt-Feld als angeheftetes Panel und zeigt das Ziel, die verwendeten Credits und den Fortschritt der Aufgaben an. Das Panel reduziert sich auf kurzen Terminals (unter 30 Zeilen) automatisch auf eine einzelne Zeile und wird oberhalb dieses Schwellenwerts wieder erweitert; drücken Sie STRG+X und dann `g`, um die automatische Größenanpassung manuell zu übersteuern. | | `/changelog [summarize] [VERSION\|last N\|since VERSION]`, `/release-notes [summarize] [VERSION\|last N\|since VERSION]` | Anzeigen des CLI-Änderungsprotokolls. Geben Sie optional eine Version, eine Anzahl der zuletzt verwendeten Versionen oder eine Startversion an. Fügen Sie das Schlüsselwort `summarize` für eine KI-generierte Zusammenfassung hinzu. | | `/chronicle ` | Tools für den Sitzungsverlauf und Einblicke. Die `skills` Unterbefehle entwerfen, überprüfen und verfolgen den Status von Repository-Qualifikationsvorschlägen, die aus der beobachteten Nutzung generiert wurden. Siehe [Verwenden von GitHub Copilot CLI Sitzungsdaten](/de/copilot/how-tos/copilot-cli/use-copilot-cli/chronicle#using-the-chronicle-slash-command). | | `/clear [PROMPT]`, `/new [PROMPT]``/reset [PROMPT]` | Beginnen Sie eine neue Unterhaltung. `/new worktree` startet eine leere Sitzung in einem neuen Git-Worktree, anstatt den aktuellen zu leeren, sodass die aktuelle Konversation und ihr Arbeitsverzeichnis unverändert bleiben. | | `/clikit [COMPONENT]` | Anzeigen einer Vorschau von CLI-Geschäftskomponenten (z. B. Kontingentinformationen). | | `/collect-debug-logs [file\|gist\|share] [PATH]` | Sammeln Sie Debugprotokolle in ein Archiv, einen GitHub Gist oder laden Sie sie in GitHub (`share`) hoch. Siehe [Sammeln und Freigeben von Debugprotokollen](#collecting-and-sharing-debug-logs). | | `/compact [FOCUS-INSTRUCTIONS]` | Fassen Sie den Unterhaltungsverlauf zusammen, um die Nutzung von Kontextfenstern zu reduzieren. Geben Sie optional Fokusvorgaben an, um die Zusammenfassung auszurichten, zum Beispiel `/compact focus on the auth module`. Siehe [Verwalten des Kontexts für GitHub Copilot](/de/copilot/concepts/prompting-and-context/context-management#compaction). | | `/context` | Anzeigen von Verwendung und Visualisierung der Kontextfenster-Tokens. Siehe [Verwalten des Kontexts für GitHub Copilot](/de/copilot/concepts/prompting-and-context/context-management#checking-your-context-usage). | | `/copy` | Kopieren Sie die letzte Antwort in die Zwischenablage. | | `/cwd`, `/cd [PATH]` | Ändern Sie das Arbeitsverzeichnis, oder zeigen Sie das aktuelle Verzeichnis an. | | `/delegate [PROMPT]` | Delegieren Sie Änderungen an einem Remote-Repository mit einer KI-generierten Pullanforderung. Siehe [Delegieren von Aufgaben an Copilot](/de/copilot/how-tos/copilot-cli/use-copilot-cli/delegate-tasks-to-cca). | | `/diagnose [PROMPT]`, `/diagnose` | Analysieren Sie das aktuelle Sitzungsprotokoll auf Fehler, unerwartetes Verhalten und andere Probleme. Fügen Sie optional eine benutzerdefinierte Eingabeaufforderung ein, um die Diagnose auf ein bestimmtes Problem zu konzentrieren. | | `/diff` | Änderungen im aktuellen Verzeichnis überprüfen; wechselt automatisch zum Verzweigungs-Diff, wenn der Arbeitsbaum keine Änderungen enthält (experimentell). | | `/downgrade VERSION` | Laden Sie eine bestimmte CLI-Version herunter, und starten Sie sie neu. Verfügbar für Teamkonten. | | `/env` | Zeigen Sie geladene Umgebungsdetails an (Anweisungen, MCP-Server, Fähigkeiten, Agents, Hooks, Plug-Ins, LSPs, Erweiterungen). | | `/every [INTERVAL] PROMPT`, `/every` | Planen Sie einen wiederkehrenden Prompt, Skill oder planbaren Slash-Befehl für die aktuelle Sitzung (z. B. `/every 1h run tests` oder `/every 1d /chronicle standup`). Ohne Argumente wird der Zeitplan-Manager angezeigt. Nur im experimentellen Modus verfügbar. | | `/exit`, `/quit` | Schließen Sie die aktuelle Sitzung. Wenn andere Sitzungen ausgeführt werden, wird in diesem Vordergrund die neueste verbleibende Sitzung anstelle des Beendens angezeigt. Beendet die CLI nur, wenn es sich um die letzte geöffnete Sitzung handelt. `/exit print` fährt die CLI immer herunter und bietet an, das Transkript auszugeben. `/exit` und `/quit` (einschließlich ihrer `print`-Variante) können auch mit Strg+Q in die Warteschlange eingereiht werden, während der Agent läuft – die CLI schließt die Sitzung, sobald die aktuelle Interaktion und alle davor in der Warteschlange stehenden Shell-Befehle abgeschlossen sind. | | `/extensions [manage\|mode]`, `/extension` | Verwalten sie CLI-Erweiterungen. Nur im experimentellen Modus verfügbar. | | `/experimental [on\|off\|show]` | Aktivieren, Festlegen oder Anzeigen experimenteller Features | | `/feedback`, `/bug` | Geben Sie Feedback zur CLI. Es kann eine Option zum Senden von Feedback mit Protokollen angeboten werden; siehe [Sammeln und Freigeben von Debugprotokollen](#collecting-and-sharing-debug-logs). | | `/fleet [PROMPT]` | Aktivieren Sie die parallele Subagentausführung von Teilen eines Vorgangs. Siehe [Beschleunigen des Aufgabenabschlusses mit dem \`/fleet\` Befehl](/de/copilot/how-tos/copilot-cli/use-copilot-cli/speed-up-task-completion). | | `/help` | Zeigen Sie die Hilfe für interaktive Befehle an. | | `/ide` | Stellen Sie eine Verbindung mit einem IDE-Arbeitsbereich her. Siehe [Verbinden von GitHub Copilot CLI mit VS Code](/de/copilot/how-tos/copilot-cli/use-copilot-cli/connecting-vs-code#managing-the-connection-with-the-ide-slash-command). | | `/init [suppress\|INSTRUCTIONS]` | Initialisieren Sie Copilot benutzerdefinierte Anweisungen und agentenbasierte Funktionen für dieses Repository. Text nach dem Befehl bestimmt, was geschrieben wird. | | `suppress` Blendet die Starterinnerung für dieses Repository aus. Siehe [Projektinitialisierung für Copilot](#project-initialization-for-copilot). | | | `/instructions` | Anzeigen und Umschalten von benutzerdefinierten Anweisungsdateien. | | `/keep-alive [on\|off\|busy\|DURATION]`, `/caffeinate [on\|off\|busy\|DURATION]` | Verhindern Sie, dass der Computer in den Ruhezustand wechselt: Während eine CLI-Sitzung aktiv ist, während der Agent ausgelastet ist oder für eine definierte Zeitdauer. Akzeptiert Zeiträume wie `30`, `30m`, `2h`, `1d` (bloße Zahlen sind standardmäßig Minuten). | | `/limits` | Öffnen des Dialogfelds "Interaktive Antwortbeschränkungen". | | `/limits set max-ai-credits VALUE` | Legen Sie ein weiches Maximum für AI-Guthaben fest, das pro Antwort zulässig ist. Antwortgrenzwerte sind weiche Grenzwerte, die für jede Benutzernachricht zurückgesetzt werden. Siehe [Festlegen eines AI credit Sitzungslimits in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit). | | `/limits unset [max-ai-credits\|all]` | Entfernen Sie ein bestimmtes Antwortlimit oder alle Antwortgrenzwerte. | | `/list-dirs` | Zeigen Sie alle Verzeichnisse an, für die der Dateizugriff zulässig ist. | | `/login` | Melden Sie sich auf Copilot an. | | `/logout` | Melden Sie sich von Copilot ab. | | `/lsp [show\|test\|reload\|logs\|help] [SERVER-NAME]` | Verwalten Sie die Sprachserverkonfiguration. Der `logs` Unterbefehl öffnet den Protokollbereich der Live-LSP-Dienste. | | `/mcp [config\|list\|show\|add\|edit\|delete\|disable\|enable\|auth\|reload\|search] [SERVER-NAME]` | Verwalten Sie die MCP-Serverkonfiguration. Ohne Unterbefehl oder mit `config` wird das Plugin-Dashboard mit fixierter MCP-Serverliste geöffnet; die Formulare zum Hinzufügen, Bearbeiten und Authentifizieren werden ebenfalls innerhalb dieses Dashboards geöffnet, sodass Sie nach dem Schließen eines Formulars zur Serverliste zurückkehren. Verwenden Sie `show SERVER-NAME` oder `show`, um alle konfigurierten Server anzuzeigen oder die Details eines Servers direkt zu öffnen, einschließlich der verfügbaren Tools, und ihn zu aktivieren oder zu deaktivieren. Für einen von einem Plugin bereitgestellten Server zeigt `show SERVER-NAME` auch die Quellenangabe an (zum Beispiel `Source: Plugin my-plugin (1.2.0)`). | | `list` (Alias `ls`) Druckt eine Nur-Text-Liste der konfigurierten Server mit Verbindungsstatus und Livestatus. Bare `/mcp`, `config`, `show` und `list` (auch bekannt als `ls`) sind schreibgeschützt oder öffnen das Dashboard, sodass sie ausgeführt werden können, während der Agent gerade eine Anfrage verarbeitet. Die ändernden Unterbefehle (`add`, `edit`, `delete`, `disable`, `enable`, `auth`, `reload` und `search`) sind gesperrt, bis der Zug beendet ist. | | | `edit ` lehnt einen aus dem Arbeitsbereich stammenden Server (einen, der im `.mcp.json` eines Repositorys definiert ist) ab, anstatt den Assistenten der Benutzerebene zu öffnen, da beim Speichern stillschweigend ein Benutzereintrag mit demselben Namen erstellt würde, der weiterhin vom Arbeitsbereichseintrag überdeckt wird. Der Fehler benennt die Datei, die direkt bearbeitet werden soll. | | | `delete ` zeigt dieselbe Datei an, wenn es aufgefordert wird, einen aus dem Arbeitsbereich stammenden Server zu entfernen. Lokale Sandbox-Server zeigen einen `connected (sandboxed)`-Status an. Siehe [Hinzufügen von MCP-Servern für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers#managing-mcp-servers). | | | `/model [--session\|--global\|--repo\|--local] [MODEL\|auto TIER]`, `/models` | Wählen Sie das KI-Modell aus, das Sie verwenden möchten, oder wählen Sie **"Auto"** aus. Bei Modell-IDs wird nicht zwischen Groß- und Kleinschreibung unterschieden, und die kanonische ID wird gespeichert. Ändert standardmäßig (oder mit `--session`, Alias `-s`) das Modell, den Denkaufwand oder das Kontextfenster nur für die aktuelle Sitzung, ohne gespeicherte Einstellungen zu berühren. `--repo`/`--local` heftet stattdessen das Standardmodell in Repositoryeinstellungen an; `--global` (oder `/config model`) legt die Standardeinstellung für zukünftige Sitzungen fest. Drücken Sie die TAB-TASTE auf einem Modell mit einer langen Kontextvariante, um die Kontextspalte zwischen dem Standardfenster und dem langen Kontextfenster umzuschalten. Die Auswahlhilfe gruppiert Modelle in Abschnitte – drücken Sie Umschalt+Tab, um zwischen den Gruppierungen „Empfohlen“ (Zuletzt verwendet, Empfohlen, Neu und andere Modelle), „Anbieter“ und „Kategorien“ zu wechseln. Das Auswahlfeld markiert Ihr effektives verwaltetes Standardmodell mit der Standardkennzeichnung, wenn es auswählbar ist. Ein Modell mit anbieterspezifischen Datenaufbewahrungsbedingungen zeigt ein Warnbanner für die Datenaufbewahrung mit einem Link zur Richtlinie des Anbieters an. Während eines laufenden Turns nutzbar: Eine Änderung, die angefordert wird, während der Agent läuft, wird als abbrechbarer Befehl (Ctrl+C) in die Warteschlange gestellt und angewendet, sobald der aktuelle Turn abgeschlossen ist, anstatt das Live-Modell mitten in der Anfrage zu wechseln. Verwenden Sie `/model auto TIER` (`efficiency`, `balance` oder `intelligence`), um eine bestimmte Auto-Routing-Stufe direkt auszuwählen, auch über die Aktion „Wechseln“ in einem Empfehlungshinweis für eine Auto-Stufe. Wenn Auto ein Modell auswählt, zeigt die Zeitachse den Grund für diese Auswahl an, wenn die API einen bereitstellt. Siehe [Über GitHub Copilotauto model selection](/de/copilot/concepts/models/auto-model-selection). | | `/permissions [default\|assisted\|allow-all\|show]` | Wechseln zwischen Berechtigungsmodi (`default`, `assisted`, `allow-all`) oder Anzeigen des aktuellen Modus (`show`). Dies ist der kanonische Befehl für Änderungen im Berechtigungsmodus; `/allow-all` und `/yolo` bleiben als Aliase unterstützt. Informationen zu unterstützten Berechtigungen finden Sie unter [Zulassen der Ausführung sicherer Befehle ohne manuelle Genehmigung](/de/copilot/concepts/customizations/allowing-safe-commands). | | `/permissions reset` | Setzen Sie alle Speichertool- und Pfadgenehmigungen für die aktuelle Sitzung zurück (erneute Eingabeaufforderung bei der nächsten Verwendung). | | `/plan [PROMPT]` | Erstellen Sie vor dem Codieren einen Implementierungsplan. | | `/plugin` | Öffnen Sie das Plugins-Dashboard, in dem Ihre installierten Plug-Ins angezeigt werden. Wählen Sie ein Plugin aus und drücken Sie die Eingabetaste, um dessen Details sowie Aktionen wie das Aktivieren, Deaktivieren, Aktualisieren oder Deinstallieren anzuzeigen. Verwenden Sie die ← - und → Schlüssel, um zwischen den Ansichten **"Installiert**", " **Online**" und **"Marketplace** " zu wechseln. Das Dashboard zeigt nur Plug-ins an – verwenden Sie `/mcp` für MCP-Server und `/skills` für Fähigkeiten. Siehe [Plug-Ins für GitHub Copilot](/de/copilot/concepts/agents/about-plugins). | | `/plugin install SOURCE` | Installieren Sie ein Plug-In aus einer Marketplace-Spezifikation, einem GitHub Repository, einer Git-URL oder einem lokalen Pfad. | | `/plugin update PLUGIN[@MARKETPLACE]` | Aktualisieren eines installierten Plug-Ins. | | `/plugin uninstall PLUGIN[@MARKETPLACE]` (auch bekannt als `remove`, `rm`) | Deinstallieren Sie ein Plug-In. | | `/plugin list` (Alias `ls`) | Installierte Plug-ins auflisten. Team-Plug-In-Zuweisungen legen optionale Standardwerte für Teammitglieder fest. Plug-Ins, die als standardmäßig aktiviert zugewiesen sind, werden als aktiviert angezeigt, und deren Skills werden geladen, es sei denn, Sie deaktivieren sie oder verwaltete Einstellungen setzen die Standardeinstellung außer Kraft. Im Gegensatz dazu können Plug-Ins, die über verwaltete `enabledPlugins` erzwungen werden, einschließlich Unternehmensteameinstellungen, nicht lokal deaktiviert werden. Siehe [GitHub Copilot CLI-Plug-In-Referenz](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference#cli-commands). | | `/plugin marketplace add SOURCE` | Fügen Sie einen Marketplace hinzu. | | `/plugin marketplace remove NAME` | Entfernen Sie einen Marketplace. | | `/plugin marketplace list` | Registrierte Marktplätze auflisten. | | `/plugin marketplace browse NAME` | Durchsuchen Sie Plug-Ins auf einem Marketplace. | | `/plugin marketplace update [NAME]` (Alias `refresh`) | Rufen Sie den Plug-In-Katalog eines Marketplaces oder jeden registrierten Marketplace erneut ab, wenn kein Name angegeben wird. | | `/pr [view\|create\|fix\|auto\|automerge]` | Verwalten von Pull Requests für den aktuellen Branch. | | `auto` bringt die Pull-Anforderung auf „grün“ und stoppt; `automerge` (Alias: `agentmerge`) bringt die Pull-Anforderung auf „grün“ und führt anschließend den Merge durch. Wenn das Repository über eine Pull-Anforderungsvorlage (`.github/pull_request_template.md` oder eine Datei unter `.github/PULL_REQUEST_TEMPLATE/`) verfügt, `create` folgt sie standardmäßig – beibehalten von Überschriften, Kommentaren und Checklistenelementen und Ausfüllen genauer Details, anstatt einen generischen Text zu schreiben. Bitten Sie Copilot , die Vorlage zu überspringen, wenn sie nicht angewendet werden soll. Siehe [Verwalten von Pullanforderungen mit dem Befehl "/pr"](/de/copilot/how-tos/copilot-cli/use-copilot-cli/manage-pull-requests). | | | `/refine TEXT` | Schreiben Sie eine grob zusammengesetzte Eingabeaufforderung in eine klare Eingabeaufforderung zur Überprüfung um. Führen Sie den Befehl ohne Argumente aus (mit Strg+X und dann `/refine`), um das aktuelle Eingabefeld zu leeren. Kann besonders nützlich sein, wenn Prompts per Sprache eingegeben werden. | | `/remote [on\|off]` | Status der Fernsteuerung anzeigen (falls kein Argument angegeben), Fernsteuerung aktivieren (`on`) oder Remoteverbindung beenden (`off`). Siehe [Steuern einer GitHub Copilot CLI Sitzung von einem anderen Gerät](/de/copilot/how-tos/copilot-cli/use-copilot-cli/steer-remotely). | | `/rename [NAME]` | Benennen Sie die aktuelle Sitzung um (generiert automatisch einen Namen, wenn nicht angegeben; Alias für `/session rename`). | | `/research TOPIC` | Führen Sie eine umfassende Recherche mithilfe von GitHub Such- und Webquellen durch. Siehe [Recherchieren mit GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/research-with-copilot-cli). | | `/reset-allowed-tools` | Berechtigungen für die aktuelle Sitzung zurücksetzen. Dadurch werden die Genehmigungen des Sitzungstools gelöscht, der Berechtigungsmodus wird auf manuell zurückgesetzt (wodurch „Allow-All“ oder assisted permissions deaktiviert wird, falls eine der beiden Optionen aktiviert ist), und die für den aktuellen Speicherort gespeicherten Genehmigungen gelöscht. Explizite Startregeln, z. B. `--allow-tool`, `--deny-tool`, `--allow-url` und `--deny-url`, bleiben Teil der Baseline der Sitzung. | | `/restart` | Starten Sie die CLI neu und stellen Sie alle aktiven Sitzungen des aktuellen Prozesses wieder her, nicht nur die aktive Sitzung im Vordergrund. Wenn die Ziel-CLI-Version mehrere Sitzungen nicht wiederherstellen kann, werden Sie aufgefordert, nur die Vordergrundsitzung fortzusetzen oder abzubrechen. Sitzungen, die in einer Git-Arbeitsstruktur mit `-w` oder `--worktree` gestartet wurden, werden in derselben Arbeitsstruktur fortgesetzt. Das mit `/model` ausgewählte Modell wird beibehalten. | | `/resume [SESSION-ID]`, `/continue [SESSION-ID]` | Wechseln Sie zu einer anderen Sitzung, indem Sie eine Liste auswählen (optional eine Sitzungs-ID angeben). | | `/review [PROMPT]` | Führen Sie den Codeüberprüfungs-Agent aus, um Änderungen zu analysieren. Siehe [Anfordern einer Codeüberprüfung mit GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/agentic-code-review). | | `/rubber-duck [PROMPT]` | Ziehen Sie den Rubber-Duck-Agent für eine Zweitmeinung zu Plänen, Code und Tests zurate. Siehe [Eine zweite Meinung mit dem Rubber-Duck-Agenten](/de/copilot/concepts/agent-capabilities/choosing-and-delegating-agent-work/getting-a-second-opinion). | | `/sandbox [config\|status\|policy [COMMAND]\|enable\|disable]` | Verwalten Sie Sandkasteneinschränkungen für Dateisystem und Netzwerkzugriff. | | `config` (oder nur `/sandbox`) öffnet das Dialogfeld „Einstellungen“, in dem mögliche Umgebungsgeheimnisse vorgeschlagen werden, und Sie können vor dem Speichern Maskierungshosts hinzufügen. Auf der Registerkarte " **Allgemein** " des Dialogfelds gibt es separate Optionen zum Aktivieren der Sandboxing für die aktuelle Sitzung und zum Festlegen des Standardwerts für neue Sitzungen. Wenn Sie eine der beiden Optionen ändern, bleibt die andere unverändert. | | | `/sandbox enable session` und `/sandbox disable session` ändern das Sandboxing für die aktuelle Sitzung, ohne den gespeicherten Standardwert zu ändern. | | | `status` zeigt an, ob Sandboxing für die aktuelle Sitzung aktiviert ist. Wenn die Sandbox aktiviert ist, zeigt `policy` Pfadberechtigungen und Einschränkungen gruppiert nach Quell- und Zugriffstyp, Netzwerkeinstellungen, Zugriff auf Entwicklertools und Sandbox-Funktionen an. Fügen Sie optional einen Befehl hinzu, z. B. `/sandbox policy npm install`, um den Zugriff auf das Entwicklertool zu überprüfen, ohne ihn auszuführen. | | | `enable` und `disable` aktualisieren normalerweise Ihre gespeicherte Einstellung. Wenn Ihre Organisation Sandboxing erfordert, wird `disable` verweigert, es sei denn, die Umgehung ist zulässig. In diesem Fall gilt das Deaktivieren nur für die aktuelle Sitzung. | | | `/sandbox ca [create\|trust\|rotate\|remove]` | Verwalten Sie die Proxyzertifizierungsstelle der Sandbox. | | `create` schreibt es, ohne ihm zu vertrauen. | | | `trust` fügt es dem OS-Vertrauensspeicher hinzu. | | | `rotate` ersetzt es, während sein Vertrauenszustand erhalten bleibt. | | | `remove` entfernt das Vertrauen des Betriebssystems. Siehe [Verwendung `copilot sandbox ca`](#using-copilot-sandbox-ca), um dieselben Vorgänge außerhalb einer Sitzung auszuführen, z. B. auf verwalteten Geräten. | | | `/search [QUERY]`, `/find [QUERY]` | Durchsuchen Sie den Gesprächsverlauf. | | `/security-review [PROMPT]` | Führen Sie eine fokussierte Sicherheitsüberprüfung der aktiven lokalen Codeänderungen aus, und geben Sie priorisierte Sicherheitsrisiken mit Korrekturvorschlägen zurück. Dieser Befehl ist keine vollständige Sicherheitsprüfung des Repositorys. | | `/session [info\|checkpoints [n]\|files\|plan\|rename [NAME]\|cleanup\|prune\|delete [ID]\|delete-all]`, `/sessions [info\|checkpoints [n]\|files\|plan\|rename [NAME]\|cleanup\|prune\|delete [ID]\|delete-all]` | Anzeigen von Sitzungsinformationen und Verwalten von Sitzungen Der `info` Unterbefehl zeigt Sitzungsdetails einschließlich des Sitzungslinks (sofern verfügbar). Unterbefehle: `info`, , `checkpoints`, `files`, `plan``rename`, `cleanup`, `prune`, . `delete``delete-all` | | `/settings [--repo\|--local] [show KEY\|KEY\|KEY VALUE]`,
`/config [--repo\|--local] [show KEY\|KEY\|KEY VALUE]` | Öffnen Sie das Dialogfeld „Einstellungen“, öffnen Sie es mit Fokus auf eine bestimmte Einstellung (`KEY`), legen Sie eine Einstellung inline fest (`KEY VALUE`), oder zeigen Sie den aktuellen Wert einer Einstellung an (`show KEY`). `show` maskiert benannte Werte mit geheimem Inhalt (z. B. Token oder API-Schlüssel, die in einer Einstellung verschachtelt sind), anstatt sie im Klartext auszugeben. Das Dialogfeld zeigt die Registerkarten **Benutzer**, **Repo**, **Repo (lokal)** und **Probleme** – wechseln Sie mit Tab/Umschalt+Tab; eine Einstellung, die in einem anderen Bereich überschrieben wird, zeigt ein Abzeichen an, das angibt, welcher Bereich Vorrang hat. Die Registerkarte **„Probleme“** ist eine scopeübergreifende Ansicht der Einstellungen, die Aufmerksamkeit benötigen (z. B. unbekannte oder ungültige Schlüssel); ihre Beschriftung zeigt die Anzahl an, z. B. `Problems (2)`, wenn irgendein Bereich ein Problem aufweist, und lautet andernfalls einfach `Problems`. Das Dialogfeld enthält auch eine globale Suche, die sichtbare Einstellungen, Bereiche und lokale Ressourcen findet. Fügen Sie `--repo` oder `--local` zum Ziel `.github/copilot/settings.json` oder `.github/copilot/settings.local.json` hinzu, anstatt zur Benutzereinstellungsdatei – z. B. `/settings --repo model gpt-6-astra`. Auf diese Weise können nur [repo-außerkraftsetzungsfähige Schlüssel](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#repository-settings-githubcopilotsettingsjson) festgelegt werden. Zeilen, die von einer aktiven Organisation oder einer verwalteten MDM-Richtlinie gesteuert werden, werden mit dem Tag `(managed)` als schreibgeschützt angezeigt. Siehe [Ändern von Einstellungen mit dem \`/settings\` Befehl](/de/copilot/how-tos/copilot-cli/customize-copilot/change-settings). | | `/share [link\|off\|file\|html\|gist\|research] [...]`, `/export [...]` | Geben Sie die aktuelle Sitzung frei. Ohne Unterbefehl wird ein Freigabemenü geöffnet, ohne etwas zu teilen oder zu exportieren. `link` teilt die Sitzung und gibt einen freigabefähigen GitHub Link aus. `off` oder `link off` beendet das Teilen des Links. `file [session\|research] [PATH]` exportiert in eine Markdown-Datei. `html [session\|research] [PATH]` exportiert in eine HTML-Datei. `gist [session\|research]` erstellt einen GitHub Gist. `research [PATH]` exportiert den Forschungsbericht. | | `/skills` | Öffnen Sie das Plugins-Dashboard auf der Registerkarte "Fähigkeiten". | | `/skills list` | Alle verfügbaren Fähigkeiten auflisten. | | `/skills info NAME` | Zeigen Sie Details zu einer bestimmten Fähigkeit an. | | `/skills add [--project] ` | Fügen Sie eine Fähigkeit aus einer Datei, URL oder einem Verzeichnis hinzu; `--project` beschreibt eine Datei- oder URL-Installation in diesem Repository anstelle Ihres Benutzerkontos. | | `/skills remove ` | Entfernen Sie eine Fähigkeit anhand des Namens, oder heben Sie die Registrierung eines benutzerdefinierten Qualifikationsverzeichnisses auf. | | `/skills reload` | Laden Sie Die Fähigkeiten aus allen Verzeichnissen neu. Siehe [Hinzufügen von Agent-Fähigkeiten für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/add-skills). | | `/statusline`, `/footer` | Konfigurieren Sie, welche Elemente in der Statuszeile angezeigt werden. | | `/subagents`, `/agents` | Konfigurieren Sie Standard- und agentenspezifische Subagentenmodelle. Für einen Agent mit `modelPolicy: "required"` – unabhängig davon, ob dies in der Definition des Agents selbst oder in den `subagents`-Einstellungen festgelegt ist – zeigt das Auswahlfeld einen gesperrten **Modell**-Eintrag und eine Zeile für die **Modellvorgabe** mit dem Text „erforderlich – kann nicht außer Kraft gesetzt werden“ an (oder „von der Agentdefinition vorgegeben“, wenn die Agentdefinition selbst die Richtlinie vorgibt). Setzen Sie die Richtlinie in der Auswahl wieder auf `"preferred"`, um Außerkraftsetzungen wieder zuzulassen, sofern die Agentdefinition dies nicht erfordert. Siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). | | `/tasks` | Anzeigen und Verwalten von Aufgaben (Subagenten und Shellbefehle). | | `/terminal-setup` | Konfigurieren Sie das Terminal für die Unterstützung von Mehrzeileneingaben (Umschalt+Eingabe und Strg+Eingabe). | | `/theme [default\|github\|dim\|high-contrast\|colorblind]` | Anzeigen oder Festlegen des Farbmodus. | | `/tuikit [colors\|icons\|select\|tabbar]` | Vorschau von TUIkit-Designsystemkomponenten und Farbtoken. | | `/undo`, `/rewind` | Öffnen Sie die Zurückspul-Auswahl, um die Sitzung wieder auf einen früheren Benutzer-Turn zurückzusetzen. Wählen Sie zwischen: **Nur Unterhaltung** (setzt die Unterhaltung zurück, wobei die Dateien unverändert bleiben) oder **Unterhaltung + Dateien** (stellt auch die Dateien Copilot, die in diesem Schritt und in später verworfenen Schritten geändert wurden, auf ihren Inhalt vor den Änderungen zurück; Dateien, die Sie seitdem selbst bearbeitet haben, werden übersprungen). Dateiänderungen werden pro Schritt bei der Verwendung von Bearbeitungstools, Shell-Befehlen und Unteragenten nachverfolgt, sodass Git nicht erforderlich ist. Ein Zurückspulen kann nicht rückgängig gemacht werden: Spätere Schritte werden aus der Sitzung entfernt. Verwenden Sie `/fork` zuerst, um eine Kopie beizubehalten. | | `/update`, `/upgrade` | Aktualisieren Sie die CLI auf die neueste Version. `/update stable` oder `/update prerelease` speichern auch den ausgewählten Kanal für zukünftige Updates. | | `/usage` | Zeigt Nutzungsmetriken und Statistiken für Sitzungen an, einschließlich Token-Gesamtsummen pro Modell. Für Konten mit tokenbasierter Abrechnung zeigt die Zeile jedes Modells auch den eigenen AI credit Verbrauch an (z. B. `1 AIC`). Abrechnungsmodelle ohne Tokenanzahl zeigen nur Gutschriften an. | | `/user [show\|list\|switch]` | Angemeldete Konten verwalten. | | `/version` | Zeigen Sie Versionsinformationen an, und suchen Sie nach Updates. | | `/vim` | Vim-Modus für das Promptfeld umschalten, um modale Bearbeitung im Vim-Stil zu aktivieren: Bewegungen (z. B. `hjkl`, `w`, `b`, `e`, `0`, `$`, `gg`, `G`), Zeichensuche (`f`/`F`/`t`/`T`/`;`/`,`), Einfügebefehle (`i`/`a`/`o`), Bearbeitungsbefehle (`r`/`~`/`J`/`x`/`D`/`C`), Operatoren (`d`/`c`/`y`), „Yank and put“ (`y`/`p`/`P`), Wiederholung (`.`), Rückgängigmachen und Wiederholen (`u`/Strg+R), Anzahl und Esc, um zum normalen Modus zurückzukehren. Auch konfigurierbar mit der `editorMode` Einstellung. Siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#user-settings-copilotsettingsjson). | | `/voice [on\|off\|models\|devices]` | Schalten Sie den Sprachmodus ein, durchsuchen Sie die verfügbaren Sprachmodelle, oder wählen Sie das Eingabegerät (Mikrofon) aus. | | `/workflows` | Beobachten Sie Workflowausführungen, Phasen, Agents und Fortschritt. Erfordert einen tokenbasierten Abrechnungsplan. Siehe [Verwenden `copilot workflow run`](#using-copilot-workflow-run), um einen registrierten Workflow direkt auszuführen. | | `/fork [NAME]`, `/branch [NAME]` | Verzweigen Sie die aktuelle Sitzung in eine neue Sitzung, optional mit einem Namen. Auch nutzbar, während der Agent läuft – die Quellsitzung funktioniert weiterhin im Hintergrund. `/fork worktree` erstellt unter Beibehaltung des Gesprächskontexts aus der aktuellen Sitzung einen neuen Git-Worktree, der von `HEAD` abzweigt. | | `/worktree [branch\|task]` | Erstellen Sie einen neuen Git-Worktree und wechseln Sie zu ihm, wobei nicht festgeschriebene Änderungen im aktuellen Worktree zurückbleiben. Geben Sie einen Branchnamen, eine Aufgabenbeschreibung (mehrzeilige Eingaben werden unterstützt und als anfängliche Eingabe im neuen Worktree verwendet) an, oder lassen Sie das Argument weg, um automatisch einen Branchnamen aus der Konversation zu generieren. Verzweigt standardmäßig von der aktuellen Checkout-Position aus (`HEAD`); setzen Sie die Einstellung `worktreeBaseRef` auf `"defaultBranch"`, um stattdessen von der Remote-Standard-Verzweigung abzuzweigen. Siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#user-settings-copilotsettingsjson). Erfordert ein Git-Repository. | | `/worktree new [PROMPT]` | Veraltet – stattdessen verwenden `/new worktree` . Startet eine neue Unterhaltung in einem neuen Git-Worktree, wobei die aktuelle Unterhaltung und das Arbeitsverzeichnis unverändert bleiben. Geben Sie optional die erste Eingabeaufforderung an. | | `new` ist als Schlüsselwort des Unterbefehls reserviert und kann nicht als Literalzweigname verwendet werden. Folgt der gleichen `worktreeBaseRef` Einstellung wie `/worktree`. | | | `/move [branch\|task]` | Verschieben Sie nicht festgeschriebene Änderungen in einen neuen Git-Worktree und wechseln Sie dorthin. Geben Sie einen Branchnamen, eine Aufgabenbeschreibung (mehrzeilige Eingaben werden unterstützt und als anfängliche Eingabe im neuen Worktree verwendet) an, oder lassen Sie das Argument weg, um automatisch einen Branchnamen aus der Konversation zu generieren. Erfordert ein Git-Repository. | Eine vollständige Liste der verfügbaren Slash-Befehle erhalten Sie durch Eingeben von `/help` auf der interaktiven Benutzeroberfläche der CLI. Verwenden Sie im Terminplan-Manager, der über `/every` oder `/after` geöffnet wird, ↑/↓, um einen Eintrag auszuwählen, und `x`, um ihn zu entfernen. Zeitpläne können nur über die Prompt-Eingabe mithilfe von `/every` oder `/after` mit Argumenten hinzugefügt werden – das Dialogfeld selbst ist nur zum Anzeigen und Entfernen vorgesehen. In der Fußzeile wird standardmäßig ein Indikator „N geplant“ angezeigt, sobald die Sitzung aktive Zeitpläne hat, auch wenn `/every` und `/after` für Sie nicht aktiviert sind. `/plugin` kennzeichnet ein installiertes Plug-In oder Marketplace, wenn eine neuere Version upstream verfügbar ist, und bietet eine **Update-Aktion** aus dem Dashboard an. `/mcp list` / `ls` und `/plugin list`/`ls` (einschließlich reinem `/plugin`) sind schreibgeschützt und können ausgeführt werden, während der Agent gerade einen Durchgang verarbeitet. Alle anderen Unterbefehle `/mcp` und `/plugin` sind gesperrt, bis der Vorgang abgeschlossen ist. > [!NOTE] > Der experimentelle `/plugins` Befehl wurde entfernt. Die Ressourcen wurden nach `/plugin`, `/mcp` und `/skills` verschoben. Verwenden `/subagents` und `/instructions` für Agenten und Anweisungen. ### Sammeln und Freigeben von Debugprotokollen Verwenden Sie `/collect-debug-logs [file|gist|share] [PATH]`, um Debug-Protokolle für die Problembehandlung zu sammeln: | Ziel | Beschreibung | | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ | | `file` | Speichern Sie die Protokolle in einem lokalen Archiv unter `PATH` (Standardspeicherort, der verwendet wird, wenn `PATH` weggelassen wird). | | `gist` | Laden Sie die Protokolle in einen geheimen GitHub Gist hoch. | | `share` | Speichern Sie ein lokales Archiv, und laden Sie es dann zu GitHub hoch. | `/collect-debug-logs share`, und die Option für Feedback mit Protokollen, die von `/feedback` angeboten wird, speichern Sie zuerst ein lokales Archiv und bitten Sie dann vor dem Hochladen zu \*\*\*\* um erneute Zustimmung (standardmäßig GitHub). Das Hochladen ist derzeit nur für GitHub Mitarbeiter und interne Benutzer verfügbar und ist noch nicht allgemein verfügbar. Benutzer außerhalb von GitHub verwenden weiterhin die vorhandenen Archiv- und Gist-Routen und die vorhandene öffentliche Feedbackroute. ## Befehlszeilenoptionen | Auswahl | Purpose | | | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | | `--add-dir=PATH` | Dateizugriff auf ein Verzeichnis zulassen und seine Skills (`.github/`, `.agents/`, `.claude/`) und Agenten (`.github/`, `.claude/`) als vertrauenswürdige Konfigurationen laden (kann mehrmals verwendet werden). Ein relativer Pfad wird unabhängig von der Reihenfolge der Optionen relativ zum Arbeitsverzeichnis der Sitzung (dem Verzeichnis `--resume`, `--worktree` oder `-C`) aufgelöst. Der Pfad muss ein vorhandenes Verzeichnis sein– ein fehlender Pfad oder eine normale Datei schlägt den Start sofort mit einem Flag-spezifischen Fehler auf die gleiche Weise in jedem Modus fehl. | | | `--add-github-mcp-tool=TOOL` | Fügen Sie ein Tool hinzu, um den GitHub MCP-Server anstelle der standardmäßigen CLI-Teilmenge zu aktivieren (kann mehrmals verwendet werden). Verwenden Sie `*` für alle Tools. | | | `--add-github-mcp-toolset=TOOLSET` | Fügen Sie ein Toolset hinzu, um den GitHub MCP-Server anstelle der standardmäßigen CLI-Teilmenge zu aktivieren (kann mehrmals verwendet werden). Verwenden Sie `all` für alle Toolsets. | | | `--additional-mcp-config=JSON` | Fügen Sie nur einen MCP-Server für diese Sitzung hinzu. Die Serverkonfiguration kann als JSON-Zeichenfolge oder als Dateipfad (Präfix mit `@`) bereitgestellt werden. Ein relativer `@file` Pfad wird unabhängig von der Optionsreihenfolge relativ zum Arbeitsverzeichnis der Sitzung (dem `--resume`-, `--worktree`- oder `-C`-Verzeichnis) aufgelöst. Erweitert die Konfiguration von `~/.copilot/mcp-config.json`. Überschreibt jede installierte MCP-Serverkonfiguration mit demselben Namen. Siehe [Hinzufügen von MCP-Servern für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers). | | | `--agent=AGENT` | Geben Sie eine custom agent an, die verwendet werden soll. Siehe [Benutzerdefinierte Agents](/de/copilot/concepts/customizations/custom-agents). | | | `--allow-all` | Alle Berechtigungen aktivieren (entspricht `--allow-all-tools --allow-all-paths --allow-all-urls`). | | | `--allow-all-mcp-server-instructions` | Schließen Sie Initialisierungsanweisungen von allen MCP-Servern in die Systemaufforderung ein. Standardmäßig sind nur zugelassene Serveranweisungen im Vorfeld enthalten; Die Anweisungen anderer Server werden bei Bedarf abgerufen. | | | `--allow-all-paths` | Deaktivieren Sie die Überprüfung des Dateipfads, und erlauben Sie den Zugriff auf einen beliebigen Pfad. | | | `--allow-all-tools` | Gewähren Sie allgemeine Tool-Berechtigungen ohne Modellsicherheitsprüfung oder individuelle Genehmigungsaufforderungen. Es gelten weiterhin Verweigerungsregeln und Unternehmenseinschränkungen (env: `COPILOT_ALLOW_ALL`). | | | `--allow-all-urls` | Zugriff auf alle URLs ohne Bestätigung zulassen. | | | `--allow-tool=TOOL ...` | Tools, die von der CLI verwendet werden dürfen. Fordert keine Erlaubnis an. Verwenden Sie für mehrere Tools eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. Siehe [Zulassen und Verweigern der Verwendung von Tools](/de/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools#allowing-or-denying-permission-for-specific-tools). | | | `--allow-url=URL ...` | Zugriff auf bestimmte URLs oder Domänen zulassen. Verwenden Sie für mehrere URLs eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. | | | `--acp` | Als Server für das Agent-Client-Protokoll starten. | | | `--assisted-approval` | Aktivieren Sie assisted permissions für die Ausführung, damit eine Sicherheitsüberprüfung berechtigte Berechtigungsanforderungen genehmigen kann. Nur gültig für nicht interaktive Ausführungen, d. h. Ausführungen, die `-p` oder `--prompt` verwenden und in einer Umgebung ohne angeschlossenes Terminal ausgeführt werden. Wenn sie erfolgreich aktiviert wurde, hat sie Vorrang vor `--allow-all-tools`, hat jedoch keine Auswirkungen auf `--allow-all-paths` oder `--allow-all-urls` (env: `COPILOT_ASSISTED_APPROVAL`). Siehe [Zulassen der Ausführung sicherer Befehle ohne manuelle Genehmigung](/de/copilot/concepts/customizations/allowing-safe-commands). | | | `--attachment PATH` | Fügen Sie eine Datei an die anfängliche Eingabeaufforderung an (kann mehrmals verwendet werden). Bilddateien werden akzeptiert, aber für ein erfolgreiches Senden müssen das ausgewählte Modell und die Organisationsrichtlinie Bildeingaben zulassen. | | | `--autopilot` | Autopilot-Fortsetzung aktivieren – der Agent arbeitet weiter, bis `task_complete` aufgerufen wird, und kehrt dann in den interaktiven Modus zurück. Siehe [Verwenden des Autopilot-Modus in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/use-autopilot-mode). | | | `--available-tools=TOOL ...` | Nur diese Tools sind für das Modell verfügbar. Verwenden Sie für mehrere Tools eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. Siehe [Zulassen und Verweigern der Verwendung von Tools](/de/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools). | | | `--banner`, `--no-banner` | Ein- oder Ausblenden des Startbanners. | | | `--bash-env` | Aktiviert `BASH_ENV`- Unterstützung für Bash-Shells. | | | `-C DIRECTORY` | Ändern Sie das Arbeitsverzeichnis, bevor Sie etwas anderes ausführen. | | | `--connect[=SESSION-ID]` | Stellen Sie eine direkte Verbindung mit einer Remotesitzung her (optional geben Sie eine Sitzungs-ID oder Aufgaben-ID an). Konflikte mit `--resume` und `--continue`. | | | `--context TIER`. | Legen Sie die Stufe des Kontextfensters für Modelle mit gestaffelter Preisgestaltung fest (setzt die gespeicherte Einstellung außer Kraft und wird in neuen interaktiven Sitzungen angewendet). Optionen: "default", "long\_context". | | | `--config-dir=DIRECTORY` | Diese Option zum Festlegen des Konfigurationsverzeichnisses ist veraltet. Verwenden Sie stattdessen die `COPILOT_HOME` Umgebungsvariable. | | | `--continue` | Setzen Sie die letzte Sitzung im aktuellen Arbeitsverzeichnis fort oder nutzen Sie gegebenenfalls die global zuletzt verwendete Sitzung. Konflikte mit `--resume`. | | | `--deny-tool=TOOL ...` | Tools, die von der CLI nicht verwendet werden dürfen. Fordert keine Erlaubnis an. Verwenden Sie für mehrere Tools eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. | | | `--deny-url=URL ...` | Der Zugriff auf bestimmte URLs oder Domänen wird verweigert; hat Vorrang vor `--allow-url`. Verwenden Sie für mehrere URLs eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. | | | `--disable-builtin-mcps` | Deaktivieren Sie den integrierten Server für diese Ausführung. Dadurch werden nicht alle vom Plug-In bereitgestellten Server deaktiviert. Siehe [Integrierte MCP-Server](#built-in-mcp-servers) für die betroffenen Server und Informationen zum Deaktivieren der Computernutzung. | | | `--disable-client-telemetry` | Deaktivieren Sie telemetrie, die von der CLI gesendet wird. Wirkt sich nicht auf die serverseitige Telemetrie aus. | | | `--disable-mcp-server=SERVER-NAME` | Deaktivieren Sie einen bestimmten MCP-Server (kann mehrmals verwendet werden). | | | `--disallow-temp-dir` | Verhindern des automatischen Zugriffs auf das temporäre Systemverzeichnis. | | | `--effort=LEVEL`, `--reasoning-effort=LEVEL` | Legen Sie die Aufwandsstufe für die Begründung fest (`low`, `medium`, `high`, `xhigh`, ). `max` `max` ist die Stufe mit der größten Tiefe für Anthropic-Modelle. | | | `--enable-all-github-mcp-tools` | Aktivieren Sie alle GitHub MCP-Server-Tools anstelle der standardmäßigen CLI-Teilmenge. Überschreibt die Optionen `--add-github-mcp-toolset` und `--add-github-mcp-tool`. | | | `--enable-mcp-server=SERVER-NAME` | Aktivieren Sie einen MCP-Server, der in Ihren Einstellungen deaktiviert ist, nur für diese Sitzung (kann mehrmals verwendet werden). Die Änderung wird nicht in Ihrer Konfiguration gespeichert. | | | `--enable-memory` | Aktivieren Des Speichers im Eingabeaufforderungsmodus (standardmäßig deaktiviert). | | | `--enable-reasoning-summaries` | Veraltete Kompatibilitätsoption (akzeptiert, aber ignoriert). Detaillierte Begründungszusammenfassungen für die Unterstützung von OpenAI-Modellen werden standardmäßig angezeigt. Schalten Sie sie mit STRG+T um. | | | `--excluded-tools=TOOL ...` | Diese Tools sind für das Modell nicht verfügbar. Verwenden Sie für mehrere Tools eine in Anführungszeichen gesetzte, durch Kommas getrennte Liste. | | | `--experimental` | Aktivieren Sie experimentelle Features (verwenden Sie `--no-experimental`, um zu deaktivieren). | | | `--extension-sdk-path DIRECTORY` | Überschreiben Sie das gebündelte `@github/copilot-sdk`, das in Erweiterungsunterprozesse eingefügt wird, durch einen lokalen Ordner `copilot-sdk/`. Bei ungültigen Pfaden wird auf das gebündelte SDK zurückgegriffen. | | | `--fleet` | Führen Sie den Prompt im Fleet-Modus aus (parallele Subagenten-Orchestrierung). Kombinieren Sie dies mit `-i`, `-p` oder einer weitergeleiteten Standardeingabe. Dies erfordert eine Eingabeaufforderung aus einer dieser Quellen und wirkt sich nicht allein aus. Dies ist gleichbedeutend damit, einer interaktiven Eingabe den Schrägstrichbefehl `/fleet` voranzustellen. Mit `-p` oder weitergeleiteter Eingabe führt es dieselbe Flottenorchestrierung nicht interaktiv aus. Siehe [Beschleunigen des Aufgabenabschlusses mit dem \`/fleet\` Befehl](/de/copilot/how-tos/copilot-cli/use-copilot-cli/speed-up-task-completion). | | | `-h`, `--help` | Hilfe anzeigen. | | | `-i PROMPT`, `--interactive=PROMPT` | Starten Sie eine interaktive Sitzung, und führen Sie diese Eingabeaufforderung automatisch aus. | | | `--log-dir=DIRECTORY` | Legen Sie das Protokolldateiverzeichnis fest (Standard: `~/.copilot/logs/`). Ein führendes `~` wird zu Ihrem Home-Verzeichnis expandiert. | | | `--log-level=LEVEL` | Legen Sie die Protokollebene fest (Auswahlmöglichkeiten: `none`, `error`, `warning`, , `info`, `debug`, , `all`). `default` | | | `--max-ai-credits=CREDITS` | Legen Sie ein Soft-Limit für die pro Antwort zulässigen KI-Guthaben fest. Das Limit wird mit jeder Benutzernachricht zurückgesetzt und kann mit `/limits` während der Sitzung angepasst werden. Siehe [Festlegen eines AI credit Sitzungslimits in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit). | | | `--max-autopilot-continues=COUNT` | Maximale Anzahl automatischer Fortsetzungen außerhalb eines aktiven Autopilot-Ziels (Standard: 5). Muss eine nicht negative ganze Zahl sein. Falsch formatierte Werte (`NaN`, negative, gebrochene oder in wissenschaftlicher Notation angegebene Werte) werden abgelehnt. Siehe [Verwenden des Autopilot-Modus in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/use-autopilot-mode). | | | `--mode=MODE` | Legen Sie den anfänglichen Agentmodus fest (Auswahlmöglichkeiten: `interactive`, `plan`, `autopilot`). Kombinieren Sie dies mit `--plan` (als `--plan --mode autopilot`) für „plan-then-autopilot“: Die Sitzung beginnt im Planmodus und wechselt automatisch in den Autopilotmodus, sobald der Plan fertig ist, anstatt darauf zu warten, dass ein Mensch ihn genehmigt. Alle anderen `--plan --mode MODE` Kopplungen werden abgelehnt. | | | `--model=MODEL` | Legen Sie das KI-Modell fest, das Sie verwenden möchten. Übergeben Sie `auto` als Wert, damit Copilot automatisch das beste verfügbare Modell auswählt. Ein expliziter `--model` Wert hat Vorrang vor dem benutzerdefinierten Agenten `model`, es sei denn, der Agent setzt `model-policy: required`. Siehe [Über GitHub Copilotauto model selection](/de/copilot/concepts/models/auto-model-selection). | | | `--mouse[=VALUE]` | Aktivieren oder deaktivieren Sie die Mausunterstützung in der interaktiven Benutzeroberfläche. WERT kann `on` (Standard) oder `off`. Wenn diese Option aktiviert ist, erfasst die CLI Mausereignisse ( Scrollrad, Klicks usw.), um in einer eigenen Benutzeroberfläche zu navigieren, z. B. das Scrollen der Zeitachse oder das Klicken auf Registerkarten. Wenn dies deaktiviert ist, wird das systemeigene Mausverhalten des Terminals, z. B. Textauswahl und Bildlaufback, beibehalten. Wenn Sie diese Option explizit festlegen, wird der Wert in Ihrer Konfigurationsdatei beibehalten. | | | `-n NAME`, `--name=NAME` | Legen Sie einen Namen für die neue Sitzung fest. Wird von `--resume` und `/resume` verwendet, um Sitzungen anhand des Namens zu finden. | | | `--no-ask-user` | Deaktivieren Sie das `ask_user` Tool (der Agent funktioniert autonom, ohne Fragen zu stellen). | | | `--no-auto-update` | Deaktivieren Sie automatische CLI-Updates, und verhindern Sie, dass eine neuere zwischengespeicherte Version anstelle der installierten Version ausgeführt wird. | | | `--no-bash-env` | Deaktivieren Sie `BASH_ENV` die Unterstützung für Bash-Shells. | | | `--no-color` | Alle Farbausgabe deaktivieren. | | | `--no-custom-instructions` | Deaktivieren Sie das Laden von benutzerdefinierten Anweisungen aus `AGENTS.md` sowie verwandten Dateien. | | | `--no-experimental` | Deaktivieren Sie experimentelle Features. | | | `--no-mouse` | Deaktivieren Sie die Mausunterstützung. | | | `--no-remote` | Entfernt. Verwenden Sie `/remote off` während einer interaktiven Sitzung, um deren Remoteverbindung zu beenden. | | | `--no-remote-export` | Umbenannt in `--sync-session=off`. | | | `--output-format=FORMAT` | FORMAT kann `text` (Standard) oder `json` (Ausgabe JSONL: ein JSON-Objekt pro Zeile) sein. | | | `-p PROMPT`, `--prompt=PROMPT` | Führen Sie einen Prompt programmgesteuert aus (beendet nach Abschluss oder mit einem Nicht-Null-Status, wenn die Ausführung unterbrochen wird). Die Zusammenfassung beim Beenden enthält einen `copilot --resume=SESSION-ID` Hinweis zum Fortsetzen der Sitzung. Verwenden Sie `@` gefolgt von einer Datei oder einem Verzeichnispfad in der Eingabeaufforderung, um sie als Kontext einzuschließen, z. B `copilot -p "Explain @src/app.js"`. . Siehe [Programmatisches Ausführen GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically). | | | `--plan` | Starten Sie im Planmodus. Kurzform für `--mode plan`. Kann nicht mit `--autopilot` kombiniert werden. Kann mit `--mode autopilot` für „plan-then-autopilot“ kombiniert werden; jeder andere Wert für `--mode` wird zurückgewiesen. | | | `--plain-diff` | Erweiterte Diff-Darstellung deaktivieren (Syntaxhervorhebung mithilfe des in Ihrer Git-Konfiguration angegebenen Diff-Tools). | | | `--plugin-dir=DIRECTORY` | Laden Sie ein Plug-In aus einem lokalen Verzeichnis (kann mehrmals verwendet werden). Ein relativer Pfad wird unabhängig von der Reihenfolge der Optionen relativ zum Arbeitsverzeichnis der Sitzung (dem Verzeichnis `--resume`, `--worktree` oder `-C`) aufgelöst. Agenten, die von einem `--plugin-dir`-Plugin bereitgestellt werden, sind in Sitzungen im Servermodus (`--server`) sowie in interaktiven und `-p`-Sitzungen verfügbar. | | | `--remote` | Wird für den interaktiven Start oder mit `-p`. Verwenden Sie `/remote on` stattdessen während einer interaktiven Sitzung. Das Flag wird für den Legacy-SDK-Serverstart mit `--server` oder `--headless` weiterhin unterstützt. Siehe [Steuern einer GitHub Copilot CLI Sitzung von einem anderen Gerät](/de/copilot/how-tos/copilot-cli/use-copilot-cli/steer-remotely). | | | `--remote-export` | Umbenannt in `--sync-session=on`. | | | `-r`, `--resume[=VALUE]` | Setzen Sie eine vorherige interaktive Sitzung fort, indem Sie eine Liste auswählen. Geben Sie optional eine Sitzungs-ID, ein ID-Präfix oder einen Sitzungsnamen an. Der Namensabgleich ist exakt und unabhängig von Groß- und Kleinschreibung; es wird auf die automatisch generierte Zusammenfassung zurückgegriffen, wenn keine expliziten Namensübereinstimmungen vorliegen. Konflikte mit `--continue`. Minimal `--resume` (kein Wert) zeigt eine interaktive Sitzungsauswahl an, die ein TTY erfordert. Wenn mehrere Sitzungen vorhanden sind und die Auswahl nicht angezeigt werden kann (z. B. unter `-p`, bei einem Nicht-TTY-`-i` oder bei umgeleiteter Standardeingabe), wird die CLI mit einem Fehler beendet, anstatt stillschweigend eine neue Sitzung zu starten – geben Sie explizit `--resume=SESSION-ID` an oder verwenden Sie `--continue`. | | | `-s`, `--silent` | Gibt nur die Agent-Antwort aus (ohne Nutzungsstatistiken). Dies ist nützlich für die Skripterstellung mit `-p`. | | | `--screen-reader` | Optimierungen für die Sprachausgabe nur für diese Sitzung aktivieren und anbieten, die Einstellung in Ihren Einstellungen zu speichern. | | | `--secret-env-vars=VAR ...` | Entfernen Sie eine Umgebungsvariable aus der Shell- und MCP-Server-Umgebung (kann mehrfach verwendet werden). Verwenden Sie für mehrere Variablen eine angeführte, kommagetrennte Liste. Die Werte in den `GITHUB_TOKEN`- und `COPILOT_GITHUB_TOKEN`-Umgebungsvariablen werden standardmäßig aus der Ausgabe entfernt. | | | `--session-id ID` | Verwenden Sie eine genaue Sitzungs- oder Aufgaben-ID, wenn Sie keinen umfassenderen Abgleich nach ID-Präfix oder Sitzungsname wünschen `--resume`. Wenn die ID einer vorhandenen Sitzung oder Aufgabe entspricht, wird diese Sitzung oder Aufgabe fortgesetzt. Wenn nichts übereinstimmt, wird nur eine neue Sitzung erstellt, wenn der Wert eine gültige UUID ist. Namen und ID-Präfixe erstellen keine neuen Sitzungen. Kombinieren Sie diese Option nicht mit anderen Sitzungsauswahl- oder Sitzungsstartoptionen wie `--resume`, `--continue`oder `--connect`, da sie konkurrieren, um zu entscheiden, welche Sitzung geöffnet oder erstellt werden soll. | | | `--trust-folder` | Vertrauen Sie den Hooks des Arbeitsverzeichnisses, den MCP-Servern des Arbeitsbereichs und den Einstellungen des Repository-Plug-Ins für eine neue, nicht interaktive Sitzung (`-p` oder weitergeleitete Standardeingabe). Das Vertrauen wird nicht in `trustedFolders` gespeichert und ist keine Tool- oder Pfadberechtigungserteilung. Kann nicht mit `--resume`, `--continue`oder `--session-id`. | | | `--sandbox` | Aktivieren Sie den Shell-Sandkasten auf Betriebssystemebene nur für diese Sitzung, ohne die gespeicherte Sandkasteneinstellung zu ändern. Verwendbar mit `-p`. | | | `--no-sandbox` | Deaktivieren Sie das lokale Sandboxing nur für diese Sitzung, ohne Ihre gespeicherte Sandboxing-Einstellung zu ändern. Diese Option wird ignoriert, wenn eine unternehmensverwaltete Richtlinie konfiguriert wurde, die Sandboxing erzwingt. | | | `--share=PATH` | Teilen einer Sitzung als Markdown-Datei nach Abschluss einer programmgesteuerten Sitzung (Standardpfad: `./copilot-session-.md`). | | | `--share-gist` | Teilen Sie eine Sitzung nach Abschluss einer programmatischen Sitzung mit einem geheimen GitHub Gist. | | | `--stream=MODE` | Aktivieren oder deaktivieren Sie den Streamingmodus, der die Antwort von Copilot während der Generierung schrittweise anzeigt, anstatt auf das Eintreffen der vollständigen Antwort zu warten (Modusoptionen: `on` oder `off`, Standard: `on`). | | | `--sync-session[=on\|off]` | Aktivieren oder Deaktivieren der schreibgeschützten Sitzungsverlaufssynchronisierung für diese Ausführung. Ohne einen Wert wird die Synchronisierung ermöglicht. Aktiviert die Fernsteuerung nicht. Wenn sie weggelassen wird, werden Ihre Einstellungen und das Standardverhalten verwendet. Die Synchronisierung wird verweigert, wenn die Cloudsitzungsspeicherrichtlinie Ihrer Organisation deaktiviert ist oder nicht bestimmt werden kann. | | | `-v`, `--version` | Versionsinformationen anzeigen. | | | `-w`, `--worktree[=NAME]` | Erstellen oder verwenden Sie standardmäßig einen isolierten Git-Worktree unter `.worktrees/` erneut und starten Sie die Sitzung darin. Verwenden Sie die `worktreePathTemplate` Einstellung, um den Speicherort zu konfigurieren. `NAME` ist optional – lassen Sie ihn weg, um automatisch einen Verzweigungsnamen zu generieren. Verzweigt standardmäßig von der aktuellen Checkout-Position aus (`HEAD`); setzen Sie die Einstellung `worktreeBaseRef` auf `"defaultBranch"`, um stattdessen von der Remote-Standard-Verzweigung abzuzweigen. Konflikte mit `--resume`, `--continue`und `--connect`. | | | `--yolo` | Alle Berechtigungen aktivieren (entspricht `--allow-all`). | | Um eine vollständige Liste der Befehle und Optionen zu erhalten, führen Sie `copilot help` aus. > [!NOTE] > Remote-Sitzungsfunktionen setzen die Verfügbarkeit in Ihrem Konto voraus. Die Legacyoption `--remote` ist kein Interaktives Sitzungssteuerelement und `--no-remote` wird nicht mehr unterstützt. > > Um die Remotesteuerung während einer interaktiven Sitzung zu aktivieren, verwenden Sie `/remote on`. Verwenden Sie `/remote off`zum Beenden der Remoteverbindung . War eine Sitzung noch geöffnet, als ihr CLI-Prozess beendet wurde, z. B. aufgrund eines Absturzes oder eines Neustarts des Rechners, wird Ihnen beim nächsten Start von `copilot` die Option angeboten, sie wiederherzustellen. Sie können die verfügbaren Sitzungen überprüfen, um stattdessen eine neue Sitzung wiederherzustellen oder zu starten. Eine wiederhergestellte Sitzung, deren Agent sich mitten in einem Durchgang befand, nimmt diese Arbeit automatisch wieder auf. ### Erst planen, dann Autopilot Plan-then-autopilot ermöglicht es einer Sitzung im Planmodus zu starten und automatisch in den Autopilot-Modus zu fahren, sobald der Plan fertig ist, ohne darauf zu warten, dass ein Mensch den Übergang genehmigt. Aktivieren Sie dies mit `--plan --mode autopilot`, oder mit der Umgebungsvariablen `COPILOT_PLAN_THEN_AUTOPILOT` für Harnesses, die nur Umgebungsvariablen setzen, aber keine Befehlszeilenoptionen übergeben können. Wenn beides festgelegt ist, haben die expliziten Optionen Vorrang, und die CLI zeigt eine Warnung an, dass die Umgebungsvariable ignoriert wurde. ### Unternehmensverwaltete Sandkastenfläche Eine vom Unternehmen verwaltete Richtlinie kann die Shell-Sandboxing auf Betriebssystemebene als Mindestebene erzwingen. Mit anderen Worten: Selbst wenn Sie `--no-sandbox` übergeben, kann die Richtlinie die Ausführung in einer Sandbox weiterhin erzwingen. Dies ist eine Richtlinienausnahme, nicht ein Fehler der Option selbst. Im Gegensatz dazu ist `--sandbox` nicht betroffen, da es Sandboxing nur aktiviert und nie entfernt. Wenn die geltende Richtlinie die Umgehung der Sandbox zulässt, können Sie die Sandbox für den Rest der aktuellen Sitzung explizit deaktivieren, wenn Sie auf eine aktive Aufforderung zur Erteilung einer Umgehungsberechtigung antworten. Wenn ein verwalteter Floor Sandboxing mit einem effektiven `sandbox.allowBypass` von `true` erzwingt (die Standardeinstellung, wenn eine Richtlinie nur `sandbox.enabled` auf `true` setzt), führen Sie `/sandbox disable` aus, um die Sandbox für den Rest der aktuellen Sitzung zu deaktivieren – zuvor ist keine Umgehungsaufforderung erforderlich. Die Deaktivierung gilt nur für die aktuelle Sitzung: Nichts wird in `settings.json` gespeichert, eine neue Sitzung startet erneut in der Sandbox, und `/sandbox enable` stellt die Sandbox sofort wieder her, ohne auf eine neue Sitzung zu warten. Wenn `allowBypass` auf `false` gesetzt ist, verweigert `/sandbox disable` dies mit der Meldung, dass Sandboxing durch die verwaltete Richtlinie erzwungen wird und nicht deaktiviert werden kann. Wenn eine verwaltete Richtlinie Ihre Einstellung außer Kraft setzt, zeigt die CLI eine Warnung in der interaktiven Zeitachse (oder bei Stderr bei Verwendung `-p`) an, sodass klar ist, dass das Verhalten von der Richtlinienerzwingung stammt, anstatt dass die Option nicht funktioniert. Wenden Sie sich an Ihren Administrator, wenn die Richtlinie geändert werden muss. Verwenden Sie `/sandbox status` oder `/sandbox policy`, um die effektiven Einschränkungen der Sitzung zu überprüfen. Das Hinzufügen der verwalteten Einstellung `sandbox.failIfUnavailable`, die auf `true` festgelegt ist, zusammen mit `sandbox.enabled`, das auf `true` festgelegt ist, macht die Sandbox obligatorisch, wenn sie nicht eingerichtet werden kann. Anstatt auf die Ausführung von Befehlen außerhalb der Sandbox zurückzufallen, blockiert Copilot die Ausführung von Modell und Tools, wenn die Richtlinie nicht von einem nutzbaren Sandbox-Backend validiert, kompiliert oder durchgesetzt werden kann. Siehe [Unternehmensverwaltete Einstellungen](/de/copilot/reference/enterprise-administrators/enterprise-managed-settings#sandbox). Die CLI warnt auch, wenn eine verwaltete Richtlinie Sandboxing für eine Sitzung aktiviert, die Sie nicht angefordert haben, und nicht nur, wenn sie `--no-sandbox` überschreibt. Dies schließt Sitzungen ein, bei denen die Richtlinie nach dem Start eingeht, da serververwaltete Einstellungen erst nach der Anmeldung verfügbar sind. Die Warnung entfällt, wenn Ihre eigenen Einstellungen oder die Option `--sandbox` bereits Sandboxing angefordert haben, da der Sitzungszustand dann zu erwarten ist. Wenn für ein Gerät eine verwaltete Richtlinie vorhanden ist, die nicht gelesen werden konnte, verweigert die CLI den Zugriff und erzwingt Sandboxing auf der höchstmöglichen Einschränkungsstufe. In dem Hinweis wird erläutert, dass die Richtlinie nicht bestimmt werden konnte und Sie auf die Lösung warten müssen. Die Startwarnung für einen nicht unterstützten Host verwendet denselben Wortlaut. ### Einschränken der Optionen für "Alle zulassen" Wenn auf gesetzt ist, werden beim Start alle Befehlszeilenoptionen, die sämtliche Berechtigungen erlauben (, , , , ), unterdrückt und können nicht verwendet werden, um erweiterte Berechtigungen zu gewähren. Die CLI zeigt eine Richtlinienwarnung an, wenn sie diese Optionen unterdrückt. Der `/permissions allow-all` Schrägstrichbefehl und seine Aliase `/allow-all` und `/yolo`, werden ebenfalls unterdrückt. Diese Einstellung deaktiviert assisted permissionsFunktionen nicht, die separat gesteuert werden. #### Was `disable` deaktiviert Wenn der Wert von `permissions.disableBypassPermissionsMode``disable` ist, haben die Befehlszeilenoptionen, die alle Berechtigungen gewähren, keine Auswirkung. Diese Optionen sind: `--allow-all-tools`, `--allow-all-paths`, `--allow-all-urls`, `--allow-all` und `--yolo`. Die Einschränkung gilt auch während einer interaktiven Sitzung. Schrägstrichbefehle, die den Modus "Alle zulassen" aktivieren würden, sind weiterhin verfügbar, werden jedoch mit einer Erläuterung abgelehnt. | Befehl | Ergebnis mit `disable` | | -------------------------------------------------------------------------- | ---------------------- | | `/permissions allow-all` | Refused | | `/allow-all` (sowie der Alias `/yolo`) ohne Argumente oder `on` | Refused | | `/permissions assisted` | Zulässig | | `/allow-all off``/allow-all show``/permissions default``/permissions show` | Zulässig | Wenn ein Befehl "Alle zulassen" abgelehnt wird, hängt die Nachricht davon ab, von wo die Einschränkung stammt. Eine Einschränkung aus Ihren eigenen Einstellungen lautet: "Der Modus zum Umgehen von Berechtigungen wurde in Ihren Einstellungen deaktiviert." Eine Einschränkung durch verwaltete oder MDM-Richtlinien meldet: "Der Modus für Umgehungsberechtigungen wurde von der Richtlinie deaktiviert." Weitere Informationen erhalten Sie von Ihrem Administrator.“ #### Unbekannte Werte Wenn `permissions.disableBypassPermissionsMode` auf einen Wert festgelegt ist, den diese Version nicht erkennt, lehnt die CLI ihn nicht ab. Stattdessen protokolliert den Wert und erzwingt `disable` als sicheren Standardwert. Eine falsch formatierte Richtlinie beschränkt weiterhin die Optionen für „Alle zulassen“, anstatt sie stillschweigend zuzulassen. #### Woher die Einstellung kommen kann Drei Quellen können `permissions.disableBypassPermissionsMode` festlegen. Sie werden in zunehmender Reihenfolge der Dauerhaftigkeit aufgeführt. | Quelle | Geltungsbereich | Durch Kontowechsel gelöscht? | | --------------------------------------------------------- | --------------- | -------------------------------------------------------------------------------------- | | Benutzereinstellungen (`~/.copilot/settings.json`) | Maschine | No. Sie gilt für alle Konten. | | Verwaltete Einstellungen (vom Server abgerufen pro Konto) | Account | Yes. Die CLI lädt die Richtlinie für das neu aktive Konto. | | MDM-Richtlinie (plist/Registrierung/Datei) | Gerät | Nie. Die Richtlinie auf Geräteebene wird nicht durch Kontowechsel außer Kraft gesetzt. | ### Verhalten der Einschränkung, wenn die Richtlinie nicht bestätigt werden kann Eine fehlgeschlagene Richtlinienüberprüfung lässt die Sitzung nicht unbedingt uneingeschränkt. Die CLI unterscheidet ein nicht verwaltetes Konto oder Gerät von einem solchen, dessen anwendbare verwaltete Richtlinie nicht bestätigt werden kann. * **Eine nicht bestätigte verwaltete Richtlinie kann Berechtigungen einschränken.** Während Richtlinienüberprüfungen ausstehen oder wenn die Richtlinie für ein verwaltetes Konto oder Gerät nicht bestätigt werden kann, kann die CLI die Berechtigungseskalation blockieren und eine explizite Genehmigung für Aktionen erfordern. Dies kann auch dann angewendet werden, wenn keine frühere Richtlinie die Optionen für "Alle zulassen" deaktiviert hat. * **Die Serverrichtlinie ist kontospezifisch.** Wenn eine Aktualisierung fehlschlägt, kann die zuvor abgerufene Richtlinie für dasselbe Konto wirksam bleiben. Das Wechseln von Konten lädt die Richtlinie des neuen Kontos, anstatt die Serverrichtlinie des vorherigen Kontos zu übernehmen. * **Geräteeinschränkungen bleiben über Konten hinweg erhalten.** Durch das Wechseln von Konten werden keine MDM-Einschränkungen oder Benutzereinstellungen entfernt, die Berechtigungsmodi blockieren. Eine Serverantwort, die die Einstellung auslässt, überschreibt diese Einschränkungen nicht. ## Unterstützte Modelle Verwenden Sie `--model=MODEL` oder die Umgebungsvariable `COPILOT_MODEL`, um das KI-Modell auszuwählen. Übergeben Sie `auto` an Copilot, um das beste verfügbare Modell automatisch auszuwählen. | Modell | Am besten geeignet für: | | ------------------- | -------------------------------------------------------------- | | `claude-sonnet-5.5` | Allgemeines Codieren (Standard) | | `gpt-6.1-sol` | Empfohlen, Opt-In (nicht die automatische Standardeinstellung) | | `gpt-6.1-terra` | Empfohlen, Opt-In (nicht die automatische Standardeinstellung) | | `gpt-6-astra` | Empfohlen, Opt-In (nicht die automatische Standardeinstellung) | | `gpt-6-luna` | Empfohlen, Opt-In (nicht die automatische Standardeinstellung) | | `claude-opus-5.5` | Empfohlene komplexe Aufgaben mit hoher Leistungsfähigkeit | | `claude-haiku-5.5` | Schnelle, schlanke Abläufe | | `claude-haiku-4.5` | Schnelle, schlanke Abläufe | | `gpt-5.3-codex` | Codeorientierte Aufgaben | | `gemini-3.8-flash` | Schnelle Google Gemini-Antworten | Sie können Modelle auch während einer interaktiven Sitzung mithilfe des `/model` Schrägstrichbefehls wechseln. ## Verfügbarkeitswerte für Tools Die Optionen `--available-tools` und `--excluded-tools` unterstützen diese Werte: ### Shell-Tools | Name des Tools | Beschreibung | | --------------------------------- | ---------------------------------------- | | `bash` / `powershell` | Befehle ausführen | | `list_bash` / `list_powershell` | Auflisten aktiver Shellsitzungen | | `read_bash` / `read_powershell` | Ausgabe aus einer Shellsitzung lesen | | `stop_bash` / `stop_powershell` | Beenden einer Shellsitzung | | `write_bash` / `write_powershell` | Senden von Eingaben an eine Shellsitzung | ### Dateivorgangstools | Name des Tools | Beschreibung | | -------------- | ---------------------------------------------------------------------------------- | | `apply_patch` | Anwenden von Patches (verwendet von einigen Modellen anstelle von `edit`/`create`) | | `create` | Erstellen neuer Dateien | | `edit` | Bearbeiten von Dateien über Zeichenfolgenersetzung | | `view` | Lesen von Dateien oder Verzeichnissen | ### Agenten- und Aufgaben-Delegierungstools | Name des Tools | Beschreibung | | -------------- | ------------------------------------------------ | | `list_agents` | Auflisten der verfügbaren Agents | | `read_agent` | Überprüfen des Status des Hintergrund-Agents | | `task` | Ausführen von Subagenten | | `write_agent` | Eine Nachricht an einen laufenden Agenten senden | ### Weitere Tools | Name des Tools | Beschreibung | | ------------------ | ------------------------------------------------- | | `ask_user` | Stellen Sie dem Benutzer eine Frage | | `glob` | Suchen nach Übereinstimmenden Mustern für Dateien | | `grep` (oder `rg`) | Suchen nach Text in Dateien | | `skill` | Aufrufen von benutzerdefinierten Fähigkeiten | | `web_fetch` | Abrufen und Analysieren von Webinhalten | ## Toolberechtigungsmuster Die `--allow-tool` Und `--deny-tool` Optionen akzeptieren Berechtigungsmuster im Format `Kind(argument)`. Das Argument ist optional. Wenn es ausgelassen wird, werden alle Tools dieser Art erfasst. | Kind | Beschreibung | Beispielmuster | | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------- | | `memory` | Fakten im Agentenspeicher speichern. Siehe [Informationen zu GitHub Copilot Memory](/de/copilot/concepts/agents/copilot-memory). | `memory` | | `read` | Datei- oder Verzeichnislesevorgänge | | | `read`, `read(.env)` | | | | `shell` | Shellbefehlsausführung | | | `shell(git push)`, `shell(git:*)``shell` | | | | `url` | URL-Zugriff über Web-Fetch oder Shell | | | `url(github.com)`, `url(https://*.api.com)` | | | | `write` | Dateierstellung oder -änderung | | | `write`, `write(src/*.ts)` | | | | SERVER-NAME | MCP-Server-Toolaufruf | | | `MyMCP(create_issue)`, `MyMCP` | | | Bei `shell` Regeln entspricht das `:*` Suffix dem Befehlsstamm gefolgt von einem Leerzeichen und verhindert partielle Übereinstimmungen. Zum Beispiel `shell(git:*)` entspricht `git push` und `git pull`, entspricht aber nicht `gitea`. Ablehnungsregeln haben immer Vorrang vor Erlaubnisregeln, auch wenn `--allow-all` festgelegt ist. ```shell # Allow all git commands except git push copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)' # Allow a specific MCP server tool copilot --allow-tool='MyMCP(create_issue)' # Allow all tools from a server copilot --allow-tool='MyMCP' # Deny writes to a specific path (exact or trailing-path-segment match; no glob support yet) copilot --deny-tool='write(secret.txt)' ``` `--deny-tool='write(PATH)'` grenzt die Verweigerung auf diesen Pfad ein – andere Schreibvorgänge bleiben davon unberührt. Der Abgleich löst Symlinks und `.`/`..`-Segmente auf und berücksichtigt unter macOS und Windows die Groß-/Kleinschreibung nicht. ## Umgebungsvariablen | Variable | Beschreibung | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `COPILOT_ALLOW_ALL` | Alle Berechtigungen automatisch zulassen (entspricht `--allow-all`). Akzeptiert `true`, `yes`, `1`, `on` oder `y` (Groß-/Kleinschreibung wird nicht beachtet, umgebende Leerzeichen werden ignoriert) zum Aktivieren; `false`, `0`, `off`, `no`, `n` oder einen leeren Wert zum Deaktivieren. Wenn Sie es auf genau `true` festlegen, wird auch dem Arbeitsverzeichnis ohne Rückfrage vertraut und es werden die Fähigkeiten, Plug-ins, MCP-Server und Hooks dieses Verzeichnisses geladen (einschließlich Hooks, die Shell-Befehle ausführen). Die anderen „wahr“-Schreibweisen führen nur zur automatischen Genehmigung durch Tools. | | `COPILOT_ASSISTED_APPROVAL` | Legen Sie den Wert auf `true` fest, um assisted permissions für eine nicht interaktive Ausführung zu aktivieren (entspricht `--assisted-approval`). | | `COPILOT_AUTO_UPDATE` | Legen Sie fest, dass `false` automatische Updates der CLI- und Erstanbieter-Plug-Ins deaktiviert werden sollen, und verhindern Sie, dass eine neuere zwischengespeicherte CLI-Version anstelle der installierten Version ausgeführt wird. | | `COPILOT_CACHE_HOME` | Überschreiben Sie das Cacheverzeichnis (verwendet für Marketplace-Caches, Automatischaktualisierungspakete und andere kurzlebige Daten). Siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#changing-the-location-of-the-configuration-directory) für Plattformstandardwerte. | | `COPILOT_CHILD_OOM_SCORE_ADJ` | Nur Linux. Setzt den `oom_score_adj`-Trend (Bias) außer Kraft, der auf von der CLI gestartete Prozessstrukturen von Shell-Befehlen angewendet wird, damit der Out-of-Memory (OOM)-Killer des Kernels eine außer Kontrolle geratene untergeordnete Prozessstruktur (zum Beispiel einen Build-Vorgang) vor der CLI selbst beendet. Standardwert: `300`. Bereich: `-1000`–`1000`. Auf `off` festlegen, um den Bias zu deaktivieren. | | `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` | Durch Trennzeichen getrennte Liste zusätzlicher Verzeichnisse für benutzerdefinierte Anweisungen. | | `COPILOT_EDITOR` | Editor-Befehl für die interaktive Bearbeitung (nach `$VISUAL` und `$EDITOR` überprüft). Wenn keine festgelegt sind, wird `vi` standardmäßig verwendet. | | `COPILOT_ENABLE_HTTP2` | Zum Aktivieren des HTTP/2-Transports auf `1` oder `true` setzen. HTTP/1.1 ist die Standardeinstellung. | | `COPILOT_ENABLE_INTERRUPTED_SESSION_RESTORE` | Legen Sie die Einstellung fest `1` , um die Wiederherstellung einer Sitzung zu aktivieren, die noch geöffnet war, wenn der CLI-Prozess beendet wurde, z. B. aufgrund eines Absturzes oder eines Neustarts eines Computers. Dieses Wiederherstellungsverhalten ist vorübergehend aktiviert, während das Startdialogfeld überarbeitet wird. Siehe [Wiederherstellen einer unterbrochenen Sitzung](#restoring-an-interrupted-session). | | `COPILOT_GH_HOST` | | | GitHub Hostname nur für Copilot CLI, wobei `GH_HOST` überschrieben wird. Verwenden Sie diese Option, wenn `GH_HOST` auf GitHub Enterprise Server zielt, aber Copilot sich gegen GitHub.com oder einem GitHub Enterprise Cloud Hostnamen authentifizieren muss. | | | `COPILOT_GITHUB_TOKEN` | Authentifizierungs-Token. Hat Vorrang vor `GH_TOKEN` und `GITHUB_TOKEN`. | | `COPILOT_HOME` | Überschreiben Sie das Konfigurations- und Statusverzeichnis. Standardwert: `$HOME/.copilot`. | | `COPILOT_LARGE_OUTPUT_THRESHOLD_BYTES` | Maximale UTF-8-Bytegröße für die Toolausgabe, die direkt an das Modell zurückgegeben wird. Standardwert: `20480` (20 KiB). Siehe [Verwalten des Kontexts für GitHub Copilot](/de/copilot/concepts/prompting-and-context/context-management#managing-large-tool-output-for-copilot-cli). | | `COPILOT_MCP_TOOL_CACHE` | Auf `false` festlegen, um das Laden und Speichern von Momentaufnahmen lokaler MCP-Server-Tools für den gesamten Prozess zu deaktivieren. Siehe [Caching von Tool-Snapshots](#tool-snapshot-caching). | | `COPILOT_MODEL` | Legen Sie das KI-Modell fest. | | `COPILOT_PLAN_THEN_AUTOPILOT` | Auf `1`, `on`, `true` oder `yes` festlegen, um für Harnesses, die nur Umgebungsvariablen einschleusen können, „plan-then-autopilot“ anzufordern (entspricht `--plan --mode autopilot`). Ignoriert, mit einer Warnung, wenn eine explizite `--mode`, `--autopilot`oder `--plan` Option übergeben wird. Siehe [Plan-then-autopilot](#plan-then-autopilot). | | `COPILOT_PROMPT_FRAME` | Stellen Sie auf `1`, um den dekorativen UI-Rahmen um die Eingabeaufforderung einzuschalten, oder auf `0`, um ihn auszuschalten. Überschreibt das experimentelle Funktionskennzeichen `PROMPT_FRAME` für die aktuelle Sitzung. | | `COPILOT_PROVIDER_API_KEY_COMMAND` | Shellbefehl, der vor jeder Anbieteranforderung einen neuen BRING-Your-Own-Key -API-Schlüssel (BYOK) druckt. Hat Vorrang vor der `COPILOT_PROVIDER_API_KEY` Umgebungsvariable. Die Ausgabe ersetzt den übereinstimmenden Header für Anmeldeinformationen auch dann, wenn ein über `COPILOT_PROVIDER_HEADERS` festgelegter benutzerdefinierter Header andernfalls zu einer Kollision führen würde. | | `COPILOT_PROVIDERS_CONFIG` | Pfad zu einer JSON-Datei, die einen BYOK-Anbieter (Bring-your-own-Key) und eine Modellregistrierung als Objekt mit `providers` und `models` Schlüssel definiert. Standardwert: `/providers.json`. Wenn in dieser Datei ein Anbieter oder ein Modell deklariert ist, hat dies Vorrang vor den älteren `COPILOT_PROVIDER_*` Legacy-Umgebungsvariablen. Siehe [`providers.json`](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#providersjson). | | `COPILOT_SKILLS_DIRS` | Durch Trennzeichen getrennte Liste zusätzlicher Verzeichnisse für Fähigkeiten. | | `PLUGINS_DASHBOARD` | Setzen Sie dies auf `false`, um das Plugin-Dashboard zu deaktivieren, das durch einfaches `/plugin`, `/mcp` und `/skills` geöffnet wird, sowie die nicht interaktiven Befehle `copilot plugin`/`copilot plugins` zu deaktivieren. | | `COPILOT_STRIP_REASONING_ON_RESUME` | Legen Sie den Wert auf `0` oder `false`, um BYOK-Reasoning-Token bei der Wiederaufnahme einer Sitzung beizubehalten, anstatt sie zu löschen. Standardmäßig werden sie entfernt. | | `COPILOT_SUBAGENT_MAX_CONCURRENT` | Maximale Anzahl gleichzeitiger Subagenten pro Sitzung (Standard: `32`, Bereich: `1`–`256`). | | `COPILOT_SUBAGENT_MAX_DEPTH` | Maximale Schachtelungstiefe für Subagenten (Standard: `4`, Bereich: `1`–`128`). | | `COPILOT_TASK_WAIT_TIMEOUT_SECONDS` | Maximale Sekunden `-p` (und `-p --autopilot`) wartet vor dem Beenden auf ausstehende Hintergrundprozesse oder Shell-Befehle, bis diese abgeschlossen sind (Standard: `600`; bei `0` erfolgt die Beendigung sofort, ohne zu warten). | | `GH_HOST` | | | GitHub Hostname für beide GitHub CLI und Copilot CLI (Standard: `github.com`). Legen Sie Ihren GitHub Enterprise Cloud Hostnamen für Datenresidenz fest. Überschreiben mit `COPILOT_GH_HOST` nur für Copilot CLI. | | | `GH_TOKEN` | Authentifizierungs-Token. Hat Vorrang vor `GITHUB_TOKEN`. | | `GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS` | Auf `true` festlegen, um Projekterweiterungen zu laden und Verwaltungstools für Erweiterungen im Prompt-Modus zuzulassen (`-p`). Standardmäßig deaktiviert, um das Ausführen von repositorygesteuertem Erweiterungscode ohne interaktive Vertrauensstellung zu verhindern. | | `GITHUB_COPILOT_PROMPT_MODE_REPO_HOOKS` | Auf `true` festlegen, um Repository Hooks im Prompt-Modus zu laden (`-p`). Repository-Hooks werden auch automatisch geladen, wenn der Ordner bereits vertrauenswürdig ist oder `COPILOT_ALLOW_ALL` festgelegt ist. | | `GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP` | Legen Sie `true` fest, um MCP-Quellen des Arbeitsbereichs im Aufforderungsmodus (`-p`) zu laden. Standardmäßig deaktiviert, um das Starten von vom Repository gesteuerten MCP-Servern ohne interaktive Vertrauensstellung zu verhindern. | | `GITHUB_TOKEN` | Authentifizierungs-Token. | | `PLAIN_DIFF` | Legt dies auf `true` fest, um Rich-Diff-Rendern zu deaktivieren. | | `USE_BUILTIN_RIPGREP` | Legt dies auf `false` fest, um den System-ripgrep anstelle der gebündelten Version zu verwenden. | | `USE_TGREP` | Legen Sie fest `true` , dass [tgrep](https://github.com/microsoft/tgrep), eine trigramindizierte Suchmaschine, auch außerhalb eines Git-Repositorys oder in einem virtualisierten oder Netzwerkdateisystem (z. B. VFS für Git-Auschecken oder SMB/9p-Mount) immer verwendet werden soll, oder `false` um ripgrep immer zu verwenden. Wenn tgrep außerhalb eines Git-Repositorys erzwungen ausgeführt wird, indexiert es das Arbeitsverzeichnis selbst. Sie sollten daher vermeiden, dies in einem großen Verzeichnis wie etwa Ihrem Home-Verzeichnis zu erzwingen. Windows-cloudsynchronisierte Ordner (z. B. OneDrive) verwenden immer ripgrep, auch wenn dies auf `true` festgelegt ist. Wenn dies nicht festgelegt ist, Copilot CLI wechselt automatisch von Ripgrep zu tgrep nur innerhalb eines Git-Repositorys, in einem nicht virtualisierten Dateisystem, und sobald er den durch die Dateianzahl festgelegten `TGREP_FILE_COUNT_THRESHOLD`Schwellenwert erreicht. Durch das Festlegen `USE_TGREP=true` wird dieser Schwellenwert vollständig umgangen. | | `USE_TGREP=false` deaktiviert weiterhin tgrep. | | | `TGREP_FILE_COUNT_THRESHOLD` | Minimale Dateianzahl für die automatische tgrep-indizierte Suche (nicht negative ganze Zahl; Standard: `10000` auf Windows, `50000` an anderer Stelle). Ungültige Werte werden auf den Standardwert der Plattform zurückgesetzt. | | `0` entfernt nur die Anforderung für die Dateianzahl . Andere automatische Startprüfungen gelten weiterhin. | | ## Konfigurationsdateieinstellungen Ausführliche Informationen zu Konfigurationsdateieinstellungen , einschließlich der vollständigen Liste der Benutzereinstellungen, Repositoryeinstellungen, lokalen Einstellungen und ihrer Weitergabe, finden Sie unter [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). ## Projektinitialisierung für Copilot Wenn Sie den Befehl `copilot init` oder den Schrägstrichbefehl `/init` in einer interaktiven Sitzung verwenden, analysiert Copilot Ihre Codebasis und schreibt oder aktualisiert eine `.github/copilot-instructions.md` Datei im Repository. Diese datei mit benutzerdefinierten Anweisungen enthält projektspezifische Anleitungen, die zukünftige CLI-Sitzungen verbessern. In der Regel verwenden `copilot init`Sie beim Starten eines neuen Projekts oder `/init`wenn Sie mit der Verwendung Copilot CLI in einem vorhandenen Repository beginnen. Die `copilot-instructions.md` Datei, die erstellt oder aktualisiert wird, dokumentiert normalerweise: * Erstellungs-, Test- und Lintenbefehle. * Architektur auf hoher Ebene * Codebasisspezifische Konventionen. Wenn die Datei bereits vorhanden ist, werden Verbesserungen vorgeschlagen, Copilot die Sie auswählen können, um sie anzuwenden oder abzulehnen. Die CLI sucht beim Start nach der `copilot-instructions.md` Datei, und wenn sie fehlt, wird die Meldung angezeigt: > 💡 Es wurden keine Copilot-Anweisungen gefunden. Führen Sie "/init" aus, um eine copilot-instructions.md Datei für dieses Projekt zu generieren. Wenn Sie diese Datei nicht erstellen möchten, können Sie diese Startmeldung für das aktuelle Repository dauerhaft ausblenden, indem Sie den `/init suppress` Schrägstrichbefehl verwenden. Weitere Informationen findest du unter [Hinzufügen von benutzerdefinierten Repositoryanweisungen für GitHub Copilot](/de/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions). Verwenden Sie `--no-sandbox` oder `copilot init` mit `--sandbox`, um die Shell-Sandbox auf Betriebssystemebene ausschließlich für die Initialisierungssitzung zu aktivieren oder zu deaktivieren, ohne Ihre gespeicherte Sandbox-Einstellung zu ändern. Diese Optionen unterliegen derselben unternehmensverwalteten Mindeststufe der Sandbox wie andere Einstiegspunkte — siehe [Unternehmensverwaltete Mindeststufe der Sandbox](#enterprise-managed-sandbox-floor). ### Speicherorte für benutzerdefinierte Anweisungen Copilot CLI lädt benutzerdefinierte Anweisungen von diesen Speicherorten gleichzeitig (alle werden zusammengeführt): | Ort | Hinweise | | -------------------------------------------------- | ----------------------------------------------------------- | | `CLAUDE.md` | In Git-Stammverzeichnis und cwd | | `GEMINI.md` | In Git-Stammverzeichnis und cwd | | `AGENTS.md` | In Git-Stammverzeichnis und cwd | | `.github/instructions/**/*.instructions.md` | In Git-Stammverzeichnis und cwd | | `.claude/rules/**/*.md` | In Git-Stammverzeichnis und cwd | | `.github/copilot-instructions.md` | In Git-Stammverzeichnis und cwd | | `$HOME/.copilot/copilot-instructions.md` | — | | `$HOME/.copilot/instructions/**/*.instructions.md` | — | | `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` | Zusätzliche Verzeichnisse mithilfe einer Umgebungsvariable. | Copilot CLI liest Claude Code-Regeldateien von `.claude/rules/**/*.md` auf die gleiche Weise, wie es Dateien von `.github/instructions/**/*.instructions.md` liest. Festlegen einer Regel auf übereinstimmende Dateien mit einem `paths` (oder `applyTo`) Frontmatterschlüssel: ```markdown --- paths: "src/api/**/*.ts" description: API layer conventions --- Use the shared `ApiError` type for all thrown errors in this directory. ``` Bereichsbezogene Regeln im Repository-Stammverzeichnis und im Arbeitsverzeichnis werden automatisch bereitgestellt, wenn der Agent eine übereinstimmende Datei liest oder bearbeitet. ### Importe von benutzerdefinierten Anweisungen Anleitungsdateien unterstützen Importe von `@path`. Stellen Sie einer Zeile `@` gefolgt von einem Pfad voran, um den Inhalt einer anderen Datei inline einzufügen. Pfade können relativ zum Verzeichnis der Anweisungsdatei oder absolut sein. Importe werden rekursiv bis zu einer maximalen Tiefe aufgelöst, mit Schutzmechanismen gegen Zyklen und Größenüberschreitungen. Dies wird in `AGENTS.md`, `CLAUDE.md` und `.github/copilot-instructions.md` unterstützt. ## Hooks-Referenz Ausführliche Informationen zu Hooks – einschließlich Hookkonfigurationsformaten, Hookereignissen, Eingabenutzlasten und Entscheidungskontrolle – finden Sie unter [GitHub Copilot-Hooks-Referenz](/de/copilot/reference/hooks-reference). ## MCP-Serverkonfiguration MCP-Server stellen zusätzliche Tools für den CLI-Agent bereit. Konfigurieren von beständigen Servern in `~/.copilot/mcp-config.json`. Verwenden Sie `--additional-mcp-config`, um Server für eine einzelne Sitzung hinzuzufügen. Lokale (Stdio)-Server, die innerhalb der Sandbox spawnen (siehe `/sandbox` Schrägstrichbefehl), zeigen einen `connected (sandboxed)` Status in `copilot mcp list` und `/mcp list`. Remote-Server (HTTP/SSE) laufen nicht in einer lokalen Sandbox, obwohl ihre Verbindungen von der CLI durch die Netzwerkrichtlinie der Sandbox eingeschränkt werden können. `copilot mcp list` und `/mcp list` markieren einen deaktivierten Server in der Textausgabe mit einem `(disabled)`-Suffix oder mit `"enabled": false` pro Server in der `--json`-Ausgabe. `copilot mcp get` zeigt eine `Status: Enabled`/`Disabled` Linie an. Das Umschalten von `/sandbox` startet nur lokale MCP-Server (stdio) neu, da sie innerhalb der Sandbox gestartet werden. Remoteserver (HTTP/SSE) bleiben verbunden. `/mcp edit ` lehnt einen aus dem Arbeitsbereich stammenden Server — einen, der im `.mcp.json` eines Repositorys definiert ist — ab, anstatt den Assistenten der Benutzerebene zu öffnen, da beim Speichern stillschweigend ein Benutzereintrag mit demselben Namen erstellt würde, der weiterhin vom Arbeitsbereichseintrag überdeckt wird. Der Fehler benennt die Datei, die direkt bearbeitet werden soll. `/mcp delete ` zeigt dieselbe Datei an, wenn es aufgefordert wird, einen aus dem Arbeitsbereich stammenden Server zu entfernen. ### `copilot mcp` Unterbefehl Verwenden Sie `copilot mcp`, um MCP-Serverkonfigurationen über die Befehlszeile zu verwalten, ohne eine interaktive Sitzung zu starten. | Subcommand | Beschreibung | | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `list [--json]` | Auflisten aller konfigurierten MCP-Server nach Quelle gruppiert, einschließlich von Plug-In bereitgestellten Servern und Servern, die über `--additional-mcp-config` oder `--plugin-dir`. | | `get [--json]` | Konfiguration und Tools für einen bestimmten Server anzeigen. Zeigt für Plug-In-Server auch den Namen und die Version des Quell-Plug-Ins an. | | `add [options] [url]` | Fügen Sie der Benutzerkonfiguration einen Server hinzu. Schreibt in `~/.copilot/mcp-config.json`. | | `enable ` / `disable ` | Aktivieren oder deaktivieren Sie einen Server anhand des Namens. Die Änderung bleibt für die Benutzerkonfiguration erhalten und gilt für zukünftige Sitzungen. | | `remove ` | Entfernen Sie einen Server auf Benutzerebene. Arbeitsbereich-Server müssen direkt in ihren Konfigurationsdateien bearbeitet werden. | Geben Sie für lokale Server (stdio) den Befehl nach `--` an: ```shell copy copilot mcp add SERVER-NAME -- COMMAND [ARGS...] ``` Geben Sie für Remote-HTTP- oder SSE-Server den Transport an, und geben Sie die URL an: ```shell copy copilot mcp add --transport http SERVER-NAME URL ``` \*\* `copilot mcp add` Optionen:\*\* | Auswahl | Beschreibung | | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-- [args...]` | Befehle und Argumente für lokale Server (Stdio). | | `` | URL für Remoteserver. | | `--transport ` | Transporttyp: `stdio`, `http`, oder `sse`. Der Standardwert lautet `stdio`. | | `--env KEY=VALUE` | Umgebungsvariable (wiederholbar). | | `--header "HEADER: VALUE"` | HTTP-Header für Remoteserver (wiederholbar). | | `--tools ` | Toolfilter: `"*"` für alle, eine durch Kommas getrennte Liste oder `""` für keine. | | `--timeout ` | Timeout in Millisekunden für Tool-Erkennung und Tool-Aufrufe. Standardwert: `30000`. Muss eine positive ganze Zahl ohne Bruchteil, Einheitensuffix, Zeichen oder Exponent sein, von `1` bis `4294967295`. | | `--json` | Füge die Konfiguration als JSON aus. | | `--show-secrets` | Vollständige Umgebungsvariablen und Headerwerte anzeigen. | Geben Sie im `/mcp add`/`/mcp edit` interaktiven Formular das `env` Feld als kommagetrennte `KEY=VALUE` Paare oder als JSON-Objekt ein (z. B `{"API_KEY":"secret"}`. ). `$PATH` ist standardmäßig enthalten und muss nicht aufgeführt werden. > [!CAUTION] > `--show-secrets` kann vertrauliche Umgebungsvariablen und Header-Werte an Ihr Terminal oder in Ihre Protokolle ausgeben. Verwenden Sie diese Option nur in vertrauenswürdigen Umgebungen, und vermeiden Sie das Kopieren, Einfügen oder anderweitige Erfassen der Ausgabe in freigegebenen Protokollen oder Verlauf. ### Transporttypen | Typ | Beschreibung | Pflichtfelder | | ------------------------------------------------------------------------------------- | ----------------------------------------------- | ------------- | | `local` / `stdio` | Lokaler Prozess kommuniziert über stdin/stdout. | | | `command`, `args` | | | | `http` | Remoteserver mit streambarem HTTP-Transport. | | | `"streamable-http"` wird auch als Alias akzeptiert und wird normalisiert in `"http"`. | `url` | | | `sse` | Remoteserver mit Server-Sent-Ereignistransport. | `url` | ### Lokale Serverkonfigurationsfelder | Feld | Erforderlich | Beschreibung | | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `command` | Ja | Befehl zum Starten des Servers. | | `args` | Ja | Befehlsargumente (Array). | | `tools` | Ja | Zu aktivierende Tools: `["*"]` für alle oder eine Liste bestimmter Toolnamen. | | `env` | No | Umgebungsvariablen. Unterstützt `$VAR`, `${VAR}` und `${VAR:-default}` Erweiterungen. | | `cwd` | No | Arbeitsverzeichnis für den Server. | | `timeout` | No | Timeout in Millisekunden für Tool-Erkennung und Tool-Aufrufe. Standardwert: `30000`. | | `type` | No | | | `"local"` oder `"stdio"`. Standardwert: `"local"`. | | | | `deferTools` | No | | | `"auto"` (Standard) oder `"never"`. Legen Sie fest, `"never"` dass die Tools dieses Servers immer sichtbar bleiben, auch wenn die Toolsuche aktiv ist. | | | | `disableToolCache` | No | Auf `true` setzen, um das Laden und Speichern des Tool-Snapshots für diesen Server zu überspringen. | | `slowConnectionThresholdMs` | No | Millisekunden, bevor Copilot CLI warnt, dass die Verbindung zu diesem Server länger dauert als erwartet. Standardwert: `10000`. Diese Einstellung wirkt sich nur auf den Fall aus, wenn die Warnung angezeigt wird. Dadurch wird das Zeitlimit für die Verbindung nicht geändert. Muss eine positive ganze Zahl sein, die nicht größer als `2147483647`ist. | `slowConnectionThresholdMs` und `timeout` sind unabhängig: `timeout` legt das tatsächliche Verbindungsbudget fest (mindestens `slowConnectionThresholdMs` ms), während Copilot CLI nur steuert, wann `60000` eine Warnung für eine Verbindung ausgibt, die noch im Gange ist. Erhöhen Sie `slowConnectionThresholdMs`, um erwartungsgemäß langsame Handshakes zu unterdrücken, z. B. bei Servern hinter einem Authentifizierungsablauf, ohne zu verlängern, wie lange Tool-Aufrufe dauern dürfen. ### Zwischenspeicherung von Tool-Snapshots Copilot CLI speichert eine Momentaufnahme der Liste der Tools jedes lokalen Servers, sodass die Tools beim Start sofort verfügbar sind, während die Live-Ermittlung im Hintergrund abgeschlossen wird. Die Live-Erkennung wird immer ausgeführt und ersetzt die Momentaufnahme, sobald sie abgeschlossen ist. Setzen Sie `disableToolCache: true` auf einem Server, um die Live-Erkennung nur für diesen Server zu erzwingen, oder setzen Sie die Umgebungsvariable `COPILOT_MCP_TOOL_CACHE=false`, um das Laden von Momentaufnahmen und die Persistenz für den gesamten Prozess zu deaktivieren. Beide Opt-Outs lassen vorhandene Cachedateien unberührt. ### Private npm-Registrierung Verwenden Sie `--registry` im `args`-Array, um ein Paket aus einer privaten npm-Registry abzurufen – zum Beispiel Artifactory oder einen GitHub-Packages-Feed: ```json { "mcpServers": { "my-internal-server": { "command": "npx", "args": [ "--registry", "https://npm.pkg.github.com", "@my-org/internal-mcp-server" ], "tools": ["*"] } } } ``` Die `--registry` Option und andere npm-Konfigurationsoptionen (`--userconfig`, , `--globalconfig`, `--prefix``--cache`, `--node-options`, `--workspace`) `-w`werden beim Berechnen des Identitätsabdrucks des Servers als wertaufwendige Argumente behandelt. Dadurch wird sichergestellt, dass die Überprüfung der Zulassungsliste des Unternehmens und die Registrierungsüberprüfung ordnungsgemäß funktionieren, wenn diese Optionen vor dem Paketnamen angezeigt werden. ### Remote-Server-Konfigurationsfelder | Feld | Erforderlich | Beschreibung | | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `type` | Ja | | | `"http"` oder `"sse"` (`"streamable-http"` wird auch als Alias für `"http"`) akzeptiert. | | | | `url` | Ja | Server-Adresse. | | `tools` | Ja | Tools zur Aktivierung. | | `headers` | No | HTTP-Header. Unterstützt variable Erweiterung. | | `oauthClientId` | No | Statische OAuth-Client-ID (überspringt dynamische Registrierung). | | `oauthScopes` | No | Nicht leeres Array von OAuth-Bereichstoken, die angefordert werden sollen. Erfordert `oauthClientId`. Ein nicht leerer Scope in der Challenge des Servers `WWW-Authenticate` hat weiterhin Vorrang; andernfalls überschreibt dies die ermittelten `scopes_supported`-Metadaten. | | `oauthPublicClient` | No | Gibt an, ob der OAuth-Client öffentlich ist. Standardwert: `true`. | | `false` für vertrauliche Clients mit einem gespeicherten geheimen Schlüssel einstellen. | | | | `oauthGrantType` | No | OAuth-Gewährungstyp: `"authorization_code"` (Standard, browserbasierter Flow) oder `"client_credentials"` (vollständig headless, kein Browser oder Callback). | | `oidc` | No | Aktivieren Sie die OIDC-Tokeneinfügung. Wenn `true`, injiziert die CLI OIDC-Token für jede `GITHUB_COPILOT_OIDC_MCP_TOKEN`- oder `GITHUB_COPILOT_OIDC_MCP_TOKEN_`-Variable, auf die im `env`-Block des Servers verwiesen wird (lokale Server), oder sendet das Token als `Bearer`-`Authorization`-Header (Remote-Server). Bevorzugen Sie für lokale Server suffixe Varianten (z. B `${GITHUB_COPILOT_OIDC_MCP_TOKEN_MY_SVC}`. ), um einen eindeutigen Variablennamen pro Server zuzuweisen. | | `timeout` | No | Timeout in Millisekunden für Tool-Erkennung und Tool-Aufrufe. Standardwert: `30000`. | | `deferTools` | No | | | `"auto"` (Standard) oder `"never"`. Legen Sie fest, `"never"` dass die Tools dieses Servers immer sichtbar bleiben, auch wenn die Toolsuche aktiv ist. | | | | `slowConnectionThresholdMs` | No | Millisekunden, bevor Copilot CLI warnt, dass die Verbindung zu diesem Server länger dauert als erwartet. Standardwert: `10000`. Diese Einstellung wirkt sich nur auf den Fall aus, wenn die Warnung angezeigt wird. Dadurch wird das Zeitlimit für die Verbindung nicht geändert. Muss eine positive ganze Zahl sein, die nicht größer als `2147483647`ist. | ### Erneute Authentifizierung von OAuth Remote-MCP-Server, die OAuth verwenden, können einen `needs-auth` Status anzeigen, wenn ein Token abläuft oder ein anderes Konto erforderlich ist. Verwenden Sie `/mcp auth `, um einen neuen OAuth-Fluss auszulösen. Dadurch wird eine Browserauthentifizierungsaufforderung geöffnet, sodass Sie sich anmelden oder Konten wechseln können. Nach Abschluss des Flusses wird die Verbindung automatisch vom Server erneut hergestellt. Unter Windows authentifizieren sich Remote-MCP-Server, die durch Microsoft Entra ID geschützt sind, stattdessen über den Authentifizierungsbroker des Betriebssystems (Web Account Manager), in der Regel ohne Benutzeraufforderung. Unter Linux und macOS, wo kein Betriebssystembroker vorhanden ist, erstellt die CLI stattdessen unbemerkt ein ressourcenspezifisches Token aus dem Entra-Konto, das über `/login` → Microsoft Entra eingerichtet wurde. Wenn dieses Konto die Anforderung nicht ohne Benutzerinteraktion erfüllen kann, z. B. keine angemeldete Entra-Identität, ein mehrdeutiges Konto oder eine Ressource, die für einen anderen Client vorab autorisiert wurde, fällt die Anmeldung auf den oben beschriebenen Browserablauf zurück. Durch Übergeben `--device-code` wird der Broker umgangen und der OAuth-Gerätecodefluss anstelle des Browserflusses erzwungen, und Windows Computer ohne die Brokerbibliothek fallen ebenfalls auf den Browserfluss zurück. ### Aus dem Account abgeleitetes WorkIQ Wenn Sie sich mit einem Microsoft Entra-Konto anmelden, wird der gehostete WorkIQ MCP-Server in `/mcp` verfügbar gemacht. Standardmäßig ist sie deaktiviert. Die Erkennung allein stellt keine Verbindung her, erwirbt kein Token und stellt keine Tools bereit – aktivieren Sie sie mit den normalen MCP-Steuerelementen (`/mcp enable WorkIQ` oder `copilot mcp enable WorkIQ`), um zuerst die stille Authentifizierung zu versuchen. `/mcp auth WorkIQ` bleibt für die Wiederherstellung verfügbar. Der Server verwendet eine an das angemeldete Entra-Konto gebundene Anmeldeinformation, kein Token, das für einen anderen Dienst ausgestellt wurde, und die Aktivierung des Servers folgt dieser Entra-Identität, anstatt auf ein anderes Konto überzugehen. Die explizite Serverkonfiguration und -deaktivierung sowie die Allowlist- oder Denylist-Richtlinie der Organisation haben weiterhin Vorrang. Es wird kein WorkIQ-Eintrag geschrieben in `mcp-config.json`. Dies ist nicht mit der Ausführung `npx @microsoft/workiq mcp` als unabhängig authentifizierter Stdioserver verbunden. ### Headless OAuth (`client_credentials` Gewährung) Für CI- oder Cron-Anwendungsfälle, bei denen kein Browser verfügbar ist, legen Sie `oauthGrantType: "client_credentials"` fest. Dies erfordert Folgendes: * `oauthClientId`– die statische Client-ID, die vom MCP-Anbieter ausgestellt wurde. * `oauthPublicClient: false`– der Client ist vertraulich. * Ein `client_secret`, das in der Keychain des Systems gespeichert wird (einmalig über die `/mcp` UI oder durch Schreiben in den Store für OAuth-Anmeldeinformationen konfiguriert). Bei der Konfiguration überspringt die CLI den Browser, den Rückrufserver, PKCE und die dynamische Clientregistrierung vollständig. Bei jedem 401 wird `grant_type=client_credentials` direkt an den ermittelten Token-Endpunkt des Servers gesendet. ```json { "mcpServers": { "headless-api": { "type": "http", "url": "https://api.example.com/mcp", "tools": ["*"], "oauthClientId": "YOUR-CLIENT-ID", "oauthPublicClient": false, "oauthGrantType": "client_credentials" } } } ``` ### Filterzuordnung Steuern Sie, wie die MCP-Toolausgabe mithilfe des Felds in der `filterMapping` Konfiguration eines Servers verarbeitet wird. | Modus | Beschreibung | | ------------------- | ------------------------------------------------- | | `none` | Keine Filterung. | | `markdown` | Formatieren Sie die Ausgabe als Markdown. | | `hidden_characters` | Entfernt verborgene oder Steuerzeichen. Standard. | ### Integrierte MCP-Server Die CLI konfiguriert `github-mcp-server` automatisch, wenn die Authentifizierung verfügbar ist, es sei denn, Sie deaktivieren sie oder geben Ihre eigene Konfiguration an. Andere Server hängen von Ihrem Konto, Ihrer Plattform, der CLI-Version und aktivierten Plug-Ins ab. Sie sind nicht alle verfügbar oder standardmäßig aktiviert. | Server | Beschreibung | Verfügbarkeit und Einrichtung | | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `github-mcp-server` | | | | GitHub Integration, einschließlich Repositoryzugriff und Codesuche. | Standardmäßig aktiviert, wenn die Authentifizierung verfügbar ist. Die verfügbar gemachten Tools hängen von Ihrer Konfiguration ab. | | | `WorkIQ` | Gehosteter MCP-Server, der einem Microsoft Entra-Konto zugeordnet ist. | Entdeckt, nachdem Sie sich mit einem Microsoft Entra Konto angemeldet haben. Standardmäßig deaktiviert. Weitere Informationen unter [Account-derived WorkIQ](#account-derived-workiq). | | `browser-use` | Browserinteraktion über ein gebündeltes Plug-In. | Verfügbar in CLI-Versionen, die das Plug-In enthalten. Standardmäßig deaktiviert. Aktivieren Sie sie mit `/mcp enable browser-use`, installieren Sie die entsprechende Browsererweiterung und Node.js 22 or later, dann `/browser-use:activate` ausführen oder eine neue Sitzung starten. Der Name des Legacyservers lautet `github-copilot-browser`. | | `computer-use` | Desktopanwendungsinteraktion über ein gebündeltes Plug-In. | Verfügbar für lokale Sitzungen unter macOS und Windows. Standardmäßig deaktiviert. Aktivieren Sie es mit `/computer on`. Unter macOS sind Barrierefreiheits- und Bildschirmaufzeichnungsberechtigungen erforderlich. Siehe [GitHub Copilot CLI zum Interagieren mit Desktopanwendungen verwenden](/de/copilot/how-tos/copilot-cli/use-copilot-cli/computer-use). | Verwaltete Einstellungen können verhindern, dass Sie einen Server oder sein Plug-In aktivieren. `--disable-builtin-mcps` deaktiviert `github-mcp-server`, `WorkIQ`, `browser-use` und den Legacy-Browser-Servernamen `github-copilot-browser` für die aktuelle Ausführung. Es wird nicht deaktiviert `computer-use`. Verwenden Sie `--disable-mcp-server computer-use`, um diesen Server für die aktuelle Ausführung zu deaktivieren, oder `/computer off`, um das Plugin zu deaktivieren und diese Einstellung zu speichern. Verwenden Sie `--disable-mcp-server SERVER-NAME`, um jeden anderen spezifischen Server für die aktuelle Ausführung zu deaktivieren. Verwenden Sie `/mcp list` in einer interaktiven Sitzung, um zu überprüfen, welche Server verfügbar sind, und um ihren Verbindungsstatus zu überprüfen. Verwenden Sie `copilot mcp list` oder `copilot mcp get SERVER-NAME` außerhalb einer Sitzung, um die Serverkonfiguration zu prüfen. Ein nicht vorhandener oder deaktivierter Server ist nicht unbedingt ein Konfigurationsfehler. Überprüfen Sie oben die Verfügbarkeit und die Setupanforderungen. #### GitHub MCP-Server-Tools Die `github-mcp-server` stellt die folgenden Tools zur Verfügung. | Tools | Beschreibung | | ---------------------------------------------------------------- | ---------------------------------- | | `get_file_contents`, `search_code` | Dateien im Repository durchsuchen. | | `list_issues`, `issue_read``search_issues` | Problemverfolgung. | | `get_pull_request`, `list_pull_requests``get_pull_request_files` | Pull Requests | | `list_commits`, `get_commit` | Commitverlauf. | | `list_workflow_runs`, `get_workflow_run_logs` | GitHub Actions. | | `get_label`, `list_label``label_write` | Beschriftungsverwaltung. | ### Ressourcenermittlung Nur im experimentellen Modus verfügbar. Wenn eine lokale Funktion fehlt, kann der Agent einen Remotekatalog nach öffentlichen MCP-Servern `discover-resources` und Fähigkeiten durchsuchen, um sie hinzuzufügen, indem er eine integrierte Fähigkeit verwendet. Die Qualifikation fragt den Katalog nach relevanzrangigen MCP-Servern und Fähigkeiten ab, die einer abstrakten Funktion (z. B. "Datenbankzugriff" oder "Architekturdiagramme") entsprechen, und stellt dann Kandidaten vor, aus der Sie wählen können. Die Fähigkeit selbst installiert niemals etwas. Die Dashboards `/mcp`, `/skills` und `/plugin` enthalten auch eine Katalogsuche mit Eingabe, die dieselben Remote-Ergebnisse mit der lokalen Ressourcenliste zusammenführt. ### MCP-Serverbenennung Servernamen können beliebige druckbare Zeichen enthalten, einschließlich Leerzeichen, Unicode-Zeichen und Interpunktion. Steuerzeichen (U+0000–U+001F, U+007F) und die schließende geschweifte Klammer (`}`) sind nicht zulässig. Servernamen werden als Präfixe für Toolnamen verwendet, z. B. erzeugt ein Server namens `my-server` Toolnamen wie `my-server-fetch`, und ein Server mit dem Namen `My Server` erzeugt `My Server-fetch`. ### MCP-Toolnamenbereinigung MCP-Servernamen und Toolnamen werden sanitiert, bevor sie an das Modell gesendet werden. Zeichen, die in Toolnamen ungültig sind (alles andere als `a-z`, , `A-Z`, `0-9`, `-`, ) `_`werden durch ersetzt `-`. Unicode-Zeichen sind punycodecodiert. Das Symbol `@` wird ebenfalls durch `-` ersetzt, um Konflikte mit der Punycode-Codierung zu vermeiden. Der kombinierte Name (`serverName-toolName`) ist mit 64 Zeichen begrenzt. Wenn die Trunkierung einen Namenskonflikt erzeugt, wird ein numerisches Suffix angefügt (z. B. `my-server-tool2`, `my-server-tool3`), um die Eindeutigkeit sicherzustellen. ### MCP-Serververtrauensstufen MCP-Server werden aus mehreren Quellen geladen, jeweils mit einer anderen Vertrauensstufe. | Quelle | Vertrauensebene | Überprüfung erforderlich | | ---------------------------------------------------- | --------------- | ------------------------ | | Integriert | Hoch | No | | Repositorium (`.github/mcp.json`) | Mittelstufe | Empfohlen | | Arbeitsbereich (`.mcp.json`) | Mittelstufe | Empfohlen | | Benutzerkonfiguration (`~/.copilot/mcp-config.json`) | User-defined | Benutzerverantwortung | | Remoteserver | Niedrig | Immer | MCP-Toolaufrufe unterliegen den Berechtigungsregeln der Sitzung, einschließlich vorhandener Genehmigungen und assisted permissions, wenn aktiviert. Auch Nur-Lesevorgänge für externe Dienste können eine Genehmigung erfordern. ### MCP-Serverladepriorität MCP-Server aus unterschiedlichen Quellen werden in der Prioritätsreihenfolge zusammengeführt (zuerst am höchsten). Wenn Server einen Namen freigeben, hat die Quelle mit höherer Priorität Vorrang. 1. `--additional-mcp-config` Option (höchste) 2. Von Plugins bereitgestellte Server 3. Workspace-Server – `.mcp.json` und `.github/mcp.json` werden ausgehend vom Arbeitsverzeichnis aufwärts bis zum Git-Stammverzeichnis geladen; setzt einen vertrauenswürdigen Ordner voraus 4. `~/.copilot/mcp-config.json` (niedrigste) > [!NOTE] > Arbeitsbereich-MCP-Server (`.mcp.json` und `.github/mcp.json`) werden sowohl in interaktiven Sitzungen als auch in Sitzungen im SDK-Servermodus geladen, vorausgesetzt, das Arbeitsverzeichnis ist vertrauenswürdig. Weitere Informationen zur Ordnervertrauensstellung finden Sie unter [Zulassen und Verweigern der Verwendung von Tools](/de/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools). Wenn eine Arbeitsbereichskonfigurationsdatei einen ungültigen Servereintrag enthält, überspringt die CLI nur diesen Eintrag und lädt die anderen gültigen Einträge weiterhin, wobei sie für jeden übersprungenen Eintrag `Warning: workspace MCP config "": ` ausgibt. Eine falsch formatierte oder nicht lesbare Datei (ungültiger JSON-Code oder eine ungültige Struktur auf oberster Ebene) wird weiterhin vollständig übersprungen. ### Enterprise MCP-Zulassungsliste GitHub Enterprise Organisationen können eine Zulassungsliste zulässiger MCP-Server erzwingen. Wenn sie aktiv ist, wertet die CLI jeden nicht standardmäßigen Server anhand der Unternehmensrichtlinie aus, bevor eine Verbindung hergestellt wird. Wenn eine GitHub Enterprise-Registrierungsrichtlinie erkannt wird (oder das experimentelle `MCP_ENTERPRISE_ALLOWLIST`-Featureflag aktiviert ist), wird in der CLI Folgendes durchgeführt: 1. Berechnet einen Fingerabdruck für jeden konfigurierten nicht standardmäßigen Server basierend auf seinen Befehlen, Argumenten und Remote-URL. 2. Sendet die Fingerabdrücke an den Evaluierungs-Endpunkt der Freigabeliste des Unternehmens. 3. Lässt nur Server zu, deren Fingerabdrücke genehmigt werden; alle anderen Personen werden mit einer Nachricht blockiert, die das Unternehmen benennt. Diese Überprüfung ist fehlgeschlagen: Wenn der auswertende Endpunkt nicht erreichbar ist oder einen Fehler zurückgibt, werden nicht standardmäßige Server blockiert, bis die Richtlinie überprüft werden kann. Wenn ein Server von einer Unternehmens-Zulassungsliste blockiert wird, zeigt die CLI Folgendes an: ```text MCP server "SERVER-NAME" was blocked by your enterprise "ENTERPRISE-NAME". Contact your enterprise administrator to add this server to the allowlist. ``` Integrierte Standardserver sind immer von der Durchsetzung der Erlaubnisliste ausgenommen. ### Migrieren von `.vscode/mcp.json` Wenn Ihr Projekt das MCP-Konfigurationsformat von VS Code verwendet `.vscode/mcp.json`, migrieren Sie zu `.mcp.json` für GitHub Copilot CLI. Die Migration ordnet den `servers` Schlüssel neu zu `mcpServers`. **POSIX-Shells (bash, zsh, fish und andere):** ```shell jq '{mcpServers: .servers}' .vscode/mcp.json > .mcp.json ``` Erfordert [`jq`](https://jqlang.github.io/jq/). **PowerShell**: ```powershell pwsh -NoProfile -Command "`$json = Get-Content '.vscode/mcp.json' -Raw | ConvertFrom-Json; `$content = ([pscustomobject]@{ mcpServers = `$json.servers } | ConvertTo-Json -Depth 100); [System.IO.File]::WriteAllText('.mcp.json', `$content, (New-Object System.Text.UTF8Encoding `$false))" ``` Ersetzen Sie auf Windows `pwsh` durch `powershell`, wenn Sie Windows PowerShell anstelle von PowerShell Core verwenden. ### Ausgabe des Stdio-Servers Der MCP-stdio-Transport reserviert stdout ausschließlich für durch Zeilenumbrüche getrennte JSON-RPC-Frames. Die CLI filtert automatisch alle Nicht-JSON-Zeilen – Klartext-Logs, Stacktraces von Ausnahmen oder Zeilen, die nur aus Leerraum bestehen – heraus, bevor die Ausgabe an den Protokollparser übergeben wird. Schreiben Sie alle Diagnoseausgabe in **Stderr**, nicht auf Stdout. Ein Server, der Protokolle oder Fehlermeldungen in stdout schreibt, kann eine Rückkopplungsschleife von Parse-Fehlern auslösen, die den Initialisierungs-Handshake ins Stocken bringt; der Filter verhindert dies, indem er Nicht-JSON-Frames stillschweigend verwirft. Zeilen, die länger als 1 MB sind, umgehen die Strukturprüfung und werden as-isweitergeleitet, um zu vermeiden, dass übergroße, aber gültige Protokollframes (z. B. eine große `tools/list` Antwort) geteilt oder gelöscht werden. ## Referenz zu Skills Fähigkeiten sind Markdown-Dateien, die erweitern, was die CLI tun kann. Jede Fähigkeit lebt in einem eigenen Verzeichnis, das eine `SKILL.md` Datei enthält. Beim Aufrufen (über `/SKILL-NAME` oder automatisch durch den Agenten) wird der Inhalt der Fähigkeit in die Unterhaltung eingefügt. ### Frontmatterfelder der Fähigkeit | Feld | Typ | Erforderlich | Beschreibung | | -------------------------- | --------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `name` | Schnur | Ja | Eindeutiger Bezeichner für die Fähigkeit. Muss mit einem Buchstaben oder einer Zahl beginnen und nur Buchstaben, Zahlen, Bindestriche, Unterstriche, Punkte, Doppelpunkte und Leerzeichen enthalten. Max. 64 Zeichen. Doppelpunkte erlauben Namespacenamen (z. B `my-plugin:search`. ). | | `description` | Schnur | Ja | Was die Fähigkeit tut und wann sie zu verwenden. Max. 1024 Zeichen. | | `argument-hint` | Schnur | No | Freiform-Hinweis, der die erwarteten Argumente beschreibt und in der Skill-Auswahl angezeigt wird (z. B. `"[target] [mode]"`). | | `allowed-tools` | Zeichenfolge oder Zeichenfolge\[] | No | Eine durch Kommas getrennte Liste oder ein YAML-Array von Tools, die automatisch erlaubt sind, wenn die Funktion aktiv ist. Verwenden Sie `"*"` für alle Tools. | | `user-invocable` | boolean | No | Ob Benutzer den Skill `/SKILL-NAME`aufrufen können. Standardwert: `true`. | | `disable-model-invocation` | boolean | No | Verhindern Sie, dass der Agent diese Fähigkeit automatisch aufruft. Standardwert: `false`. | ### Qualifikationsstandorte Fähigkeiten werden in der Reihenfolge der Priorität aus diesen Speicherorten geladen (bei duplizierten Namen wird der zuerst gefundene verwendet). | Ort | Geltungsbereich | Beschreibung | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `.github/skills/` | Projekt | Projekt-spezifische Fähigkeiten. | | `.agents/skills/` | Projekt | Alternative Projektstandort. | | `.claude/skills/` | Projekt | Claude-kompatibler Standort. | | Elternteil `.github/skills/` | Geerbt | Unterstützung für das übergeordnete Monorepo-Verzeichnis. | | `~/.copilot/skills/` | Personal | Persönliche Fähigkeiten für alle Projekte. | | `~/.agents/skills/` | Personal | Agentenkompetenzen, die für alle Projekte gemeinsam genutzt werden. | | Plug-In-Verzeichnisse | Plug-In | Fähigkeiten von installierten Plug-Ins. | | `COPILOT_SKILLS_DIRS` | Kundenspezifisch | Zusätzliche Verzeichnisse (durch Trennzeichen getrennt). | | `--add-dir ` | Stamm hinzugefügt | | | `.github/skills/`, `.agents/skills/` und `.claude/skills/` unter Verzeichnissen, die mit `--add-dir`, `/add-dir` oder dem `additionalDirectories` des SDK hinzugefügt wurden. Dies ist eine Vertrauensentscheidung: Zusätzliche Fähigkeiten werden mit demselben Vertrauen wie Projektkompetenzen ausgeführt. | | | | (gebündelt mit CLI) | Integriert | Fähigkeiten, die mit der CLI ausgeliefert wurden. Niedrigste Priorität - kann von jeder anderen Quelle überschrieben werden. | | (org/enterprise) | Remote | Fähigkeiten, die von Ihrer Organisation oder Ihrem Unternehmen gehostet werden, projiziert über das AHP-Relay. Inhalte werden bei Bedarf abgerufen, wenn die Fähigkeit aufgerufen wird. | Remote-Fähigkeiten werden zusammen mit lokalen Fähigkeiten angezeigt und folgen derselben namensbasierten Priorisierung, wenn eine lokale Fähigkeit denselben Namen hat. Verwenden Sie die `ignoredSkillsLocations` Einstellung, um bestimmte Verzeichnisse (und deren Nachfolger) von der Ermittlung auszuschließen, unabhängig davon, an welcher Position oben sie andernfalls angezeigt werden. Siehe [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). Wenn zwei Plug-Ins Skills mit demselben Namen bereitstellen, koexistieren beide unter pluginqualifizierten Aufrufnamen wie `/my-plugin/search` und `/other-plugin/search`. Der Name ohne Präfix verweist auf das Plugin mit der höheren Priorität. Dies gilt nur für Fähigkeiten; Befehle behalten die standardebenenbasierte Deduplizierung bei, wobei die Quelle mit höherer Priorität gewinnt. ### Verwalten von Fähigkeiten, die nicht interaktiv sind Verwenden Sie `copilot skill`, um Fähigkeiten über die Befehlszeile zu verwalten, ohne eine interaktive Sitzung zu öffnen. | Subcommand | Beschreibung | | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | | `list [--json]` | Auflisten aller entdeckten Fähigkeiten. | | `add [--project]` | Fügen Sie eine Fähigkeit aus einem Dateipfad, einer URL oder einem Verzeichnis hinzu. | | `remove ` | Entfernen Sie eine persönliche oder Projektkompetenz, oder heben Sie die Registrierung eines benutzerdefinierten Qualifikationsverzeichnisses auf. | | `enable ` / `disable ` | Aktivieren oder deaktivieren Sie eine Fähigkeit anhand des Namens. | ```bash # Install a skill for your user account (default) copilot skill add ./my-skill/SKILL.md # Install a skill into the current project (.github/skills; file or URL skills only) copilot skill add --project ./my-skill/SKILL.md # Enable, disable, or remove a skill by name copilot skill enable my-skill copilot skill disable my-skill copilot skill remove my-skill ``` Durch die Installation eines Verzeichnisses wird es als benutzerdefinierte Qualifikationsquelle registriert, anstatt es zu kopieren. Die Installation einer Datei oder URL kopiert den Inhalt des Skills in Ihr persönliches oder Projekt-Skills-Verzeichnis. Der entsprechende interaktive Befehl ist `/skills add [--project] `. `copilot skill list --json` Zeilen weisen die Form auf `{ name, description, source, path, enabled }`. Mit `remove` übergeben Sie entweder einen Skill-Namen oder den Pfad zu einem benutzerdefinierten Skill-Verzeichnis, das Sie hinzugefügt haben – ein Skill-Name löscht die Dateien dieses Skills, während ein benutzerdefinierter Verzeichnispfad nur die Registrierung des Verzeichnisses aufhebt und seine Dateien auf dem Datenträger belässt. Nur persönliche und projektbasierte Fähigkeiten, die Sie hinzugefügt haben, können entfernt werden. Fähigkeiten, die von einem Plug-In oder dem integrierten Satz bereitgestellt werden, können auf diese Weise nicht entfernt werden (deaktivieren Sie sie stattdessen). Dies ersetzt die eingestellten `copilot plugins install --skill [--scope project]` und `copilot plugins remove/enable/disable --skill`. ### Befehle (alternatives Qualifikationsformat) Befehle sind eine Alternative zu "Skills", die in einzelnen `.md` Dateien in `.claude/commands/` gespeichert werden. Der Befehlsname wird vom Dateinamen abgeleitet. Befehlsdateien verwenden ein vereinfachtes Format (kein `name` Feld erforderlich) und unterstützen `argument-hint`, , `description`, `allowed-tools`und `disable-model-invocation`. Befehle haben eine niedrigere Priorität als Fähigkeiten mit demselben Namen. ## Erweiterungsmodi > [!NOTE] > GitHub Copilot CLI Erweiterungen sind derzeit ein experimentelles Feature und können geändert werden. In einer interaktiven Sitzung steuert `/extensions mode`, ob Erweiterungen ausgeführt werden und ob Copilot sie verwalten kann. | Modus | Erweiterungen werden ausgeführt | Agent kann Erweiterungen verwalten | | --------------------------------- | ------------------------------- | ---------------------------------- | | **Load & Augment** (Standardwert) | Ja | Ja | | **Nur laden** | Ja | No | | **Disabled** | No | No | Im **Load & Augment-Modus** verfügt der Agent über Tools, um ermittelte Erweiterungen auflisten, deren Status und Protokolle zu überprüfen, eine Starterweiterung zu erstellen und Erweiterungen nach Codeänderungen neu zu laden. Auf diese Weise kann der Agent Erweiterungscode als Teil Ihrer Anforderung erstellen und laden. Wählen Sie **Nur laden**, um einen vorhandenen Satz vertrauenswürdiger Erweiterungen auszuführen, ohne dem Agenten Tools zur Erweiterungsverwaltung zu geben. Der Agent kann weiterhin Tools aufrufen, die durch Ausführen von Erweiterungen bereitgestellt werden. Modusänderungen werden sofort in der aktuellen Sitzung wirksam: * Durch den Wechsel zu **Deaktiviert** werden Erweiterungsprozesse beendet und ihre Tools entfernt. * Der Wechsel von **"Deaktiviert"** in einen der beiden Lademodi startet Erweiterungen. * Der Wechsel zwischen **„Nur laden“** und **„Laden und erweitern“** ändert den Zugriff auf Erweiterungsverwaltungstools, ohne die Erweiterungen zu beenden. Das Deaktivieren von Erweiterungen wird für zukünftige Sitzungen beibehalten, bis Sie einen Lademodus auswählen. Andere bereits laufende Sitzungen sind nicht betroffen. Verwenden Sie `/extensions manage`, um Erweiterungen und deren Status zu prüfen. Beispiele für Suchorte und Implementierung finden Sie unter [Erstellen von Erweiterungen für GitHub Copilot CLI](/de/copilot/tutorials/create-an-extension). ## Referenz für benutzerdefinierte Agents Kundenspezifische Agenten sind spezialisierte KI-Agenten, die in Markdown-Dateien definiert sind. Für Benutzer-, Projekt- und hinzugefügte Stamm-Agents wird die Agent-ID vom Pfad der Datei relativ zum `agents` Verzeichnis abgeleitet. Die CLI entfernt die `.agent.md` Oder `.md` Erweiterung und ersetzt Verzeichnistrennzeichen durch `--`. Zum Beispiel hat `agents/team/reviewer.agent.md` die ID `team--reviewer`. ### Integrierte Agenten | Agent | Standardmodell | Beschreibung | | ----------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `code-review` | claude-sonnet-4.6 | Codeüberprüfung für hohes Signal-Rausch-Verhältnis. Analysiert Diffs für Fehler, Sicherheitsprobleme und Logikfehler. Ändert den Code nicht. | | `explore` | gpt-5.6-luna | Schnelle Code-Basissuche. Durchsucht Dateien, liest Code und beantwortet Fragen. Gibt fokussierte Antworten unter 300 Wörtern zurück. Kann sicher parallel ausgeführt werden. | | `general-purpose` | claude-sonnet-4.6 | Vollfunktions-Agent für komplexe Aufgaben mit mehreren Schritten. Wird in einem separaten Kontextfenster ausgeführt. | | `research` | claude-haiku-4.5 | Führt gründliche Suchvorgänge basierend auf Anweisungen aus. Durchsucht GitHub Repositorys, ruft Dateien ab, überprüft Ansprüche und meldet detaillierte Ergebnisse mit Zitaten. | | `rubber-duck` | Ergänzendes Modell | Verwenden Sie ein ergänzendes Modell, um eine konstruktive Kritik an Vorschlägen, Entwürfen, Implementierungen oder Tests bereitzustellen. Identifiziert Schwachstellen und schlägt Verbesserungen vor. Siehe [Eine zweite Meinung mit dem Rubber-Duck-Agenten](/de/copilot/concepts/agent-capabilities/choosing-and-delegating-agent-work/getting-a-second-opinion). | | `security-review` | claude-sonnet-4.6 | Sicherheitsrelevante Codeüberprüfung. Analysiert Änderungen bei mit hoher Zuverlässigkeit erkannten Schwachstellen in 11 Kategorien. Kennzeichnet nur Probleme, deren Ausnutzbarkeit mit über 80 % Sicherheit angenommen wird. Meldet Schweregrade und Konfidenzwerte. Ändert den Code nicht. | | `task` | gpt-5.6-luna (fällt auf claude-haiku-4.5 zurück) | Befehlsausführung (Tests, Builds, Lints). Gibt eine kurze Zusammenfassung bei Erfolg, eine vollständige Ausgabe bei Fehlern zurück. | `code-review` und `security-review` leiten niemals eine vollständige Prüfung an einen anderen Review-Agenten weiter: Das Starten eines solchen Agenten gilt bereits als Erfüllung einer Anforderung, einen Prüfer zu „verwenden“ oder „aufzurufen“, sodass der Agent die Prüfung selbst durchführt, anstatt die gesamte Aufgabe rekursiv entlang der gesamten Delegierungskette an einen verschachtelten `code-review`- oder `security-review`-Subagenten zu delegieren. `code-review` gibt sicherheitsrelevante Teile einer Anfrage weiterhin an den dedizierten `security-review`-Spezialisten ab, und beide Agenten können eng umrissene, unabhängig abgegrenzte Recherchen an Agenten, die keine Prüfungen durchführen, wie `explore`, delegieren. Nur der Root-Agent kann `store_memory` oder `vote_memory` aufrufen, um eine Erinnerung zu speichern oder darüber abzustimmen. Subagenten behalten lesezugriff auf gespeicherte Erinnerungen durch `read_memories`, können aber nicht schreiben oder abstimmen. ### Benutzerdefinierte Agent-Vordergrundinformationsfelder | Feld | Typ | Erforderlich | Beschreibung | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `description` | Schnur | Ja | Beschreibung, die in der Agentenliste und im `task` Tool angezeigt wird. | | `include-custom-instructions` | boolean | No | Fügen Sie Repository-Anweisungsdateien (`copilot-instructions.md`, `AGENTS.md`, `CLAUDE.md`), wenn dieser Agent als Subagent ausgeführt wird. Standardwert: `false`. | | [Siehe benutzerdefinierte Repository-Anweisungen für Subagenten](#repository-custom-instructions-for-subagents). | | | | | `infer` | boolean | No | Automatische Delegierung durch den Hauptagenten zulassen. Standardwert: `true`. | | `mcp-servers` | Objekt | No | MCP-Server zum Verbinden. Verwendet dasselbe Schema wie `~/.copilot/mcp-config.json`. | | `model` | Schnur | No | KI-Modell für diesen Agent. Wenn dies nicht festgelegt ist, wird das Modell des äußeren Agents geerbt. Wenn das Sitzungsmodell auf `Auto` (servergewählt) festgelegt ist, erben Subagenten unabhängig von diesem Feld immer das aufgelöste Sitzungsmodell. | | `models` | string\[] | No | Erstellte Modelle in Prioritätsreihenfolge. Die Laufzeit verwendet das erste Modell, auf das der Benutzerplan zugreifen kann; wenn keine Auflösung erfolgt, greift die Verteilerstelle auf das Modell der Sitzung zurück. Hat Vorrang vor `model`, wenn beide festgelegt sind. | | `modelPolicy` | Schnur | No | | | `"preferred"` (Standard) ermöglicht, dass `model`/`models` durch eine `subagents`-Außerkraftsetzung in `~/.copilot/settings.json` oder im `/subagents`-Auswahlfeld außer Kraft gesetzt wird. | | | | | `"required"` beschränkt Dispatch auf eines der definierten Modelle – Überschreibungen werden abgelehnt und der Eintrag **Model** in der Auswahl ist deaktiviert. | | | | | `name` | Schnur | No | Anzeigename. Sie können diesen Wert auch verwenden, um den Agent auszuwählen, z. B. mit `--agent`. Standardmäßig wird die Agent-ID verwendet. | | `reasoningEffort` | Schnur | No | Standardwert für den Schlussfolgerungsaufwand dieses Agenten (z. B. `"low"`, `"medium"` oder `"high"`). Wenn nicht festgelegt, wird der Aufwand des übergeordneten Agents übernommen. | | `tools` | string\[] | No | Tools, die für den Agent verfügbar sind. Standard: `["*"]` (alle Tools). Fügen Sie `*` an einer beliebigen Stelle in der Liste den vollständigen Zugriff auf Tools ein , `["view", "*"]` z. B. gewährt jedes Tool, nicht nur `view`. | `model`, `models`, `modelPolicy` und `reasoningEffort` gelten unabhängig davon, ob der Agent über das `task`-Tool bereitgestellt oder direkt gestartet wird – zum Beispiel über das `session.startSubagent` des SDKs. Modell und Aufwand werden in folgender Prioritätsreihenfolge aufgelöst, höchste Priorität zuerst: ein expliziter Wert pro Aufruf, die Überschreibung `subagents` in `~/.copilot/settings.json`, das Feld `reasoningEffort``model`/`models`/ der Agentdefinition und dann der Wert der übergeordneten Sitzung. Ein deklariertes Modell oder eine deklarierte Aufwandsstufe, die nicht eingehalten werden kann, greift stattdessen auf den Sitzungswert zurück, statt die Weiterleitung fehlschlagen zu lassen – es sei denn, der Agent deklariert `modelPolicy: "required"`, dann wird die Weiterleitung verweigert, anstatt stillschweigend ein nicht verfasstes Modell zu verwenden. ### Benutzerdefinierte Agent-Standorte Die CLI lädt benutzerdefinierte Agents in der folgenden Prioritätsreihenfolge. Wenn Agents dieselbe ID haben, wird der erste geladene Agent verwendet. | Priorität | Geltungsbereich | Ort | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ----------------------------------------- | | 1 (höchste) | Benutzer | `~/.copilot/agents/` | | 2 | Projekt | | | `.github/agents/`, vom aktuellen Arbeitsverzeichnis nach oben zum Git-Stamm | | | | 3 | Projekt | | | `.claude/agents/`, vom aktuellen Arbeitsverzeichnis nach oben zum Git-Stamm | | | | 4 | Stamm hinzugefügt | | | `.github/agents/` und `.claude/agents/` unter einem Verzeichnis, das mit `--add-dir`, `/add-dir` oder dem `additionalDirectories` des SDK hinzugefügt wurde. Das Hinzufügen des Verzeichnisses ist eine Vertrauensentscheidung: Seine Agenten werden als vertrauenswürdige Konfiguration geladen. | | | | 5 | Plug-In | `/agents/` | | 6 (niedrigste) | Remote | Organisation oder Unternehmensmitarbeiter | Innerhalb jeder Projektzeile überprüft die CLI zuerst das aktuelle Arbeitsverzeichnis, dann jedes übergeordnete Verzeichnis bis zum Git-Stamm, sodass das tiefste Verzeichnis die höchste Priorität hat. Jedes Projektverzeichnis `.github/agents/` wird vor einem Projektverzeichnis `.claude/agents/` geladen. Dies bedeutet, dass jedes Paket oder Unterverzeichnis in einem Monorepo seine eigenen Agenten bereitstellen kann. Das optionale `name` Frontmatterfeld steuert keine Deduplizierung. Agents mit demselben `name`, aber unterschiedlichen IDs werden beide geladen. Wenn der an `--agent` übergebene Wert mit der ID oder `name` von mehr als einem Agenten übereinstimmt, verwendet die CLI den ersten übereinstimmenden Agenten in der oben angegebenen Prioritätsreihenfolge. ### Benutzerdefinierte Anweisungen für Subagenten im Repository Ein benutzerdefinierter Agent, der als Unteragent gestartet wurde – über das `task`-Tool oder das `session.startSubagent` des SDK – empfängt standardmäßig keine Anweisungsdateien des Repositorys (`copilot-instructions.md`, `AGENTS.md`, `CLAUDE.md`). Legen Sie `include-custom-instructions: true` in der Frontmatter fest, um sich zu anmelden: ```markdown --- name: RepoAwareReviewer description: Reviews a change against this repository's conventions tools: ["*"] include-custom-instructions: true --- Review the change and flag anything that violates the repository's conventions. ``` | Agent | Empfängt Repositoryanweisungen | | ------------------------------------------------------------------------------------------------ | ------------------------------------------- | | Sitzungs-Agent (der Standard-Agent oder ein benutzerdefinierter Agent, ausgewählt mit `--agent`) | Ja | | `general-purpose` Unteragent | Ja | | Integrierte `explore`, `task` und `code-review`-Subagenten | No | | Benutzerdefinierter Agent als Subagent erzeugt | Nur mit `include-custom-instructions: true` | Wenn ein Subagent über `include-custom-instructions: true` verfügt, liest er die Anweisungsdateien Ihres Repositorys (`copilot-instructions.md`, `AGENTS.md`, `CLAUDE.md`). Es erbt keine zusätzlichen Anweisungsverzeichnisse, die Sie nur für die Hauptsitzung geladen haben – zum Beispiel ein persönliches Verzeichnis, auf das Sie die Sitzung mit `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` verwiesen haben. Das Starten einer Sitzung mit `--no-custom-instructions` hat immer Vorrang: Wenn Sie diese Option verwenden, erhält kein Agent Anweisungen für das Repository, selbst wenn ein Agent `include-custom-instructions: true` festlegt. Aktivieren Sie nur die Einstellung für Agents, die den Konventionen Ihres Repositorys entsprechen müssen, z. B. einem Agent, der Code überprüft oder bearbeitet. Anweisungen für das Repository erweitern das, was ein Agent bei jedem Durchlauf verarbeitet. Wenn die Einstellung daher für Agenten deaktiviert bleibt, die sie nicht benötigen – zum Beispiel ein Agent, der nur nach Dateien sucht oder Text zusammenfasst –, laufen diese Agenten schneller und kostengünstiger. Weitere Informationen findest du unter [Erstellen und Verwenden von benutzerdefinierten Agenten für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/create-custom-agents-for-cli). ### Agentkommunikation Verwenden Sie `list_agents` und `write_agent` innerhalb benutzerdefinierter Agenten, um benachbarte Agenten zu überprüfen und die Arbeit in einer Multi-Agenten-Sitzung zu koordinieren. #### Beziehungsbezeichnungen in `list_agents` Beziehungsbezeichnungen geben an, in welcher Beziehung sichtbare Agenten zum aktuellen Agenten stehen. Labels werden angezeigt, wenn ein Subagent innerhalb einer übergeordneten Sitzung mit aktivierter gemeinsamer gleichgeordneter Kommunikation ausgeführt wird. | Etikett | Bedeutung | Verwenden Sie es, um | | ----------- | ------------------------------------------------------------------- | -------------------------------------------------------------------- | | `"self"` | Der aktuelle Agent | Bestätigen, welcher Eintrag den aktiven Agent darstellt | | `"sibling"` | Ein Agent, der von demselben übergeordneten Element gestartet wurde | Arbeiten Sie über `write_agent` mit anderen Agents zusammen | | `"child"` | Ein Agent, der vom aktuellen Agent gestartet wurde | Folgemaßnahmen verfolgen, die vom aktuellen Agenten delegiert wurden | #### Bereichsbezogene Auflistung Verwenden Sie `scope` auf `list_agents`, um die Liste einzugrenzen, bevor Sie Ziele auswählen. | `scope` Wert | Rücklieferungen | Verwenden Sie es, um | | ------------ | ---------------------------------------------- | ------------------------------------------------------------------------------------------ | | ausgelassen | Nahegelegene Agenten im aktuellen Kontext | Zeigen Sie den Standardarbeitssatz für den aktuellen Workflow an | | `"siblings"` | Nur gleichgeordnete Agents | Suchen nach Peer-Agents, die von demselben übergeordneten Element gestartet wurden | | `"children"` | Nur untergeordnete Agents des aktuellen Agents | Die vom aktuellen Agenten delegierte Arbeit überprüfen | | `"all"` | Alle sichtbaren Agents | Überprüfen Sie den vollständigen Sitzungsbaum, ohne ihn für die Koordination zu verwenden. | In Sitzungen mit einem einzelnen Agenten ist die Standardansicht auf untergeordnete Agenten zentriert. Bei Multi-Agent-Sitzungen zeigt die Standardansicht den unmittelbaren lokalen Kontext anstelle der gesamten Baumstruktur an. ```text list_agents(scope="siblings") list_agents(scope="children") list_agents(scope="all") ``` #### Nachrichten mit festgelegtem Geltungsbereich Verwenden Sie `scope` auf `write_agent`, um eine Nachricht an mehrere zugehörige Agents zu senden. Verwenden Sie Scoped Messaging nur von einem Subagenten, der innerhalb einer übergeordneten Sitzung mit aktivierter gemeinsamer gleichgeordneter Kommunikation ausgeführt wird. Verwenden Sie in Sitzungen der obersten Ebene stattdessen Agents mit expliziten `agent_id`-Werten als Ziel. | `scope` Wert | Sendet an | Verwenden Sie es, um | | ------------ | ------------------------------------------------ | ------------------------------------------------------------------------------- | | `"siblings"` | Alle sichtbaren verwandten Agenten | Koordinieren Sie die Zusammenarbeit unter Kollegen in einer gemeinsamen Sitzung | | `"children"` | Alle untergeordneten Agents des aktuellen Agents | Dieselbe Nachverfolgung an delegierte Aufgaben senden | Wenn ein Geltungsbereich zu viele Agenten umfasst, gibt `write_agent` einen Fehler zurück und fordert stattdessen explizite `agent_id`-Werte von `list_agents` an. ```text write_agent(scope="children", message="Re-check your findings against the updated schema.") write_agent(scope="siblings", message="Post status when your current check completes.") write_agent(agent_id="explore-auth", message="Focus on token refresh flow and report only confirmed issues.") ``` ### Subagent-Grenzwerte Die CLI erzwingt Tiefen- und Gleichzeitigkeitsbegrenzungen, um zu verhindern, dass Agenten aus dem Ruder laufen. | Begrenzung | Vorgabe | Max. | | ------------------------ | ----------- | ----- | | Max. Tiefe | `6` | `256` | | Maximal zulässige Anzahl | planbasiert | `32` | **Die Tiefe** zählt, wie viele Agents ineinander geschachtelt sind. Wenn die Tiefenbeschränkung erreicht ist, kann der innerste Agent keine weiteren Subagenten erzeugen. **Parallelität** zählt, wie viele Unteragenten im gesamten Sitzungsbaum gleichzeitig laufen. Wenn der Grenzwert erreicht ist, werden neue Anfragen von Subagenten abgelehnt, bis ein aktiver Agent fertig ist. Der Standardmäßige Parallelitätsgrenzwert hängt von Ihrem Copilot Plan ab: | Planen | Maximal zulässige Anzahl | | ---------------------------- | ------------------------ | | Kostenlos / Bildung | `2` | | Pro / Pro+ | `4` | | Max. | `8` | | Geschäftlich | `16` | | Enterprise | `32` | | Nutzungsbasierte Abrechnung: | `32` | Benutzer mit nutzungsbasierter Abrechnung können diese Beschränkungen mit den Einstellungen `subagents.maxConcurrency` und `subagents.maxDepth` außer Kraft setzen: ```json { "subagents": { "maxConcurrency": 16, "maxDepth": 10 } } ``` Werte außerhalb des gültigen Bereichs werden begrenzt: `maxConcurrency` wird auf `32` begrenzt, und `maxDepth` wird auf `256` begrenzt. Diese Einstellungen werden für Pläne ignoriert, die keine nutzungsbasierte Abrechnung verwenden. Siehe [Konfigurationsdateieinstellungen](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). ## Sidekick-Agenten Sidekick-Agents laufen automatisch im Hintergrund und stellen Kontext im Posteingang der Sitzung bereit. Sie reagieren auf Sitzungsereignisse, anstatt explizit aufgerufen zu werden. Fügen Sie einer beliebigen Agentdefinition einen `sidekick:` Block hinzu, um ihn zu einem Sidekick-Agent zu machen: ```yaml --- name: Context Gatherer description: Gathers relevant context when the working directory changes sidekick: triggers: - session.context_changed - event: user.message limit: 1 behavior: persistent maxSendsPerTurn: 2 --- Gather useful context about the current repository and working directory. Summarize recent changes and any relevant project structure. ``` ### Sidekick-Trigger Jeder Eintrag in `triggers` ist entweder eine bloße Ereignisnamen-Zeichenfolge, die beliebig oft ausgelöst wird, oder ein Objekt mit `event` und einem optionalen `limit`. | Ereignis | Beschreibung | | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | | `user.message` | Wird für jede Benutzernachricht ausgelöst. | | `session.context_changed` | Wird ausgelöst, wenn sich das Arbeitsverzeichnis, das Repository oder der Branch ändert (z. B. nach `cd` oder nach dem Wechseln von Git-Branches). | | Triggerfeld | Typ | Vorgabe | Beschreibung | | ----------- | -------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------ | | `event` | `string` | Erforderlich | Sitzungsereignistyp, der diesen Agent startet. | | `limit` | `number` | Unbegrenzt | Maximale Anzahl, wie oft dieser Auslöser pro Sitzung ausgelöst werden kann. Muss beim Festlegen eine positive ganze Zahl sein. | ### Sidekick-Konfigurationsfelder | Feld | Typ | Vorgabe | Beschreibung | | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | `triggers` | | | | | `string[]` oder objekt\[] | Erforderlich | Sitzungsereignistypen, die diesen Agent starten. Mindestens ein Trigger ist erforderlich. | | | `behavior` | `string` | `"restart"` | | | `"restart"`: Brechen Sie jede vorherige Ausführung ab, und beginnen Sie auf jedem Trigger neu. | | | | | `"persistent"`: Behalten Sie dieselbe lang laufende Ausführung bei und speisen Sie neue Nachrichten in die bestehende Schleife ein, anstatt sie neu zu starten. | | | | | `maxSendsPerTurn` | `number` | `1` | Maximal zulässige Inbox-Sendungen pro Trigger. Im `"persistent"` Modus setzt jede übermittelte Benutzernachricht dieses Budget zurück. | Das Verhalten von `"restart"` eignet sich für zustandslose Agenten zur Kontextsammlung. Das Verhalten `"persistent"` eignet sich für Agenten, die über mehrere Interaktionen hinweg Zustand akkumulieren. ## Berechtigungsgenehmigungsantworten Wenn die CLI zur Berechtigung zum Ausführen eines Vorgangs auffordert, können Sie mit den folgenden Schlüsseln antworten. | Schlüssel | Auswirkung | | --------- | --------------------------------------------------------------------- | | `y` | Diese bestimmte Anforderung einmal zulassen. | | `n` | Verweigern Sie diese spezifische Anforderung einmal. | | `!` | Alle ähnlichen Anfragen für die restliche Sitzung zulassen. | | `#` | Verweigern Sie alle ähnlichen Anforderungen für den Rest der Sitzung. | | `?` | Detaillierte Informationen zur Anforderung anzeigen. | Wenn das vollständige Dialogfeld angezeigt wird, können Sie auch aus den folgenden Optionen wählen: | Auswahl | Geltungsbereich | Ausdauer | | ---------- | -------------------------- | ------------------------------------------- | | Einmal | Einzelverwendung | Nichts | | Dieser Ort | Bis zur manuellen Löschung | Auf datenträger pro Speicherort gespeichert | | Immer | Unbefristet | Konfigurationsdatei | Die Option **"Dieser Speicherort"** wird angezeigt, wenn die CLI einen Speicherortschlüssel (Git-Stamm oder aktuelles Verzeichnis) ermitteln kann. Die Genehmigung wird auf dem Datenträger gespeichert, so dass dieselbe Berechtigung automatisch erteilt wird, wenn Sie das nächste Mal in diesem Verzeichnis arbeiten, ohne dass Sie erneut gefragt werden. Wenn ein Shellbefehl die Toolgenehmigung und den Zugriff auf Pfade außerhalb der zulässigen Verzeichnisse benötigt, kann die CLI beide Genehmigungen in einer Eingabeaufforderung kombinieren. Ein einmaliges Genehmigen gewährt nur für diese Ausführung Pfadzugriff. Durch die Genehmigung für die Sitzung oder den Speicherort wird auch der Pfadzugriff für die restliche Sitzung gewährt. Verwenden Sie `/reset-allowed-tools`, um Sitzungsgenehmigungen für die aktuelle Sitzung zu löschen. ### URL-Genehmigungen für übergeordnete Domänen URL-Genehmigungsaufforderungen können zusätzlich zum genauen Ursprung auch einen Bereich der übergeordneten Domäne anbieten, etwa `https://*.example.com`. Dadurch wird jede Unterdomäne der registrierbaren Domäne, z. B. `api.example.com` und `flow.example.com`, für den Rest der Sitzung genehmigt. Der Bereich hat folgende Einschränkungen: * Die Genehmigung gilt nur für die aktuelle Sitzung und wird nie in Den Einstellungen gespeichert. * Das Schema und ein ggf. angegebener nicht standardmäßiger Port müssen übereinstimmen. * Hosts unter einem gesondert verwalteten Suffix, z. B. `s3.amazonaws.com`, werden nicht von der Genehmigung `*.amazonaws.com` abgedeckt. Dadurch wird verhindert, dass sich eine Genehmigung für \*.amazonaws.com auf Buckets unter s3.amazonaws.com erstreckt, die möglicherweise zu anderen Mandanten gehören. * IP-Adressen, Single-Label-Hosts wie `localhost` und öffentliche Suffixe wie `github.io` erhalten diese Option nicht. ## Sicherheit ### Planmodus `/plan` startet eine Planungssitzung, in der Copilot CLI Ihre Codebasis erkunden und analysieren kann, jedoch daran gehindert wird, Ihre Projektdateien zu bearbeiten. Specifically: * **Ihre Projektdateien sind geschützt.** Jeder Versuch, einen Shellbefehl zu bearbeiten, zu patchen oder auszuführen, der eine Datei in Ihrem Arbeitsbereich ändern würde, wird automatisch blockiert . Dies ist nicht nur ein Vorschlag für das Modell, es wird direkt erzwungen, sodass es nicht von dem Modell abhängt, das sich verhalten soll. * **Der Plan selbst kann noch geschrieben werden.** Copilot benötigt an einer beliebigen Stelle Notizen und Entwürfe des Plans, sodass es erlaubt ist, Dateien in einem eigenen privaten Planungsarbeitsbereich zu erstellen und zu bearbeiten (einschließlich der Plandatei, die Sie überprüfen und genehmigen). * **Delegierte Unteraufgaben sind ebenfalls geschützt.** Wenn Copilot eine Hilfssitzung startet, um einen Teil Ihrer Frage zu recherchieren, unterliegt diese Hilfssitzung denselben Einschränkungen und kann Ihr Projekt ebenfalls nicht bearbeiten. * **Es ist ein Sicherheitsnetz, keine Garantie.** Dieser Schutz ist darauf ausgelegt, klare, direkte Versuche zu erkennen, Ihre Dateien zu ändern – er ist jedoch kein absolut wasserdichter Schutz. Einige Dinge sind absichtlich erlaubt, sodass die Recherche nicht übermäßig eingeschränkt ist: z. B. Shellbefehle, deren Wirkung im Voraus nicht eindeutig bestimmt werden kann, und Aufrufe an externe/MCP-Tools, die Sie verbunden haben. In der Praxis ist dies selten ein Problem, aber der Planmodus sollte als "Änderungen erfordern Ihre Überprüfung vor der Anwendung" betrachtet werden, nicht eine absolute Garantie dafür, dass sich nichts auf dem Datenträger ändern kann. Sobald Sie mit dem Plan zufrieden sind, bestätigen Sie ihn, um den Planmodus zu verlassen und Copilot die eigentlichen Änderungen vornehmen zu lassen. ### Befehlssicherheitsanalyse Shellbefehle werden vor der Ausführung analysiert, um potenziell gefährliche Muster zu identifizieren: * Dateilöschung (`rm -rf`) * Systemänderungen (`sudo`, `chmod 777`) * Netzwerkexfiltration (`curl` mit vertraulichen Pfaden) * Zugriff auf Anmeldeinformationen (Auslesen von `.env`, SSH-Schlüsseln) * Inline-Zuweisungen von Umgebungsvariablen, die gefährliche Variablen überschreiben (z. B. `PATH=...`, `LD_PRELOAD=...`) Befehle mit hohem Risiko können zusätzliche Warnungen und Genehmigungsaufforderungen auslösen. Ob eine Anforderung Ihre Genehmigung benötigt, hängt von den geltenden Berechtigungen ab. Wenn die Sandbox aktiviert ist und die Einstellung **Umgehung der Sandbox zulassen** aktiviert ist (standardmäßig), werden Sie bei einem synchronen Shell-Befehl, der durch die Dateisystem- oder Netzwerkrichtlinie der Sandbox blockiert wird, aufgefordert, ihn außerhalb der Sandbox erneut auszuführen – ein Roundtrip mit dem Modell ist nicht erforderlich. Durch das Bestätigen der Aufforderung wird der Befehl erneut ausgeführt und seine Ausgabe zurückgegeben. Durch Ablehnen bleibt das Ergebnis in der Sandbox (blockiert) erhalten. Eine Aufforderung zum Umgehen der Sandbox bietet außerdem die Option **Ja, und die Sandbox für den Rest dieser Sitzung deaktivieren**. Wenn Sie dies auswählen, wird das Sandboxing für alle verbleibenden Befehle in der aktuellen Sitzung deaktiviert, nicht nur für den Befehl, den Sie gerade genehmigen. Dies gilt nur für die aktuelle Sitzung – beim Starten einer neuen Sitzung mit `/new` werden Befehle wieder in der Sandbox ausgeführt, und die Option hat keine Auswirkungen auf die gespeicherte `sandbox`-Konfigurationseinstellung oder auf andere laufende Sitzungen. Ein abgekoppelter (im Hintergrund ausgeführter) Befehl kann überhaupt nicht in einer Sandbox ausgeführt werden, da die Sandbox keinen Prozess kapseln kann, der den Aufruf des Tools überdauert. Wenn die Einstellung **„Sandkastenumgehung zulassen“** aktiviert ist, wird vor dem Start des Befehls um Bestätigung gebeten, anstatt den Befehl sofort abzulehnen. Beim Genehmigen wird der Befehl von Anfang an ohne Sandbox ausgeführt. Auf Windows Hosts, deren Sandkastenrichtlinie die Denialerfassung unterstützt, eskaliert ein blockierter interaktiver Shellbefehl in einem einzigen Schritt, anstatt direkt zu einer vollständigen Umgehung zu springen. Durch die Genehmigung wird der Befehl erneut ausgeführt, wobei Datei- und Prozesseinschränkungen so festgelegt werden, dass sie aufzeichnen statt blockieren (die Netzwerkrichtlinie gilt weiterhin); nur wenn der Befehl dann immer noch blockiert ist, wird auf den offengelegten vollständigen Bypass zurückgegriffen. Für die gesamte Eskalation wird nur eine Eingabeaufforderung angezeigt. Ein verweigerter Loopback- oder lokaler Netzwerk-Socket (z. B. beim Binden oder Verbinden mit `127.0.0.1`) führt ebenfalls zu derselben Eskalation, anstatt stillschweigend fehlzuschlagen. Das Ergebnis des erneuten Versuchs wird als „Sandbox gelockert“ bezeichnet, wenn die Netzwerkrichtlinie weiterhin erzwungen wird, oder als „Sandbox umgangen“, wenn die Sandbox vollständig aufgehoben ist. Wenn der Wiederholungsversuch weiterhin fehlschlägt, erklärt die Meldung, dass Berechtigungen auf Host-Ebene weiterhin gelten. Ein Befehl, der mit einer `EACCES`- oder `EPERM`-Diagnose fehlschlägt, die einen von der Sandbox blockierten Pfad nennt, bietet nun an, außerhalb der Sandbox ausgeführt zu werden, auch wenn in der Befehlszeile selbst dieser Pfad nie genannt wurde. Wenn eine Ablehnung durch einen Symlink verursacht wird, dessen Ziel außerhalb dessen liegt, was die Sandbox-Richtlinie gewährt, erklärt die Ablehnung, dass der Link des gewährten Pfads außerhalb der gewährten Freigabe verweist, und nennt das tatsächliche Ziel, sodass Sie genau wissen, welchen Pfad Sie Ihrer Sandbox-Richtlinie hinzufügen müssen. Weitere Informationen findest du unter [Konfigurieren lokaler Sandkasteneinstellungen](/de/copilot/how-tos/cloud-and-local-sandboxes/configuring-local-sandbox-settings#allowing-sandbox-bypass). #### Sperrliste für Umgebungsvariablen Die CLI blockiert die Inlinezuweisung von Umgebungsvariablen, die ausgenutzt werden können, um beliebigen Code auch in anderen schreibgeschützten Befehlen auszuführen. Blockierte Kategorien umfassen: | Kategorie | Beispiele | | ---------------------------------------------------------------------------------------------------------------------------- | --------- | | Dynamische-Linker-Injektion | | | `LD_*`, `DYLD_*` (alle Präfixe) | | | Indizierte Git-Konfigurationsüberschreibungen | | | `GIT_CONFIG_COUNT`, `GIT_CONFIG_KEY_*`, `GIT_CONFIG_VALUE_*` (alle `GIT_CONFIG_` Präfixe) | | | Externe Git-Programm-Hooks | | | `GIT_EXTERNAL_DIFF`, `GIT_PROXY_COMMAND` | | | Außerkraftsetzungen der Git-Konfigurationsdatei | | | `GIT_CONFIG`, `GIT_CONFIG_GLOBAL``GIT_CONFIG_SYSTEM` | | | Shell-PATH und Startdateien | | | `PATH`, `BASH_ENV``ENV` | | | Vorhandene blockierte Variablen | | | `PAGER`, `GIT_PAGER`, `GIT_EDITOR`, `VISUAL`, `EDITOR`, `GIT_SSH`, `GIT_SSH_COMMAND`, `GIT_ASKPASS`, `BROWSER`, `GH_BROWSER` | | ### `web_fetch` SSRF-Schutz Das `web_fetch` Tool erzwingt serverseitigen Anforderungsfälschungsschutz (SSRF), bevor eine HTTP-Anforderung ausgeführt wird: * **Protokoll-Zulassungsliste**: Nur `http://` und `https://` URLs sind zulässig. `file://` und andere Schemas werden abgelehnt. * **IP-Blockliste**: Anfragen an Loopback-Adressen (`127.x.x.x`, `::1`), private RFC-1918-Bereiche (`10.x`, `172.16–31.x`, `192.168.x`) und Cloud-Metadatenendpunkte (z. B. `169.254.169.254`) werden durch die Prüfung auf IP-Literale und vorgelagerte DNS-Auflösung blockiert. * **Validierte Umleitungen**: `web_fetch` folgt `3xx` Umleitungen (bis zu 10 Weiterleitungen innerhalb eines Netzwerkzeitbudgets von 60 Sekunden) und validiert das Ziel jeder Weiterleitung erneut anhand derselben IP-Blockliste, bevor es ihr folgt. Eine Umleitung zu einem anderen Ursprung als die ursprüngliche URL erfordert eine Berechtigungsgenehmigung, die gleiche wie alle anderen ursprungsübergreifenden Abrufe; Umleitungen desselben Ursprungs werden ohne zusätzliche Eingabeaufforderung befolgt. Das Endergebnis vermerkt, wann der Inhalt `(redirected from )` war. Wenn Sandboxing aktiviert ist, werden Anfragen bereits vor der Berechtigungsabfrage anhand der Sandbox-Netzwerkrichtlinie (ausgehender Zugriff, lokale und private Hosts) geprüft, sodass ein durch die Richtlinie blockiertes Ziel sofort fehlschlägt, anstatt eine Berechtigungsabfrage auszulösen. Wenn die **Einstellung "Sandkastenumgehung zulassen** " aktiviert ist und der Sandkastennetzwerkproxy keine URL erreichen kann – im Gegensatz zu der URL, die von der Richtlinie verweigert wird –`web_fetch` fordert Sie auf, die Anforderung außerhalb der Sandbox erneut auszuführen. Die Genehmigung führt zu einem weiteren Versuch beim Abruf und gibt das Ergebnis zurück. Legen Sie die folgende Umgebungsvariable fest, damit `web_fetch``localhost` während der Entwicklung erreichen kann – beispielsweise einen lokalen Dokumentationsserver: ```bash export COPILOT_WEB_FETCH_ALLOW_LOCALHOST=1 ``` ### Berechtigungen für das Sandbox-Toolverzeichnis Wenn lokales Sandboxing aktiviert ist, ermittelt Copilot CLI die Tool-Verzeichnisse, die ein in einer Sandbox ausgeführter Befehl voraussichtlich benötigt, und gewährt jedem davon **schreibgeschützten** Zugriff, sodass ein Befehl eine installierte Toolchain verwenden kann, ohne sie ändern zu können. Die Ermittlung wird für jeden Befehl ausgeführt, bevor der Prozess gestartet wird, und liest zwei Arten von Quelle aus der Umgebung des Befehls. * **`PATH`** (`Path` unter Windows). Jedes aufgelistete Verzeichnis ist eine Kandidatenzuteilung. * **Benannte Toolkettevariablen.** Die CLI prüft die Variablen in der folgenden Tabelle. Ein Verzeichniswert gewährt Zugriff auf dieses Verzeichnis. Eine Pfadliste wird anhand des Pfadtrennzeichens des Betriebssystems aufgeteilt (ein Semikolon unter Windows, ein Doppelpunkt an anderer Stelle), und jeder Eintrag wird zu einer potenziellen Berechtigung. Die Git-Dateivariablen werden nur unter macOS und Linux überprüft. Ein Verzeichniskandidat wird nur akzeptiert, wenn es sich um einen absoluten Pfad handelt, der als Verzeichnis vorhanden ist. Relative Pfade, fehlende Pfade, Dateisystemwurzeln (z. B. `/` oder `C:\`) und systemkritische Speicherorte werden von der Ermittlung ausgeschlossen. Beispiele für ausgeschlossene Standorte sind `%WINDIR%` unter Windows und `/bin`, `/sbin`, `/usr/bin`, `/usr/sbin`, `/boot`, `/proc`, `/sys` und `/dev` unter macOS und Linux. Der Grund wird in `sandbox_spawn` protokolliert. Diese Berechtigungen behalten ihre Pfadangabe bei, anstatt automatisch das Ziel einer symbolischen Verknüpfung hinzuzufügen. Wenn der Zugriff über einen Link blockiert ist, gewähren Sie dem beabsichtigten Ziel ausdrücklich Zugriff. Doppelte Verzeichnisse werden unter Windows ohne Beachtung der Groß-/Kleinschreibung entfernt. | Variable | Toolkette | Wert | In der Regel aktiviert | | ----------------------- | -------------------------- | --------------------- | ---------------------- | | `BAZEL_VC` | Bazel / Visual C++ | Einzelnes Verzeichnis | Windows | | `BAZEL_VS` | Bazel / Visual Studio | Einzelnes Verzeichnis | Windows | | `BAZELISK_HOME` | Bazelisk | Einzelnes Verzeichnis | All | | `BAZELISK_HOME_DARWIN` | Bazelisk | Einzelnes Verzeichnis | macOS | | `BAZELISK_HOME_LINUX` | Bazelisk | Einzelnes Verzeichnis | Linux | | `BAZELISK_HOME_WINDOWS` | Bazelisk | Einzelnes Verzeichnis | Windows | | `CONDA_PREFIX` | Conda | Einzelnes Verzeichnis | All | | `DOTNET_ROOT` | .NET | Einzelnes Verzeichnis | All | | `GIT_CONFIG_SYSTEM` | Git-Systemkonfiguration | Datei | macOS und Linux | | `GIT_EXEC_PATH` | Git-Hilfsprogramme | Einzelnes Verzeichnis | All | | `GIT_SSL_CAINFO` | Git-Zertifikatpaket | Datei | macOS und Linux | | `GIT_SSL_CAPATH` | Git-Zertifikate | Einzelnes Verzeichnis | All | | `GIT_TEMPLATE_DIR` | Git-Vorlagen | Einzelnes Verzeichnis | All | | `GOPATH` | Go | Pfadliste | All | | `GOROOT` | Go | Einzelnes Verzeichnis | All | | `JAVA_HOME` | Java | Einzelnes Verzeichnis | All | | `LD_LIBRARY_PATH` | Freigegebene Bibliotheken | Pfadliste | Linux | | `NODE_PATH` | Node.js | Pfadliste | All | | `NVM_HOME` | Node.js (nvm) | Einzelnes Verzeichnis | Windows | | `NVM_SYMLINK` | Node.js (nvm) | Einzelnes Verzeichnis | Windows | | `PATH` / `Path` | Ausführbare Dateien (alle) | Pfadliste | All | | `PSModulePath` | PowerShell | Pfadliste | All | | `PYENV_ROOT` | Python (Pyenv) | Einzelnes Verzeichnis | All | | `PYTHONHOME` | Python | Einzelnes Verzeichnis | All | | `PYTHONPATH` | Python | Pfadliste | All | | `RUSTUP_HOME` | Rust (rustup) | Einzelnes Verzeichnis | All | | `VCINSTALLDIR` | Visual C++ | Einzelnes Verzeichnis | Windows | | `VCPKG_ROOT` | vcpkg | Einzelnes Verzeichnis | All | | `VIRTUAL_ENV` | Python (venv) | Einzelnes Verzeichnis | All | | `VSINSTALLDIR` | Visual Studio | Einzelnes Verzeichnis | Windows | Mit Ausnahme der beiden Git-Dateivariablen wird jede Variable auf jeder Plattform gelesen. Die Spalte **Typischerweise festgelegt auf** zeigt, wo jeder Eintrag normalerweise ausgefüllt wird. Eine nicht festgelegte Variable trägt nichts bei. `CARGO_HOME` wird separat über toolspezifische Berechtigungen für ausgewählte Cargo-Verzeichnisse und Dateien abgewickelt. Es gewährt keinen Zugang zum gesamten Cargo Home. Entwicklertool-Zuschüsse können auch verschobenen Caches folgen, einschließlich Go- und NuGet-Caches. Dies sind nicht die einzigen automatisch gewährten Berechtigungen. Mit aktiviertem Copilot CLI gewährt \*\*\*\* ausgewählten Anwendungsverzeichnissen im Benutzerprofil, einschließlich `~/.local/bin` und `~/.local/lib` unter macOS und Linux sowie den unmittelbaren Unterverzeichnissen von `%LOCALAPPDATA%\Programs` unter Windows. Außerdem werden toolspezifische Caches und Registrys gewährt, von denen einige schreibbar sind, z. B. npms Cache und freigegebene Buildcaches. Führen Sie `/sandbox policy` aus, um die aufgelösten Pfade nach Quelle und Zugriff gruppiert anzuzeigen. Im Abschnitt **Dev tools** werden Tools aufgelistet, die im aktuellen Verzeichnis erkannt wurden, sowie ihre Pfade. Fügen Sie einen Befehl hinzu, z. B. `/sandbox policy npm install`, um den Zugriff auf die Entwicklertools zu überprüfen, ohne ihn auszuführen. Der Bericht erstellt fehlende Caches nicht. Die Konzepte für die Erstellung der Richtlinie finden Sie unter [Grundlegendes zu Dateisystemrichtlinien für lokale Sandboxing in GitHub Copilot CLI](/de/copilot/concepts/security-governance-and-network-settings/understanding-local-sandboxing). ## OpenTelemetry-Überwachung Copilot CLI und andere Copilot Clients unterstützen die OpenTelemetry(OTel)-Überwachung. Informationen zu Konfigurationsoptionen, exportierten Signalen und Attributen finden Sie unter [OpenTelemetry reference](/de/copilot/reference/enterprise-administrators/opentelemetry-reference). OTel ist standardmäßig deaktiviert und hat keinen Mehraufwand. Sie wird aktiviert, wenn eine der folgenden Bedingungen erfüllt ist: * `COPILOT_OTEL_ENABLED=true` * `OTEL_EXPORTER_OTLP_ENDPOINT` ist festgelegt. * `COPILOT_OTEL_FILE_EXPORTER_PATH` ist festgelegt. ## Weiterführende Lektüre * [GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli) * [GitHub Copilot-Hooks-Referenz](/de/copilot/reference/hooks-reference) * [GitHub Copilot CLI-Plug-In-Referenz](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference) * [Programmgesteuerte Referenz für die GitHub Copilot-CLI](/de/copilot/reference/copilot-cli-reference/cli-programmatic-reference) * [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference)