{"meta":{"title":"Wiederaufnahme und Persistenz der Sitzung","intro":"Dieses Handbuch führt Sie durch die Sitzungspersistenzfunktionen des SDK – wie Sie die Arbeit anhalten, später fortsetzen und Sitzungen in Produktionsumgebungen verwalten können.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos","title":"Vorgehensweisen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk","title":"Copilot SDK"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features","title":"Funktionen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/session-persistence","title":"Sitzungspersistenz"}],"documentType":"article"},"body":"# Wiederaufnahme und Persistenz der Sitzung\n\nDieses Handbuch führt Sie durch die Sitzungspersistenzfunktionen des SDK – wie Sie die Arbeit anhalten, später fortsetzen und Sitzungen in Produktionsumgebungen verwalten können.\n\n<!-- markdownlint-disable GHD046 GHD005 -->\n\n<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->\n\n## Funktionsweise von Sitzungen\n\nWenn Sie eine Sitzung erstellen, speichert die Copilot CLI den Konversationsverlauf, den Status der Tools und den Planungskontext. Dieser Zustand befindet sich standardmäßig im Arbeitsspeicher und verschwindet, wenn die Sitzung endet. Mit aktivierter Persistenz können Sie Sitzungen über Neustarts, Containermigrationen oder sogar unterschiedliche Clientinstanzen hinweg fortsetzen.\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-0.png)\n\n| State                   | Was ist los                                              |\n| ----------------------- | -------------------------------------------------------- |\n| **Erstellen**           |                                                          |\n| `session_id` Zugewiesen |                                                          |\n| **Aktiv**               | Senden von Eingabeaufforderungen, Toolanrufen, Antworten |\n| **Pausiert**            | Auf dem Datenträger gespeicherter Zustand                |\n| **Resume**              | Vom Datenträger geladener Zustand                        |\n\n## Schnellstart: Erstellen einer reaktivierbaren Sitzung\n\nDer Schlüssel zu wiederaufnehmbaren Sitzungen ist, dass Sie Ihre eigene `session_id` bereitstellen. Ohne eine generiert das SDK eine zufällige ID, und die Sitzung kann später nicht fortgesetzt werden.\n\n### Typescript\n\n```typescript\nimport { CopilotClient } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient();\n\n// Create a session with a meaningful ID\nconst session = await client.createSession({\n  sessionId: \"user-123-task-456\",\n  model: \"gpt-5.2-codex\",\n});\n\n// Do some work...\nawait session.sendAndWait({ prompt: \"Analyze my codebase\" });\n\n// Session state is automatically persisted\n// You can safely close the client\n```\n\n### Python\n\n```python\nfrom copilot import CopilotClient\nfrom copilot.session import PermissionHandler\n\nclient = CopilotClient()\nawait client.start()\n\n# Create a session with a meaningful ID\nsession = await client.create_session(on_permission_request=PermissionHandler.approve_all, model=\"gpt-5.2-codex\", session_id=\"user-123-task-456\")\n\n# Do some work...\nawait session.send_and_wait(\"Analyze my codebase\")\n\n# Session state is automatically persisted\n```\n\n### Go\n\n```golang\nctx := context.Background()\nclient := copilot.NewClient(nil)\n\n// Create a session with a meaningful ID\nsession, _ := client.CreateSession(ctx, &copilot.SessionConfig{\n    SessionID: \"user-123-task-456\",\n    Model:     \"gpt-5.2-codex\",\n})\n\n// Do some work...\nsession.SendAndWait(ctx, copilot.MessageOptions{Prompt: \"Analyze my codebase\"})\n\n// Session state is automatically persisted\n```\n\n### C# (.NET)\n\n```csharp\nusing GitHub.Copilot;\n\nvar client = new CopilotClient();\n\n// Create a session with a meaningful ID\nvar session = await client.CreateSessionAsync(new SessionConfig\n{\n    SessionId = \"user-123-task-456\",\n    Model = \"gpt-5.2-codex\",\n});\n\n// Do some work...\nawait session.SendAndWaitAsync(new MessageOptions { Prompt = \"Analyze my codebase\" });\n\n// Session state is automatically persisted\n```\n\n## Fortsetzen einer Sitzung\n\nSpäter – Minuten, Stunden oder sogar Tage – können Sie die Sitzung fortsetzen, von wo Sie aufgehört haben.\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-1.png)\n\n### Typescript\n\n```typescript\n// Resume from a different client instance (or after restart)\nconst session = await client.resumeSession(\"user-123-task-456\");\n\n// Continue where you left off\nawait session.sendAndWait({ prompt: \"What did we discuss earlier?\" });\n```\n\n### Python\n\n```python\n# Resume from a different client instance (or after restart)\nsession = await client.resume_session(\"user-123-task-456\", on_permission_request=PermissionHandler.approve_all)\n\n# Continue where you left off\nawait session.send_and_wait(\"What did we discuss earlier?\")\n```\n\n### Go\n\n```golang\nctx := context.Background()\n\n// Resume from a different client instance (or after restart)\nsession, _ := client.ResumeSession(ctx, \"user-123-task-456\", nil)\n\n// Continue where you left off\nsession.SendAndWait(ctx, copilot.MessageOptions{Prompt: \"What did we discuss earlier?\"})\n```\n\n### C# (.NET)\n\n```csharp\n// Resume from a different client instance (or after restart)\nvar session = await client.ResumeSessionAsync(\"user-123-task-456\");\n\n// Continue where you left off\nawait session.SendAndWaitAsync(new MessageOptions { Prompt = \"What did we discuss earlier?\" });\n```\n\n## Optionen für \"Fortsetzen\"\n\nBeim Fortsetzen einer Sitzung können Sie optional viele Einstellungen neu konfigurieren. Dies ist nützlich, wenn Sie das Modell ändern, Toolkonfigurationen aktualisieren oder das Verhalten ändern müssen.\n\n| Auswahl            | Description                                                                            |\n| ------------------ | -------------------------------------------------------------------------------------- |\n| `model`            | Ändern des Modells für die fortgesetzte Sitzung                                        |\n| `systemMessage`    | Überschreiben oder Erweitern der Systemaufforderung                                    |\n| `availableTools`   | Einschränken der verfügbaren Tools                                                     |\n| `excludedTools`    | Deaktivieren bestimmter Tools                                                          |\n| `provider`         | Erneutes Bereitstellen von BYOK-Anmeldeinformationen (erforderlich für BYOK-Sitzungen) |\n| `reasoningEffort`  | Anpassen der Aufwandsstufe für die Begründung                                          |\n| `streaming`        | Aktivieren oder Deaktivieren von Streaming-Antworten                                   |\n| `workingDirectory` | Ändern des Arbeitsverzeichnisses                                                       |\n| `configDir`        | Konfigurationsverzeichnis außer Kraft setzen                                           |\n| `mcpServers`       | MCP-Server konfigurieren                                                               |\n| `customAgents`     | Konfigurieren von benutzerdefinierten Agents                                           |\n| `agent`            | Vorauswahl eines benutzerdefinierten Agents anhand des Namens                          |\n| `skillDirectories` | Verzeichnisse, aus denen Fähigkeiten geladen werden                                    |\n| `disabledSkills`   | Zu deaktivierende Fähigkeiten                                                          |\n| `infiniteSessions` | Konfigurieren des unendlichen Sitzungsverhaltens                                       |\n\n### Beispiel: Ändern des Modells bei der Wiederaufnahme\n\n```typescript\n// Resume with a different model\nconst session = await client.resumeSession(\"user-123-task-456\", {\n  model: \"claude-sonnet-4\",  // Switch to a different model\n  reasoningEffort: \"high\",   // Increase reasoning effort\n});\n```\n\n## Verwendung von BYOK (bring your own key) mit wiederaufgenommenen Sitzungen\n\nWenn Sie Ihre eigenen API-Schlüssel verwenden, müssen Sie die Anbieterkonfiguration beim Fortsetzen erneut bereitstellen. API-Schlüssel werden aus Sicherheitsgründen niemals auf dem Datenträger beibehalten.\n\n```typescript\n// Original session with BYOK\nconst session = await client.createSession({\n  sessionId: \"user-123-task-456\",\n  model: \"gpt-5.2-codex\",\n  provider: {\n    type: \"azure\",\n    endpoint: \"https://my-resource.openai.azure.com\",\n    apiKey: process.env.AZURE_OPENAI_KEY,\n    deploymentId: \"my-gpt-deployment\",\n  },\n});\n\n// When resuming, you MUST re-provide the provider config\nconst resumed = await client.resumeSession(\"user-123-task-456\", {\n  provider: {\n    type: \"azure\",\n    endpoint: \"https://my-resource.openai.azure.com\",\n    apiKey: process.env.AZURE_OPENAI_KEY,  // Required again\n    deploymentId: \"my-gpt-deployment\",\n  },\n});\n```\n\n## Was wird persistiert?\n\nDer Sitzungsstatus wird gespeichert in `~/.copilot/session-state/{sessionId}/`:\n\n```text\n~/.copilot/session-state/\n└── user-123-task-456/\n    ├── checkpoints/           # Conversation history snapshots\n    │   ├── 001.json          # Initial state\n    │   ├── 002.json          # After first interaction\n    │   └── ...               # Incremental checkpoints\n    ├── plan.md               # Agent's planning state (if any)\n    └── files/                # Session artifacts\n        ├── analysis.md       # Files the agent created\n        └── notes.txt         # Working documents\n```\n\n| Daten                            | Persistiert?                                  | Hinweise |\n| -------------------------------- | --------------------------------------------- | -------- |\n| Aufgezeichnete Unterhaltungen    |                                               |          |\n| ✅ Ja                             | Vollständiger Nachrichtenthread               |          |\n| Ergebnisse des Toolaufrufs       |                                               |          |\n| ✅ Ja                             | Im Cache gespeichert für Kontext              |          |\n| Planungsstatus des Agenten       |                                               |          |\n| ✅ Ja                             |                                               |          |\n| `plan.md`-Datei                  |                                               |          |\n| Sitzungsartefakte                |                                               |          |\n| ✅ Ja                             | Im `files/` Verzeichnis                       |          |\n| Anbieter-/API-Schlüssel          |                                               |          |\n| ❌ Nein                           | Sicherheit: muss erneut bereitgestellt werden |          |\n| Status des Arbeitsspeicher-Tools |                                               |          |\n| ❌ Nein                           | Tools sollten zustandslos sein                |          |\n\n## Bewährte Methoden für Sitzungs-ID\n\nWählen Sie Sitzungs-IDs aus, die Besitz und Zweck codieren. Dies erleichtert die Überwachung und Bereinigung.\n\n| Pattern                         | Example                                         | Anwendungsfall |\n| ------------------------------- | ----------------------------------------------- | -------------- |\n| ❌                               |                                                 |                |\n| `abc123`                        |                                                 |                |\n| Zufällige IDs                   | Schwer zu überwachen, keine Besitzinformationen |                |\n| ✅                               |                                                 |                |\n| `user-{userId}-{taskId}`        |                                                 |                |\n| `user-alice-pr-review-42`       | Apps mit mehreren Benutzern                     |                |\n| ✅                               |                                                 |                |\n| `tenant-{tenantId}-{workflow}`  |                                                 |                |\n| `tenant-acme-onboarding`        | Mehrinstanzenfähige SaaS                        |                |\n| ✅                               |                                                 |                |\n| `{userId}-{taskId}-{timestamp}` |                                                 |                |\n| `alice-deploy-1706932800`       | Zeitbasierte Bereinigung                        |                |\n\n**Vorteile strukturierter IDs:**\n\n* Einfach zu überwachen: \"Alle Sitzungen für Benutzer alice anzeigen\"\n* Einfach zu bereinigen: \"Alle Sitzungen löschen, die älter als X sind\"\n* Natürliche Zugriffskontrolle: Parsen der Benutzer-ID aus der Sitzungs-ID\n\n### Beispiel: Generieren von Sitzungs-IDs\n\n```typescript\nfunction createSessionId(userId: string, taskType: string): string {\n  const timestamp = Date.now();\n  return `${userId}-${taskType}-${timestamp}`;\n}\n\nconst sessionId = createSessionId(\"alice\", \"code-review\");\n// → \"alice-code-review-1706932800000\"\n```\n\n```python\nimport time\n\ndef create_session_id(user_id: str, task_type: str) -> str:\n    timestamp = int(time.time())\n    return f\"{user_id}-{task_type}-{timestamp}\"\n\nsession_id = create_session_id(\"alice\", \"code-review\")\n# → \"alice-code-review-1706932800\"\n```\n\n## Verwalten des Sitzungslebenszyklus\n\n### Auflisten aktiver Sitzungen\n\n```typescript\n// List all sessions\nconst sessions = await client.listSessions();\nconsole.log(`Found ${sessions.length} sessions`);\n\nfor (const session of sessions) {\n  console.log(`- ${session.sessionId} (created: ${session.createdAt})`);\n}\n\n// Filter sessions by repository\nconst repoSessions = await client.listSessions({ repository: \"owner/repo\" });\n```\n\n### Bereinigen von alten Sitzungen\n\n```typescript\nasync function cleanupExpiredSessions(maxAgeMs: number) {\n  const sessions = await client.listSessions();\n  const now = Date.now();\n  \n  for (const session of sessions) {\n    const age = now - new Date(session.createdAt).getTime();\n    if (age > maxAgeMs) {\n      await client.deleteSession(session.sessionId);\n      console.log(`Deleted expired session: ${session.sessionId}`);\n    }\n  }\n}\n\n// Clean up sessions older than 24 hours\nawait cleanupExpiredSessions(24 * 60 * 60 * 1000);\n```\n\n### Getrennt von einer Sitzung (`disconnect`)\n\nWenn eine Aufgabe abgeschlossen ist, trennen Sie die Verbindung mit der Sitzung explizit, anstatt auf Timeouts zu warten. Dadurch werden Speicherressourcen freigegeben, **sitzungsdaten jedoch auf dem Datenträger beibehalten**, sodass die Sitzung später noch fortgesetzt werden kann:\n\n```typescript\ntry {\n  // Do work...\n  await session.sendAndWait({ prompt: \"Complete the task\" });\n  \n  // Task complete — release in-memory resources (session can be resumed later)\n  await session.disconnect();\n} catch (error) {\n  // Clean up even on error\n  await session.disconnect();\n  throw error;\n}\n```\n\nJedes SDK stellt außerdem idiomatische automatische Bereinigungsmuster bereit:\n\n| Sprache                      | Pattern                                                                             | Example                                                              |\n| ---------------------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------- |\n| **TypeScript**               | `Symbol.asyncDispose`                                                               | `await using session = await client.createSession(config);`          |\n| **Python**                   |                                                                                     |                                                                      |\n| `async with` Kontext-Manager | `async with await client.create_session(on_permission_request=handler) as session:` |                                                                      |\n| **C#**                       | `IAsyncDisposable`                                                                  | `await using var session = await client.CreateSessionAsync(config);` |\n| **Go**                       | `defer`                                                                             | `defer session.Disconnect()`                                         |\n\n> \\[!NOTE]\n> `destroy()` wird zugunsten von `disconnect()` eingestellt. Bestehender Code, der `destroy()` verwendet, funktioniert weiterhin, sollte aber migriert werden.\n\n### Dauerhaftes Löschen einer Sitzung (`deleteSession`)\n\nUm eine Sitzung und alle zugehörigen Daten dauerhaft vom Datenträger zu entfernen (Aufgezeichnete Unterhaltungen, Planungszustand, Artefakte), verwenden Sie `deleteSession`. Dies ist unumkehrbar – die Sitzung kann nach dem Löschen **nicht** fortgesetzt werden:\n\n```typescript\n// Permanently remove session data\nawait client.deleteSession(\"user-123-task-456\");\n```\n\n> **`disconnect()` vs `deleteSession()`:**`disconnect()` veröffentlicht Speicherressourcen, behält jedoch Sitzungsdaten auf dem Datenträger für die spätere Wiederaufnahme bei. `deleteSession()` Entfernt dauerhaft alles, einschließlich Dateien auf dem Datenträger.\n\n## Automatische Bereinigung: Idle Timeout\n\nStandardmäßig haben Sitzungen **kein Leerlauftimeout** und bleiben unbegrenzt bestehen, bis sie explizit getrennt oder gelöscht werden. Optional können Sie über `CopilotClientOptions.sessionIdleTimeoutSeconds` ein serverweites Leerlauf-Timeout konfigurieren:\n\n```typescript\nconst client = new CopilotClient({\n  sessionIdleTimeoutSeconds: 30 * 60, // 30 minutes\n});\n```\n\nWenn ein Timeout konfiguriert ist, werden Sitzungen ohne Aktivität für diese Dauer automatisch bereinigt. Auf `0` setzen oder weglassen, um die Funktion zu deaktivieren.\n\n> \\[!NOTE]\n> Diese Option gilt nur dann, wenn das SDK den Laufzeitprozess startet. Beim Herstellen einer Verbindung mit einem vorhandenen Server über `cliUrl`gilt die eigene Timeoutkonfiguration des Servers.\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-2.png)\n\nSitzungen mit aktiven Prozessen (laufende Befehle, Hintergrund-Agenten) werden unabhängig von der Timeouteinstellung immer vor einer Bereinigung aufgrund von Inaktivität geschützt.\n\nLauschen Sie auf Leerlaufereignisse, um auf Sitzungsinaktivität zu reagieren:\n\n```typescript\nsession.on(\"session.idle\", (event) => {\n  console.log(`Session idle for ${event.idleDurationMs}ms`);\n});\n```\n\n## Bereitstellungsmuster\n\n### Muster 1: ein CLI-Server pro Benutzer (empfohlen)\n\nAm besten geeignet für: Starke Isolation, Mehrinstanzenumgebungen, Azure dynamische Sitzungen.\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-3.png)\n\n\\*\\*Vorteile:\\*\\*✅ Vollständige Isolation | ✅ Einfache Sicherheit | ✅ Einfache Skalierung\n\n### Muster 2: gemeinsam genutzter CLI-Server (ressourceneffizient)\n\nAm besten geeignet für: Interne Tools, vertrauenswürdige Umgebungen, ressourcenbeschränkte Setups.\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-4.png)\n\n**Anforderungen:**\n\n* ⚠️ Eindeutige Sitzungs-IDs pro Benutzer\n* ⚠️ Zugriffssteuerung auf Anwendungsebene\n* ⚠️ Sitzungs-ID-Überprüfung vor Vorgängen\n\n```typescript\n// Application-level access control for shared CLI\nasync function resumeSessionWithAuth(\n  client: CopilotClient,\n  sessionId: string,\n  currentUserId: string\n): Promise<Session> {\n  // Parse user from session ID\n  const [sessionUserId] = sessionId.split(\"-\");\n  \n  if (sessionUserId !== currentUserId) {\n    throw new Error(\"Access denied: session belongs to another user\");\n  }\n  \n  return client.resumeSession(sessionId);\n}\n```\n\n## dynamische Sitzungen Azure\n\nFür Serverlose/Containerbereitstellungen, bei denen Container neu gestartet oder migriert werden können:\n\n### Persistenten Speicher einbinden\n\nDas Sitzungsstatusverzeichnis muss an beständigen Speicher bereitgestellt werden:\n\n```yaml\n# Azure Container Instance example\ncontainers:\n  - name: copilot-agent\n    image: my-agent:latest\n    volumeMounts:\n      - name: session-storage\n        mountPath: /home/app/.copilot/session-state\n\nvolumes:\n  - name: session-storage\n    azureFile:\n      shareName: copilot-sessions\n      storageAccountName: myaccount\n```\n\n![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-session-persistence-diagram-5.png)\n\n**Die Sitzung bleibt auch nach Container-Neustarts erhalten!**\n\n## Fortlaufende Sitzungen für langandauernde Workflows\n\nAktivieren Sie für Workflows, die Kontextbeschränkungen überschreiten könnten, dauerhafte Sitzungen mit automatischer Datenkomprimierung.\n\n```typescript\nconst session = await client.createSession({\n  sessionId: \"long-workflow-123\",\n  infiniteSessions: {\n    enabled: true,\n    backgroundCompactionThreshold: 0.80,  // Start compaction at 80% context\n    bufferExhaustionThreshold: 0.95,      // Block at 95% if needed\n  },\n});\n```\n\n> \\[!NOTE]\n> Schwellenwerte sind Kontextauslastungsverhältnisse (0,0-1,0), keine absolute Tokenanzahl. Weitere Einzelheiten finden Sie unter [SDK- und CLI-Kompatibilität](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/troubleshooting/compatibility).\n\n## Einschränkungen und Überlegungen\n\n| Einschränkung                                    | Description                                                     | Abschwächung                                                                        |\n| ------------------------------------------------ | --------------------------------------------------------------- | ----------------------------------------------------------------------------------- |\n| **BYOK-Erneute Authentifizierung**               | API-Schlüssel werden nicht beibehalten                          | Speichern von Schlüsseln in Ihrem Secret Manager; Bereitstellung bei Wiederaufnahme |\n| **Schreibbarer Speicher**                        |                                                                 |                                                                                     |\n| `~/.copilot/session-state/` muss schreibbar sein | Bereitstellen persistenter Volumes in Containern                |                                                                                     |\n| **Keine Sitzungssperre**                         | Gleichzeitiger Zugriff auf dieselbe Sitzung ist nicht definiert | Implementieren der Sperrung oder Warteschlange auf Anwendungsebene                  |\n| **Der Toolstatus wurde nicht beibehalten.**      | Der Status des In-Memory-Tools geht verloren.                   | Entwerfen von Tools, die zustandslos sind oder ihren eigenen Status beibehalten     |\n\n### Verwaltung gleichzeitigen Zugriffs\n\nDas SDK bietet keine integrierte Sitzungssperre. Wenn mehrere Clients möglicherweise auf dieselbe Sitzung zugreifen:\n\n```typescript\n// Option 1: Application-level locking with Redis\nimport Redis from \"ioredis\";\n\nconst redis = new Redis();\n\nasync function withSessionLock<T>(\n  sessionId: string,\n  fn: () => Promise<T>\n): Promise<T> {\n  const lockKey = `session-lock:${sessionId}`;\n  const acquired = await redis.set(lockKey, \"locked\", \"NX\", \"EX\", 300);\n  \n  if (!acquired) {\n    throw new Error(\"Session is in use by another client\");\n  }\n  \n  try {\n    return await fn();\n  } finally {\n    await redis.del(lockKey);\n  }\n}\n\n// Usage\nawait withSessionLock(\"user-123-task-456\", async () => {\n  const session = await client.resumeSession(\"user-123-task-456\");\n  await session.sendAndWait({ prompt: \"Continue the task\" });\n});\n```\n\n## Zusammenfassung\n\n| Funktion                                                                                                                           | Verwendung                                    |\n| ---------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |\n| **Reaktivierbare Sitzung erstellen**                                                                                               | Bereitstellung eines eigenen `sessionId`      |\n| **Sitzung fortsetzen**                                                                                                             | `client.resumeSession(sessionId)`             |\n| **BYOK fortsetzen**                                                                                                                | Konfiguration erneut bereitstellen `provider` |\n| **Sitzungen auflisten**                                                                                                            | `client.listSessions(filter?)`                |\n| **Verbindung mit der aktiven Sitzung trennen**                                                                                     |                                               |\n| `session.disconnect()`— gibt Speicherressourcen frei; Sitzungsdaten auf dem Datenträger werden für die Wiederaufnahme beibehalten. |                                               |\n| **Sitzung dauerhaft löschen**                                                                                                      |                                               |\n| `client.deleteSession(sessionId)`— entfernt dauerhaft alle Sitzungsdaten vom Datenträger; Kann nicht fortgesetzt werden            |                                               |\n| **Containerisierte Bereitstellung**                                                                                                |                                               |\n| `~/.copilot/session-state/` in persistenten Storage mounten                                                                        |                                               |\n\n## Nächste Schritte\n\n* [Sitzungshaken](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/hooks/hooks-overview) – Anpassen des Sitzungsverhaltens mit Hooks\n* [SDK- und CLI-Kompatibilität](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/troubleshooting/compatibility) – SDK- und CLI-Featurevergleich\n* [Debughandbuch](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/troubleshooting/debugging) – Beheben von Sitzungsproblemen"}