feat(ui): Home-Ordner als Sitzungsziel in Mission Control

Erster Eintrag im Sitzungsmenue, fuer schnelle allgemeine Fragen, die zu keinem Projekt gehoeren.
feat(ui): Einfuegen und Datei-Drop im interaktiven Terminal
2026-09-07 08:17:37 +02:00 · 2026-09-07 08:17:37 +02:00 · 2026-09-07 08:17:37 +02:00 · 2026-09-07 08:17:37 +02:00 · 2026-09-03 08:20:49 +00:00 · 2026-09-03 10:20:35 +02:00
52 changed files with 1177 additions and 245 deletions
@@ -1,5 +1,63 @@
 # Changelog

+## v2.13.5 — 2026-09-03
+
+### Fixes
+
+- Version im About-Dialog aus der FileVersion lesen (cccfe2ec)
+
+### Refactoring
+
+- "Nach Updates suchen" ins Hilfe-Menue verschieben (c16c7b97)
+
+### Documentation
+
+- update for v2.13.4 (a8ec5507)
+
+## v2.13.4 — 2026-09-03
+
+### Fixes
+
+- interaktive Session ohne Arbeitsverzeichnis im User-Verzeichnis starten (f70503d0)
+
+### Documentation
+
+- update for v2.13.3 (9360cd2f)
+
+## v2.13.3 — 2026-09-03
+
+### Fixes
+
+- raise SignalR MaximumParallelInvocationsPerClient (e64d5705)
+
+### Documentation
+
+- update for v2.13.2 (fc25ee45)
+
+## v2.13.2 — 2026-09-03
+
+### Features
+
+- Handler-Run per Knopf abbrechen (bd5aa265)
+
+### Fixes
+
+- strip CLAUDE_CODE_CHILD_SESSION/CLAUDECODE before every ConPTY launch (51ee5050)
+- Dequeue-X auf blockierten Queue-Zeilen anzeigen und Kette konsistent halten (df3e7ba0)
+- report and gate ListSettingsModal load failures instead of swallowing them (a1b20d9f)
+- move ScrollViewer padding to inner content in modal bodies (e0c6b670)
+- Mission Control oeffnen, wenn ein Handler-Run per MCP startet oder ein Handoff eintrifft (b05b6fba)
+
+### Performance
+
+- show list settings modal before its seven-round-trip load finishes (f24654df)
+
+### Documentation
+
+- remove stale session-skills empty-state entry (2bd48ea1)
+- update for v2.13.1 (eb3aee41)
+- update for v2.13.0 (2b873322)
+
 ## v2.13.1 — 2026-09-02

 ### Fixes
@@ -121,7 +121,7 @@ per call and `Register` clamps to min 1, so 0 can never mean "unbounded"). Past
 `wait`/`merge` request is silently coerced to its `_final` counterpart — check the result's
 `coerced` flag — and any handoff after a `merge_final` round throws.

-**PowerUse.** When `AppSettingsEntity.PowerUseEnabled` (toggled on the usage monitor) **and** the
+**PowerUse.** When `AppSettingsEntity.PowerUseEnabled` (Settings → Execution) **and** the
 list's own `ListConfigEntity.PowerUseAllowed` are both set, `InteractiveLaunchSpecService.
 ComposeHandlerPromptAsync` appends `PromptKind.PowerUseAddendum` to whichever handler prompt the
 phase resolved to. The addendum is written as an *override* of the base prompt's interactive rules
@@ -254,6 +254,7 @@ degrades instead of throwing. Worker config: `usage_poll_interval_active_seconds
 `usage_poll_interval_idle_seconds`.

 The gate percentages are editable in **two** places that both write the same `app_settings` row:
-Settings → General (typed) and the usage-monitor gauges (dragged). The throttle stages are
+Settings → Execution (typed) and the usage-monitor gauges (dragged). The throttle stages are
 gauge-only — `SettingsModalViewModel` therefore carries them load→save verbatim so saving Settings
-can't reset a dragged value.
+can't reset a dragged value. PowerUse (switch, time window, handoff %) used to be usage-monitor-only
+and is now typed on the same Settings tab, so it needs no such round-trip.
@@ -39,10 +39,10 @@ Beyond the basics it carries:
 | `ReportExcludedPaths` | `report_excluded_paths` | null | JSON array of excluded path prefixes. |
 | `StandupWeekday` | `standup_weekday` | Wednesday | int `DayOfWeek`. |
 | `NextTaskNumber` | `next_task_number` | 1 | Persistent counter for `TaskEntity.Number` allocation. Incremented atomically in `TaskNumberAllocator.AddWithNumberAsync` on every task insert. **Monotonic only:** the counter itself advances across all tasks (no per-list numbering), and it never resets. A deleted task leaves a gap. |
-| `PowerUseEnabled` | `power_use_enabled` | false | PowerUse master switch, toggled on the **usage monitor** (not Settings). ⚠️ Never sufficient alone — a handler run is in PowerUse only when `list_config.power_use_allowed` is also set. |
+| `PowerUseEnabled` | `power_use_enabled` | false | PowerUse master switch, toggled in **Settings → Execution**. ⚠️ Never sufficient alone — a handler run is in PowerUse only when `list_config.power_use_allowed` is also set. |
 | `ListHandlerMaxHandoffs` | `list_handler_max_handoffs` | 4 | Cap on a list-handler run's wait↔merge handoff chain (`HandoffRoundTracker`). 4 = two merge rounds. Independent of PowerUse — applies to interactive runs too. Clamped to min 1 in `WorkerHub.UpdateAppSettings` and again in `Register`, because 0 would remove the only bound on a runaway chain. |
 | `PowerUseWindowStart` / `PowerUseWindowEnd` | `power_use_window_*` | null | Optional local-time window (`HH:mm`) narrowing when PowerUse applies. Both null (or only one set) = round the clock, i.e. byte-identical to the pre-window behaviour; end before start wraps over midnight. Semantics live in the pure `PowerUseWindow`; checked in `InteractiveLaunchSpecService.ComposeHandlerPromptAsync` **per phase** at prompt-build time, so a chain handing off past the end time drops the addendum from there on. Unparseable input is stored as null, not rejected. |
-| `PowerUseHandoffPct` | `power_use_handoff_pct` | 95 | 5h-usage percentage at which a PowerUse handler session should hand off. Clamped 50..99. Stored + shown on the usage monitor; the consumer is the handoff prompt. |
+| `PowerUseHandoffPct` | `power_use_handoff_pct` | 95 | 5h-usage percentage at which a PowerUse handler session should hand off. Clamped 50..99. Typed in Settings → Execution; the consumer is the handoff prompt. |

 All four usage percentages are clamped 0..100 by `AppSettingsRepository.UpdateAsync`.
 Gate/throttle semantics → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md).
@@ -62,8 +62,7 @@ public sealed class AppSettingsEntity
    public bool AutoContinueOnUsageLimit { get; set; }

    // Master switch for PowerUse: list-handler runs go unattended (never ask the user) and harvest
-    // new work when a round would otherwise starve. Toggled from the usage monitor, because it is a
-    // deliberate "spend the remaining window" decision rather than a normal default. Off by default,
+    // new work when a round would otherwise starve. Toggled in Settings → Execution. Off by default,
    // and on its own it changes nothing — a run is only in PowerUse when the LIST also opted in via
    // ListConfigEntity.PowerUseAllowed, so leaving this on cannot make an unrelated list's handler
    // run unattended. Composition lives in InteractiveLaunchSpecService.
@@ -37,13 +37,12 @@ public record AppSettingsDto(
    int UsageThrottleSevenDaySoftPct = 50,
    int UsageThrottleSevenDayHardPct = 65,
    bool AutoContinueOnUsageLimit = false,
-    // PowerUse master switch — toggled on the usage monitor, not typed in Settings. Only takes
-    // effect for a list that also set PowerUseAllowed.
+    // PowerUse master switch — Settings → Execution. Only takes effect for a list that also set
+    // PowerUseAllowed.
    bool PowerUseEnabled = false,
    int ListHandlerMaxHandoffs = 4,
    // PowerUse time window (`HH:mm`, local, null = round the clock) + the 5h-usage percentage at
-    // which a PowerUse handler session should hand off. Also usage-monitor-owned, so Settings has
-    // to round-trip them too.
+    // which a PowerUse handler session should hand off. Same Settings tab.
    string? PowerUseWindowStart = null,
    string? PowerUseWindowEnd = null,
    int PowerUseHandoffPct = 95);
@@ -43,6 +43,13 @@
      "autoContinueOnUsageLimitHint": "Ist ein Run am Nutzungslimit abgebrochen, wird er nach Ablauf des 5-Stunden-Fensters automatisch fortgesetzt. Weckt außerdem die pausierte Queue genau zum Reset-Zeitpunkt statt erst beim nächsten Backstop-Check.",
      "listHandlerMaxHandoffs": "Handoff-Budget des List-Handlers",
      "listHandlerMaxHandoffsHint": "Wie viele Wait/Merge-Handoffs ein „Let Claude handle it\"-Run verketten darf. 4 entspricht zwei Merge-Runden. Für Läufe, die stundenlang durchlaufen sollen, höher setzen; der Wert begrenzt eine entlaufene Kette und darf daher nicht 0 sein.",
+      "powerUseHeading": "PowerUse",
+      "powerUse": "PowerUse aktivieren",
+      "powerUseHint": "Das restliche Fenster ausnutzen: ein List-Handler-Run fragt nichts, löst Konflikte selbst, sammelt neue Arbeit und handoffet weiter, solange sein Budget reicht. Wirkt nur auf Listen, die PowerUse in ihren Listen-Einstellungen erlaubt haben.",
+      "powerUseWindow": "Nur zwischen",
+      "powerUseWindowPlaceholder": "HH:mm",
+      "powerUseHandoffPct": "Übergabe bei (% von 5h)",
+      "powerUseWindowHint": "Beide Zeiten leer = rund um die Uhr. Das Fenster wird bei jedem Start einer Handler-Phase geprüft — eine Kette, die über das Ende hinausläuft, macht ohne PowerUse weiter.",
      "throttleStagesHeading": "Throttle-Stufen",
      "throttleStagesHint": "Die Parallelität wird vor dem harten Gate begrenzt: soft auf 2 Slots, hard auf 1. Eingestellt wird das durch Ziehen der Marker an den Gauges im Usage-Monitor. Der Monitor schließt diese Einstellungen — vorher speichern, wenn du etwas geändert hast.",
      "throttleStagesValues": "5h: soft {0}% / hard {1}%  ·  7d: soft {2}% / hard {3}%",
@@ -332,6 +339,7 @@
    "failed": "Fehlgeschlagen",
    "roadblock": "Blockade gemeldet",
    "openSession": "Sitzung öffnen",
+    "homeFolder": "Home (Schnellsitzung)",
    "browseForFolder": "Ordner wählen…",
    "focusMode": "Fokus",
    "overviewMode": "Übersicht",
@@ -407,7 +415,7 @@
      "findingsTracked": "Findings-Ordner .claudedo einchecken",
      "findingsTrackedHint": "Aus: der Ordner bleibt über .git/info/exclude aus git heraus. An: Findings reisen mit dem Repo.",
      "powerUseAllowed": "PowerUse für diese Liste erlauben",
-      "powerUseAllowedHint": "Erlaubt einem List-Handler-Run auf dieser Liste, unbeaufsichtigt zu laufen, sobald PowerUse im Usage-Monitor eingeschaltet ist: er fragt nichts, löst Konflikte selbst und sammelt neue Arbeit. Beide Schalter sind nötig — ein global aktives PowerUse ändert an einer Liste ohne Opt-in also nichts.",
+      "powerUseAllowedHint": "Erlaubt einem List-Handler-Run auf dieser Liste, unbeaufsichtigt zu laufen, sobald PowerUse in Einstellungen → Ausführung eingeschaltet ist: er fragt nichts, löst Konflikte selbst und sammelt neue Arbeit. Beide Schalter sind nötig — ein global aktives PowerUse ändert an einer Liste ohne Opt-in also nichts.",
      "sectionIcon": "ICON",
      "icon": "Listen-Icon",
      "iconHint": "Wird in der Seitenleiste neben dem Listennamen angezeigt.",
@@ -510,18 +518,18 @@
      "regenerate": "Neu erstellen",
      "emptyStateHint": "Noch kein Bericht für diesen Zeitraum. Klicke auf „Erstellen“."
    },
+    "cheatSheets": {
+      "title": "CHEAT SHEETS",
+      "windowTitle": "Cheat Sheets",
+      "pin": "Anpinnen",
+      "pinTooltip": "Fenster über den anderen halten",
+      "missing": "Cheat Sheet {0} nicht gefunden."
+    },
    "usageMonitor": {
      "title": "USAGE MONITOR",
      "windowTitle": "Usage Monitor",
      "noGauges": "Noch keine Nutzungslimits gemeldet.",
-      "powerUse": "PowerUse",
-      "powerUseHint": "Das restliche Fenster ausnutzen: ein List-Handler-Run fragt nichts, löst Konflikte selbst, sammelt neue Arbeit und handoffet weiter, solange sein Budget reicht. Wirkt nur auf Listen, die PowerUse in ihren Listen-Einstellungen erlaubt haben.",
-      "powerUseWindow": "Nur zwischen",
-      "powerUseWindowPlaceholder": "HH:mm",
-      "powerUseHandoffPct": "Übergabe bei (% von 5h)",
-      "powerUseWindowHint": "Beide Zeiten leer = rund um die Uhr. Das Fenster wird bei jedem Start einer Handler-Phase geprüft — eine Kette, die über das Ende hinausläuft, macht ohne PowerUse weiter.",
-      "refresh": "Jetzt aktualisieren",
-      "refreshHint": "Abruf alle 5 Min., während ein Task läuft, sonst alle 15 Min.",
+      "refreshHint": "Jetzt aktualisieren — Abruf alle 5 Min., während ein Task läuft, sonst alle 15 Min.",
      "staleFormat": "Werte veraltet (Stand {0})",
      "staleGateHint": "Das Gate greift in diesem Zustand nicht.",
      "gateBlockedFormat": "Warteschlange pausiert — {0}",
@@ -710,6 +718,9 @@
    "abort": "Merge abbrechen"
  },
  "controls": {
+    "markdown": {
+      "copy": "Befehl kopieren"
+    },
    "datePicker": {
      "today": "Heute",
      "tomorrow": "Morgen",
@@ -729,6 +740,13 @@
      "worktrees": "Worktrees…",
      "weeklyReport": "Wochenbericht…",
      "usageMonitor": "Usage Monitor…",
+      "cheatSheets": "Cheat Sheets",
+      "cheatSheetGit": "Git…",
+      "cheatSheetCommits": "Conventional Commits…",
+      "cheatSheetClaude": "Claude CLI…",
+      "cheatSheetClaudeConfig": "Claude-Konfiguration…",
+      "cheatSheetDotnet": "dotnet CLI…",
+      "cheatSheetPowershell": "PowerShell…",
      "about": "Über…",
      "addRepos": "Repos als Listen hinzufügen…"
    },
@@ -765,7 +783,6 @@
      "loadFailed": "Nutzungsdaten konnten nicht geladen werden: {0}",
      "refreshFailed": "Nutzung konnte nicht aktualisiert werden: {0}",
      "thresholdSaveFailed": "Grenze konnte nicht gespeichert werden: {0}",
-      "powerUseSaveFailed": "PowerUse-Schalter konnte nicht gespeichert werden: {0}",
      "installStarted": "TokenTracker wird installiert — der Fortschritt läuft in der Log-Leiste.",
      "installFailed": "TokenTracker konnte nicht installiert werden: {0}",
      "analyticsRefreshFailed": "Die Auswertung konnte nicht aktualisiert werden: {0}",
@@ -43,6 +43,13 @@
      "autoContinueOnUsageLimitHint": "When a run stops because it hit the usage limit, automatically continue it once the 5-hour window resets. Also wakes the paused queue exactly at reset time instead of waiting for the next backstop check.",
      "listHandlerMaxHandoffs": "List-handler handoff budget",
      "listHandlerMaxHandoffsHint": "How many wait/merge handoffs one \"Let Claude handle it\" run may chain. 4 means two merge rounds. Raise it for runs meant to keep going for hours; it bounds a runaway chain, so it cannot be 0.",
+      "powerUseHeading": "PowerUse",
+      "powerUse": "Enable PowerUse",
+      "powerUseHint": "Spend the rest of the window: a list-handler run asks nothing, resolves conflicts itself, harvests new work, and keeps handing off for as long as its budget allows. Only affects lists that allowed PowerUse in their list settings.",
+      "powerUseWindow": "Only between",
+      "powerUseWindowPlaceholder": "HH:mm",
+      "powerUseHandoffPct": "Hand off at (% of 5h)",
+      "powerUseWindowHint": "Leave both times empty for round the clock. A window is checked whenever a handler phase starts, so a chain that runs past the end time continues without PowerUse.",
      "throttleStagesHeading": "Throttle stages",
      "throttleStagesHint": "Parallelism is capped before the hard gate: soft caps at 2 slots, hard at 1. Edited by dragging the markers on the usage-monitor gauges. Opening the monitor closes these settings — save first if you changed anything.",
      "throttleStagesValues": "5h: soft {0}% / hard {1}%  ·  7d: soft {2}% / hard {3}%",
@@ -332,6 +339,7 @@
    "failed": "Failed",
    "roadblock": "Roadblock reported",
    "openSession": "Open session",
+    "homeFolder": "Home (quick session)",
    "browseForFolder": "Choose folder…",
    "focusMode": "Focus",
    "overviewMode": "Overview",
@@ -407,7 +415,7 @@
      "findingsTracked": "Commit the .claudedo findings folder",
      "findingsTrackedHint": "Off: the folder stays out of git via .git/info/exclude. On: findings travel with the repo.",
      "powerUseAllowed": "Allow PowerUse for this list",
-      "powerUseAllowedHint": "Lets a list-handler run on this list go unattended when PowerUse is switched on in the usage monitor: it asks nothing, resolves conflicts itself, and harvests new work. Both switches are needed, so leaving PowerUse on globally never changes a list that hasn't opted in.",
+      "powerUseAllowedHint": "Lets a list-handler run on this list go unattended when PowerUse is switched on in Settings → Execution: it asks nothing, resolves conflicts itself, and harvests new work. Both switches are needed, so leaving PowerUse on globally never changes a list that hasn't opted in.",
      "sectionIcon": "ICON",
      "icon": "List icon",
      "iconHint": "Shown next to the list name in the sidebar.",
@@ -510,18 +518,18 @@
      "regenerate": "Regenerate",
      "emptyStateHint": "No report for this range yet. Click “Generate”."
    },
+    "cheatSheets": {
+      "title": "CHEAT SHEETS",
+      "windowTitle": "Cheat Sheets",
+      "pin": "Pin",
+      "pinTooltip": "Keep this window on top of the others",
+      "missing": "Cheat sheet {0} not found."
+    },
    "usageMonitor": {
      "title": "USAGE MONITOR",
      "windowTitle": "Usage Monitor",
      "noGauges": "No usage limits reported yet.",
-      "powerUse": "PowerUse",
-      "powerUseHint": "Spend the rest of the window: a list-handler run asks nothing, resolves conflicts itself, harvests new work, and keeps handing off for as long as its budget allows. Only affects lists that allowed PowerUse in their list settings.",
-      "powerUseWindow": "Only between",
-      "powerUseWindowPlaceholder": "HH:mm",
-      "powerUseHandoffPct": "Hand off at (% of 5h)",
-      "powerUseWindowHint": "Leave both times empty for round the clock. A window is checked whenever a handler phase starts, so a chain that runs past the end time continues without PowerUse.",
-      "refresh": "Refresh now",
-      "refreshHint": "Polled every 5 min while a task runs, otherwise every 15 min.",
+      "refreshHint": "Refresh now — polled every 5 min while a task runs, otherwise every 15 min.",
      "staleFormat": "Values stale (as of {0})",
      "staleGateHint": "The gate does not apply while values are stale.",
      "gateBlockedFormat": "Queue paused — {0}",
@@ -710,6 +718,9 @@
    "abort": "Abort merge"
  },
  "controls": {
+    "markdown": {
+      "copy": "Copy command"
+    },
    "datePicker": {
      "today": "Today",
      "tomorrow": "Tomorrow",
@@ -729,6 +740,13 @@
      "worktrees": "Worktrees…",
      "weeklyReport": "Weekly Report…",
      "usageMonitor": "Usage Monitor…",
+      "cheatSheets": "Cheat Sheets",
+      "cheatSheetGit": "Git…",
+      "cheatSheetCommits": "Conventional Commits…",
+      "cheatSheetClaude": "Claude CLI…",
+      "cheatSheetClaudeConfig": "Claude configuration…",
+      "cheatSheetDotnet": "dotnet CLI…",
+      "cheatSheetPowershell": "PowerShell…",
      "about": "About…",
      "addRepos": "Add repos as lists…"
    },
@@ -765,7 +783,6 @@
      "loadFailed": "Couldn't load usage data: {0}",
      "refreshFailed": "Couldn't refresh usage: {0}",
      "thresholdSaveFailed": "Couldn't save the threshold: {0}",
-      "powerUseSaveFailed": "Couldn't save the PowerUse switch: {0}",
      "installStarted": "Installing TokenTracker — watch the log strip for progress.",
      "installFailed": "Couldn't install TokenTracker: {0}",
      "analyticsRefreshFailed": "Couldn't refresh the analytics: {0}",
@@ -0,0 +1,63 @@
+# Claude CLI
+
+## Session starten
+- `claude` — interaktive Session im aktuellen Verzeichnis
+- `claude "<prompt>"` — Session mit erstem Prompt starten
+- `claude -c` — letzte Session in diesem Verzeichnis fortsetzen
+- `claude -r` — Session aus einer Auswahlliste fortsetzen
+- `claude -r <session-id>` — bestimmte Session fortsetzen
+- `claude --fork-session -r <id>` — Session unter neuer ID fortsetzen
+- `claude -n "<name>"` — Anzeigename für die Session setzen
+
+## Modell und Aufwand
+- `claude --model sonnet` — Alias oder voller Name (`fable`, `opus`, `sonnet`, `claude-opus-5`)
+- `claude --effort high` — Denkaufwand: `low`, `medium`, `high`, `xhigh`, `max`
+- `claude --fallback-model sonnet` — Ausweichmodell bei Überlast (nur mit `-p`)
+
+## Nicht interaktiv
+- `claude -p "<prompt>"` — antworten und beenden
+- `claude -p --output-format json` — ein JSON-Ergebnis
+- `claude -p --output-format stream-json` — Streaming-JSON für Skripte
+- `claude -p --include-partial-messages` — Teil-Chunks mitstreamen
+- `claude -p --max-budget-usd 5` — Kostendeckel für den Lauf
+- `claude -p --json-schema '<schema>'` — strukturierte Ausgabe validieren
+
+## Berechtigungen und Tools
+- `claude --permission-mode <mode>` — `acceptEdits`, `auto`, `plan`, `manual`, `dontAsk`, `bypassPermissions`
+- `claude --allowed-tools "Bash(git *)" Edit` — nur diese Tools erlauben
+- `claude --disallowed-tools "Bash(rm *)"` — diese Tools sperren
+- `claude --tools "Bash,Edit,Read"` — Built-in-Toolset festlegen
+- `claude --add-dir <pfad>` — weiteres Arbeitsverzeichnis freigeben
+- `claude --restricted` — ohne befehlsausführende Tools und ohne lokale Settings
+
+## Kontext und Konfiguration
+- `claude --append-system-prompt "<text>"` — Systemprompt ergänzen
+- `claude --system-prompt "<text>"` — Systemprompt ersetzen
+- `claude --settings <datei|json>` — zusätzliche Settings laden
+- `claude --agents '<json>'` — eigene Subagents für diese Session
+- `claude --mcp-config <datei>` — MCP-Server aus JSON laden
+- `claude --strict-mcp-config` — nur diese MCP-Server, alle anderen ignorieren
+- `claude --safe-mode` — alle Anpassungen aus, zum Fehlersuchen
+- `claude --bare` — Minimalmodus ohne Hooks, Plugins, CLAUDE.md
+
+## Hintergrund-Sessions
+- `claude --bg "<prompt>"` — im Hintergrund starten, gibt die Kurz-ID aus
+- `claude agents` — laufende Hintergrund-Sessions auflisten
+- `claude attach <id>` — Hintergrund-Session in dieses Terminal holen
+- `claude logs <id>` — letzte Ausgabe einer Hintergrund-Session
+- `claude stop <id>` — Session stoppen, Verlauf bleibt
+- `claude rm <id>` — Session löschen
+
+## Worktree
+- `claude -w` — neuen Git-Worktree für diese Session anlegen
+- `claude -w <name>` — Worktree mit eigenem Namen
+
+## Verwaltung
+- `claude doctor` — Installation prüfen
+- `claude update` — auf neue Version aktualisieren
+- `claude mcp` — MCP-Server konfigurieren
+- `claude plugin` — Plugins verwalten
+- `claude auth` — Authentifizierung verwalten
+- `claude setup-token` — Langzeit-Token einrichten
+- `claude -d api,hooks` — Debugmodus mit Kategoriefilter
+- `claude -v` — Version ausgeben
@@ -0,0 +1,48 @@
+# Claude Konfiguration
+
+## Dateien und Orte
+- `~/.claude/settings.json` — globale Settings für alle Projekte
+- `.claude/settings.json` — Projekt-Settings, eingecheckt fürs Team
+- `.claude/settings.local.json` — persönliche Projekt-Settings, nicht eingecheckt
+- `Rangfolge: managed > local > projekt > global` — spezifischer gewinnt
+- `/config` — Settings interaktiv in der Session ansehen und ändern
+- `claude doctor` — Konfiguration auf Fehler prüfen
+
+## CLAUDE.md
+- `~/.claude/CLAUDE.md` — globale Anweisungen für alle Projekte
+- `CLAUDE.md` — im Projekt-Root, wird bei Start automatisch geladen
+- `<unterordner>/CLAUDE.md` — wird geladen, sobald dort gearbeitet wird
+- `@pfad/zur/datei.md` — Import einer weiteren Datei in eine CLAUDE.md
+- `# <notiz>` — in der Session: Notiz in die CLAUDE.md übernehmen
+- `/init` — CLAUDE.md für ein Projekt generieren lassen
+
+## Berechtigungen
+- `"permissions": { "allow": [...], "deny": [...], "ask": [...] }` — Struktur in settings.json
+- `Bash(git *)` — Bash-Befehle per Muster erlauben oder sperren
+- `Edit(src/**)` — Dateizugriff per Glob einschränken
+- `WebFetch(domain:example.com)` — Webzugriff auf eine Domain begrenzen
+- `mcp__<server>__<tool>` — Regel für ein einzelnes MCP-Tool
+- `/permissions` — Regeln in der Session ansehen und ergänzen
+
+## MCP-Server
+- `claude mcp add <name> -- <befehl>` — lokalen stdio-Server anlegen
+- `claude mcp add --transport http <name> <url>` — HTTP-Server anlegen
+- `claude mcp add --scope project <name> ...` — in `.mcp.json` fürs Team
+- `claude mcp list` — konfigurierte Server anzeigen
+- `claude mcp remove <name>` — Server entfernen
+- `/mcp` — Serverstatus in der Session, OAuth-Login
+
+## Hooks
+- `"hooks": { "PreToolUse": [...] }` — Shell-Befehle an Lifecycle-Events hängen
+- `PreToolUse / PostToolUse` — vor und nach jedem Tool-Aufruf
+- `UserPromptSubmit` — beim Absenden eines Prompts
+- `SessionStart / Stop` — bei Sessionbeginn und -ende
+- `Exit-Code 2` — blockiert die Aktion, stderr geht an Claude
+- `/hooks` — Hooks interaktiv verwalten
+
+## Erweiterungen
+- `.claude/commands/<name>.md` — eigener Slash-Command `/name`
+- `.claude/skills/<name>/SKILL.md` — Skill, wird bei passender Aufgabe geladen
+- `.claude/agents/<name>.md` — eigener Subagent-Typ
+- `~/.claude/...` — dieselben Ordner global statt pro Projekt
+- `claude plugin` — Plugins installieren und verwalten
@@ -0,0 +1,34 @@
+# Conventional Commits
+
+## Format
+- `<type>(<scope>): <beschreibung>` — Grundform, Scope optional
+- `feat(auth): add login endpoint` — Beispiel mit Scope
+- `fix: prevent crash on empty input` — Beispiel ohne Scope
+- `imperativ, klein, kein Punkt am Ende` — Stil der Beschreibung
+
+## Types
+- `feat` — neues Feature
+- `fix` — Bugfix
+- `refactor` — Umbau ohne Verhaltensänderung
+- `perf` — Performance-Verbesserung
+- `docs` — nur Dokumentation
+- `test` — Tests hinzufügen oder korrigieren
+- `style` — Formatierung, kein Code-Effekt
+- `build` — Build-System oder Dependencies
+- `ci` — CI-Konfiguration
+- `chore` — Sonstiges ohne src- oder Test-Änderung
+
+## Breaking Changes
+- `feat(api)!: remove legacy endpoint` — `!` markiert einen Breaking Change
+- `BREAKING CHANGE: <erklärung>` — alternativ als Footer im Commit-Body
+
+## Body und Footer
+- `Leerzeile nach der Betreffzeile` — dann optionaler Body mit dem Warum
+- `Refs: #123` — Footer für Ticket-Referenzen
+- `Reverts: <hash>` — Footer für Reverts
+
+## Warum das Ganze
+- `feat` — löst ein Minor-Release aus (SemVer)
+- `fix` — löst ein Patch-Release aus (SemVer)
+- `!` oder `BREAKING CHANGE` — löst ein Major-Release aus
+- `git log --oneline --grep "^feat"` — Verlauf wird filterbar
@@ -0,0 +1,49 @@
+# dotnet CLI
+
+## Projekt anlegen
+- `dotnet new list` — verfügbare Vorlagen anzeigen
+- `dotnet new console -n <name>` — Projekt aus Vorlage anlegen
+- `dotnet new sln` — Solution anlegen
+- `dotnet sln add <projekt>` — Projekt in die Solution aufnehmen
+
+## Bauen
+- `dotnet restore` — NuGet-Pakete auflösen
+- `dotnet build <projekt> -c Release` — Release bauen
+- `dotnet build --no-restore` — ohne Restore, wenn Pakete aktuell sind
+- `dotnet build -v minimal` — knappere Ausgabe
+- `dotnet clean -c Release` — Build-Ausgabe löschen
+
+## Laufen lassen
+- `dotnet run --project <projekt> -c Release` — starten
+- `dotnet run --project <projekt> -- <args>` — Argumente an die App
+- `dotnet watch --project <projekt> run` — bei Dateiänderung neu starten
+
+## Testen
+- `dotnet test <projekt> -c Release --no-build` — Tests ohne Neubau
+- `dotnet test --filter "FullyQualifiedName~<name>"` — nur passende Tests
+- `dotnet test --filter "FullyQualifiedName!~<name>"` — Tests ausschließen
+- `dotnet test --logger "console;verbosity=detailed"` — Details pro Test
+- `dotnet test --blame-hang-timeout 60s` — hängende Tests aufspüren
+
+## Pakete
+- `dotnet add <projekt> package <name>` — Paket hinzufügen
+- `dotnet add <projekt> package <name> --version 1.2.3` — feste Version
+- `dotnet remove <projekt> package <name>` — Paket entfernen
+- `dotnet list <projekt> package --outdated` — veraltete Pakete
+- `dotnet nuget locals all --clear` — NuGet-Caches leeren
+
+## EF Core Migrationen
+- `dotnet ef migrations add <name> -p <daten-projekt>` — Migration anlegen
+- `dotnet ef migrations list -p <daten-projekt>` — Migrationen anzeigen
+- `dotnet ef migrations remove -p <daten-projekt>` — letzte Migration zurücknehmen
+- `dotnet ef database update -p <daten-projekt>` — Schema anwenden
+
+## Veröffentlichen
+- `dotnet publish <projekt> -c Release -r win-x64 --self-contained` — eigenständiges Build
+- `dotnet publish <projekt> -c Release -p:PublishSingleFile=true` — eine Exe
+
+## Diagnose
+- `dotnet --info` — SDKs, Runtimes, RID
+- `dotnet --list-sdks` — installierte SDKs
+- `dotnet format <projekt>` — Formatierung anwenden
+- `dotnet build -p:TreatWarningsAsErrors=true` — Warnungen als Fehler
@@ -0,0 +1,80 @@
+# Git
+
+## Start
+- `git clone <url>` — Repository klonen
+- `git init` — neues Repository anlegen
+- `git remote add origin <url>` — Remote verbinden
+
+## Stand ansehen
+- `git status -sb` — Kurzstatus mit Branch-Zeile
+- `git diff` — nicht gestagete Änderungen
+- `git diff --staged` — gestagete Änderungen
+- `git diff main...HEAD` — alles, was dieser Branch gegenüber main bringt
+- `git diff --stat` — nur Datei- und Zeilenzähler
+- `git log --oneline --graph --decorate -20` — kompakter Verlauf
+- `git log -p -- <pfad>` — Verlauf einer Datei mit Diffs
+- `git show <commit>` — ein Commit im Detail
+
+## Branch
+- `git switch <branch>` — Branch wechseln
+- `git switch -c <name>` — Branch anlegen und wechseln
+- `git switch -` — zurück zum vorherigen Branch
+- `git branch -vv` — Branches mit Upstream und letztem Commit
+- `git branch -d <name>` — gemergten Branch löschen (`-D` erzwingt)
+
+## Committen
+- `git add <pfad>` — Änderungen stagen
+- `git add -p` — Änderungen hunk-weise stagen
+- `git commit -m "<text>"` — gestagete Änderungen committen
+- `git commit -- <pfad>` — nur diese Pfade committen
+- `git commit --amend --no-edit` — letzten Commit um die Staging-Area erweitern
+- `git commit --fixup <commit>` — Fixup für späteres Autosquash
+
+## Remote
+- `git fetch --all --prune` — alles holen, gelöschte Remote-Branches aufräumen
+- `git pull --rebase` — holen und eigene Commits obendrauf setzen
+- `git push -u origin <name>` — pushen und Upstream setzen
+- `git push --force-with-lease` — sicheres Force-Push, nie plain `--force`
+
+## Rebase und Merge
+- `git rebase main` — Branch auf aktuellen main setzen
+- `git rebase -i --autosquash main` — interaktiv aufräumen
+- `git rebase --continue` — nach gelöstem Konflikt weiter
+- `git rebase --abort` — Rebase abbrechen, Ausgangszustand zurück
+- `git merge --no-ff <branch>` — Merge-Commit erzwingen
+- `git merge --abort` — laufenden Merge abbrechen
+- `git cherry-pick <commit>` — einzelnen Commit übernehmen
+
+## Konflikte
+- `git diff --name-only --diff-filter=U` — konfliktbehaftete Dateien
+- `git checkout --ours <pfad>` — eigene Seite übernehmen
+- `git checkout --theirs <pfad>` — fremde Seite übernehmen
+- `git mergetool` — konfiguriertes Merge-Tool starten
+
+## Rückgängig
+- `git restore <pfad>` — Datei auf HEAD zurücksetzen, Änderungen weg
+- `git restore --staged <pfad>` — unstagen, Änderungen behalten
+- `git reset --soft HEAD~1` — letzten Commit auflösen, Änderungen gestaged behalten
+- `git reset --hard <commit>` — alles verwerfen, nicht rückholbar
+- `git revert <commit>` — Commit durch Gegen-Commit aufheben
+- `git reflog` — Referenzverlauf, um verlorene Commits wiederzufinden
+
+## Stash
+- `git stash push -m "<text>"` — Änderungen wegpacken
+- `git stash push -u` — inklusive unversionierter Dateien
+- `git stash list` — Stashes anzeigen
+- `git stash pop` — letzten Stash zurückholen und entfernen
+- `git stash apply <stash>` — anwenden, aber behalten
+
+## Worktrees
+- `git worktree list` — alle Worktrees
+- `git worktree add <pfad> <branch>` — Worktree für bestehenden Branch
+- `git worktree add -b <name> <pfad>` — Worktree mit neuem Branch
+- `git worktree remove <pfad>` — Worktree entfernen
+- `git worktree prune` — verwaiste Einträge aufräumen
+
+## Suchen
+- `git grep -n "<text>"` — im Arbeitsbaum suchen
+- `git log -S"<text>"` — Commits, die den Text einfügen oder entfernen
+- `git blame -L 40,60 <pfad>` — Zeilenbereich zuordnen
+- `git bisect start` — binäre Suche nach dem Fehler-Commit
@@ -0,0 +1,52 @@
+# PowerShell
+
+## Navigieren und Dateien
+- `Get-ChildItem` — Verzeichnis auflisten (`ls`, `-Force` zeigt versteckte)
+- `Set-Location <pfad>` — Verzeichnis wechseln (`cd`)
+- `New-Item -ItemType Directory <pfad>` — Ordner anlegen (`mkdir`)
+- `Copy-Item <quelle> <ziel> -Recurse` — kopieren
+- `Move-Item <quelle> <ziel>` — verschieben oder umbenennen
+- `Remove-Item <pfad> -Recurse -Force` — löschen, endgültig
+- `Test-Path <pfad>` — existiert die Datei oder der Ordner?
+
+## Ansehen und Suchen
+- `Get-Content <datei> -Tail 50` — letzte Zeilen (`-Wait` folgt wie tail -f)
+- `Select-String "<text>" <dateien> -List` — in Dateien suchen (grep)
+- `Get-ChildItem -Recurse -Filter *.log` — Dateien rekursiv finden
+- `<befehl> | Select-Object -First 10` — Ausgabe begrenzen (head)
+- `<befehl> | Where-Object Name -like "*test*"` — Ausgabe filtern
+- `<befehl> | Measure-Object` — zählen (wc)
+- `<befehl> | Out-GridView` — Ausgabe in sortierbarem Fenster
+
+## Prozesse und Dienste
+- `Get-Process | Sort-Object CPU -Descending | Select-Object -First 10` — Top-Prozesse
+- `Stop-Process -Name <name>` — Prozess beenden (`-Id <pid>` per PID)
+- `Get-Service <name>` — Dienststatus
+- `Restart-Service <name>` — Dienst neu starten (Admin nötig)
+
+## Netzwerk
+- `Test-NetConnection <host> -Port 443` — Erreichbarkeit und Port testen
+- `Get-NetTCPConnection -LocalPort <port>` — wer belegt den Port (OwningProcess = PID)
+- `Invoke-RestMethod <url>` — HTTP-Aufruf, JSON kommt als Objekt zurück
+- `Resolve-DnsName <host>` — DNS-Auflösung prüfen
+
+## Umgebung
+- `$env:PATH -split ";"` — PATH lesbar ausgeben
+- `$env:NAME = "wert"` — Variable für diese Session setzen
+- `[Environment]::SetEnvironmentVariable("NAME", "wert", "User")` — dauerhaft setzen
+- `Get-Command <name>` — wo liegt ein Befehl (which)
+- `Get-History` — bisherige Befehle dieser Session
+
+## Windows-Spezifisches
+- `explorer .` — aktuellen Ordner im Explorer öffnen
+- `Start-Process <datei>` — mit Standardprogramm öffnen
+- `Start-Process pwsh -Verb RunAs` — Terminal als Administrator
+- `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` — lokale Skripte erlauben
+- `winget search <name>` — Software im Paketmanager suchen
+- `winget install <id>` — installieren
+- `winget upgrade --all` — alles aktualisieren
+
+## Hilfe
+- `Get-Help <befehl> -Examples` — Beispiele zu einem Cmdlet
+- `Get-Member` — Eigenschaften eines Pipeline-Objekts anzeigen
+- `Get-Alias <kurzform>` — welches Cmdlet steckt hinter einem Alias
@@ -58,13 +58,25 @@ Design/         — Tokens.axaml (design tokens; merged before styles)
 | `ListSettingsModalViewModel` | Name, working dir, commit type, "manual list" flag, `VerifyCommand`, delete. Hosts the shared `AgentConfigEditorViewModel` as `Agent` (scope=List) — ⚠️ save delegates to `Agent.SaveAsync(verifyCommand)` because both land in the same `list_config` row via one `UpdateListConfig` call and would otherwise clobber each other. |
 | `WeeklyReportModalViewModel` | Range pickers default "since last standup weekday → today", cached per range. |
 | `MergeHelperSelectionModalViewModel` | "Let Claude handle it" picker → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md). |
-| `UsageMonitorModalViewModel` | Opened from the usage pill (shown **before** the data loads via `BeginLoad`); gauges are **dynamic** per `UsageSnapshotDto.Limits` row, and the 5h/7d ones carry three draggable stage markers (soft/hard/gate) via `UsageGaugeBar` + the pure `UsageThresholdDrag`, plus a colour-matched legend with a `NumericUpDown` per stage → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md). The **analytics** part (models/tasks/cost) comes from the external TokenTracker export, not from us: without the CLI the modal shows a hint card with an install button (gated on Node ≥ 20) instead of the totals header. Gauges, gate and throttle are unaffected by it. |
+| `UsageMonitorModalViewModel` | Opened from the usage pill (shown **before** the data loads via `BeginLoad`); gauges are **dynamic** per `UsageSnapshotDto.Limits` row, and the 5h/7d ones carry three draggable stage markers (soft/hard/gate) via `UsageGaugeBar` + the pure `UsageThresholdDrag`, plus a colour-matched legend with a `NumericUpDown` per stage → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md). The **analytics** part (models/tasks/cost) comes from the external TokenTracker export, not from us: without the CLI the modal shows a hint card with an install button (gated on Node ≥ 20) instead of the totals header. Gauges, gate and throttle are unaffected by it. The modal is **display + threshold drag only** — the PowerUse switch/window/handoff % it used to host moved to Settings → Execution (`GeneralSettingsTabViewModel`), and "Refresh now" is an icon in the titlebar via `ModalShell.HeaderActions` rather than a body row. |

 Self-explanatory: `RepoImportModalViewModel` (bulk-create lists from git repos; already-wired
 repos disabled), `MergeModalViewModel`, `WorktreesOverviewModalViewModel`,
 `UnfinishedPlanningModalViewModel`, `LogVisualizerViewModel` (last 30 min, all levels + a
 warn/error filter), `WorkerConnectionModalViewModel`, `AboutModalViewModel`.

+`CheatSheetsViewModel` backs the modeless `CheatSheetsWindow` (Help → Cheat Sheets): content is
+markdown under `Assets/CheatSheets/*.md` as **EmbeddedResource** (not `AvaloniaResource` —
+`AssetLoader` throws without an initialized Avalonia app, which would make the VM unconstructible
+in tests), rendered through `MarkdownView`, with a `Topmost` pin so it can sit docked beside the
+shell. A new sheet = a new `.md` file + its key in `CheatSheetsViewModel.Keys` (+ a menu entry if
+it should be directly reachable). `MarkdownView` has no table/fenced-code support, so sheets are
+bullet lists with inline code — rendered via its opt-in `CommandRows` property, which turns a
+`` `command` — description `` bullet into a mono chip + copy button + description and wraps each
+`##` section in a collapsible `Expander` (blocks are added to the open section's panel, not to the
+host). The flag is opt-in because the other three `MarkdownView` call sites (prompt-file viewer,
+weekly report, task-description preview) render prose where copy buttons would be noise.
+
 ## Diff & Conflicts

 `UnifiedDiffParser` (static) + `DiffModels.cs` shared types + `DiffViewerViewModel` (one unified
@@ -106,6 +118,9 @@ There is no null→bool converter — bind
 Modals use `TaskCompletionSource` results behind the reusable `ModalShell` control — the dialog
 sets the result on save/cancel, the caller awaits the TCS.

+`ModalShell.HeaderActions` is the titlebar slot left of maximise/close — for a window-level action
+that should stay visible without costing a body row (currently only the usage monitor's refresh).
+
 `ModalShell` also owns the window chrome for every modal: the titlebar drag goes through
 `Window.BeginMoveDrag` (so Windows snap works — drag to the top edge to maximise; the OS only
 snaps `CanResize="True"` windows, which is the opt-in), and it insets itself by the window's
@@ -36,6 +36,9 @@
  </ItemGroup>

  <ItemGroup>
+    <!-- EmbeddedResource, not AvaloniaResource: reading these needs no initialized Avalonia
+         app, so the VM stays constructible in tests. -->
+    <EmbeddedResource Include="Assets/CheatSheets/*.md" />
    <AvaloniaResource Include="Assets/Fonts/*.ttf" />
    <AvaloniaResource Include="Assets/Fonts/OFL-InterTight.txt" />
    <AvaloniaResource Include="Assets/Fonts/OFL-JetBrainsMono.txt" />
@@ -36,4 +36,7 @@ public interface IDialogService

    /// <summary>Show (or re-show + focus) the modeless Mission Control window. Lazily created; hides on close.</summary>
    void ShowMissionControl(MissionControlViewModel vm);
+
+    /// <summary>Show (or re-show + focus) the modeless cheat-sheet window for the shell's shared VM.</summary>
+    void ShowCheatSheets(CheatSheetsViewModel vm);
 }
@@ -137,6 +137,42 @@ public sealed class PtyTerminalSession : IDisposable
        }
    }

+    /// <summary>
+    /// Inserts <paramref name="text"/> at the cursor without submitting it — the drop-a-file-path
+    /// case. Same write seam as <see cref="SendLineAsync"/>, just without the Enter.
+    /// </summary>
+    public async Task<bool> SendTextAsync(string text)
+    {
+        if (_control is not { } control || !IsRunning || string.IsNullOrEmpty(text)) return false;
+        try
+        {
+            await SendRawAsync(control, text);
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Pastes the clipboard into the session. <see cref="TerminalControl"/> wires paste to the
+    /// right-click menu only, so Ctrl+V otherwise reaches the child as a raw control byte and does
+    /// nothing. Goes through the emulator's own <see cref="TerminalView.PasteAsync"/> rather than
+    /// writing the clipboard text raw, because that is what honours bracketed-paste mode — without
+    /// it a multi-line paste is read line by line and submits on the first newline.
+    /// </summary>
+    public async Task PasteAsync()
+    {
+        if (_control is not { } control || !IsRunning) return;
+        try
+        {
+            if (s_terminalViewField?.GetValue(control) is TerminalView view)
+                await view.PasteAsync();
+        }
+        catch (Exception) { /* best-effort, same as SendLineAsync */ }
+    }
+
    // Long enough that the two writes can't be read as one chunk by the child's stdin reader.
    private static readonly TimeSpan SubmitDelay = TimeSpan.FromMilliseconds(150);

@@ -136,6 +136,14 @@ public sealed partial class InteractiveTerminalViewModel : ViewModelBase, IDispo
    /// type into (or the write seam is gone).</summary>
    public Task<bool> SendLineAsync(string text) => _session.SendLineAsync(text);

+    /// <summary>Inserts text at the cursor without submitting — see
+    /// <see cref="PtyTerminalSession.SendTextAsync"/> (dropped file paths).</summary>
+    public Task<bool> SendTextAsync(string text) => _session.SendTextAsync(text);
+
+    /// <summary>Pastes the clipboard into the session (Ctrl+V) — see
+    /// <see cref="PtyTerminalSession.PasteAsync"/>.</summary>
+    public Task PasteAsync() => _session.PasteAsync();
+
    public void Kill() => _session.Kill();

    public void Dispose()
@@ -515,6 +515,19 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
        if (Dialogs is not null) await Dialogs.ShowAboutAsync(vm);
    }

+    // One shared VM so the sheets are parsed once and the window keeps its selection/pin
+    // across reopens; the window itself is single-instance in the dialog service.
+    private CheatSheetsViewModel? _cheatSheets;
+
+    [RelayCommand]
+    private void OpenCheatSheet(string? key)
+    {
+        if (Dialogs is null) return;
+        _cheatSheets ??= new CheatSheetsViewModel();
+        if (!string.IsNullOrEmpty(key)) _cheatSheets.Select(key);
+        Dialogs.ShowCheatSheets(_cheatSheets);
+    }
+
    [RelayCommand]
    private async Task OpenLogVisualizer()
    {
@@ -179,7 +179,14 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
    internal async System.Threading.Tasks.Task RefreshSessionTargetsAsync()
    {
        SessionTargets.Clear();
-        // Browse goes in first so the menu stays usable even if the list query below fails.
+        // Home + browse go in first so the menu stays usable even if the list query below fails.
+        // Home is the target for quick general questions that belong to no project.
+        var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        SessionTargets.Add(new SessionTargetViewModel
+        {
+            Label = Loc.T("missionControl.homeFolder"),
+            StartCommand = new RelayCommand(() => _ = OpenAdHocConPtySessionAsync(home)),
+        });
        SessionTargets.Add(new SessionTargetViewModel
        {
            Label = Loc.T("missionControl.browseForFolder"),
@@ -1,3 +1,5 @@
+using System;
+using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using ClaudeDo.Data;
@@ -10,8 +12,14 @@ namespace ClaudeDo.Ui.ViewModels.Modals;

 public sealed partial class AboutModalViewModel : ViewModelBase
 {
+    // MinVer sets AssemblyVersion to {Major}.0.0.0 for binding compat — Assembly.GetName().Version
+    // shows "2.0.0" no matter the release. FileVersion carries the real Major.Minor.Patch.
    public string AppVersion { get; } =
-        Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "0.0.0";
+        Version.TryParse(
+            FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion,
+            out var version)
+            ? version.ToString(3)
+            : "0.0.0";
    public string DataFolderPath { get; } = Paths.AppDataRoot();
    public string LogsFolderPath { get; } = Path.Combine(Paths.AppDataRoot(), "logs");
    public string WorkerConfigPath { get; } = Path.Combine(Paths.AppDataRoot(), "worker.config.json");
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using ClaudeDo.Ui.Localization;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+/// <summary>One cheat sheet: title from the file's leading <c># </c> heading, body is the rest.</summary>
+public sealed record CheatSheet(string Key, string Title, string Body);
+
+/// <summary>
+/// Backs the non-modal cheat-sheet window (Help → Cheat Sheets). Content lives as markdown
+/// under <c>Assets/CheatSheets/*.md</c> (embedded resources) and is rendered by the existing
+/// <c>MarkdownView</c>,
+/// so a new sheet is a new file — but the key list here stays explicit to keep the order
+/// deterministic and a missing resource visible instead of silently absent.
+/// </summary>
+public partial class CheatSheetsViewModel : ViewModelBase
+{
+    private static readonly string[] Keys =
+        ["git", "conventional-commits", "claude-cli", "claude-config", "dotnet-cli", "powershell"];
+
+    public ObservableCollection<CheatSheet> Sheets { get; } = [];
+
+    [ObservableProperty]
+    private CheatSheet? _selectedSheet;
+
+    /// <summary>Keeps the window above the shell so it can sit docked at a screen edge.</summary>
+    [ObservableProperty]
+    private bool _isPinned;
+
+    public Action? CloseAction { get; set; }
+
+    public CheatSheetsViewModel()
+    {
+        foreach (var key in Keys) Sheets.Add(Load(key));
+        SelectedSheet = Sheets.FirstOrDefault();
+    }
+
+    /// <summary>Preselects a sheet by key; unknown keys keep the current selection.</summary>
+    public void Select(string key)
+    {
+        var sheet = Sheets.FirstOrDefault(s => s.Key == key);
+        if (sheet is not null) SelectedSheet = sheet;
+    }
+
+    [RelayCommand]
+    private void Close() => CloseAction?.Invoke();
+
+    private static CheatSheet Load(string key)
+    {
+        var assembly = typeof(CheatSheetsViewModel).Assembly;
+        // Match by suffix rather than composing the logical name from RootNamespace — the
+        // prefix is a build detail, and a rename shouldn't silently blank the sheet.
+        var name = assembly.GetManifestResourceNames()
+            .FirstOrDefault(n => n.EndsWith($".CheatSheets.{key}.md", StringComparison.Ordinal));
+        var stream = name is null ? null : assembly.GetManifestResourceStream(name);
+        if (stream is null)
+            return new CheatSheet(key, key, Loc.T("modals.cheatSheets.missing", $"{key}.md"));
+
+        using var reader = new StreamReader(stream);
+        var text = reader.ReadToEnd().Replace("\r\n", "\n");
+
+        // The window shows the title in its own selector, so strip the leading heading
+        // rather than rendering it a second time inside the body.
+        var lines = new List<string>(text.Split('\n'));
+        var title = key;
+        var first = lines.FindIndex(l => !string.IsNullOrWhiteSpace(l));
+        if (first >= 0 && lines[first].StartsWith("# ", StringComparison.Ordinal))
+        {
+            title = lines[first][2..].Trim();
+            lines.RemoveRange(0, first + 1);
+        }
+        return new CheatSheet(key, title, string.Join('\n', lines).Trim());
+    }
+}
@@ -49,8 +49,8 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
    // lands; a non-zero exit keeps the task out of Done instead of silently reporting merged.
    [ObservableProperty] private string _verifyCommand = "";
    // Per-list opt-in for PowerUse. A handler run on this list only goes unattended (no questions,
-    // harvests new work, longer handoff chain) when this AND the global switch in the usage monitor
-    // are both on. Off by default — the global switch alone must never change a list's behaviour.
+    // harvests new work, longer handoff chain) when this AND the global switch in Settings →
+    // Execution are both on. Off by default — the global switch alone must never change a list's behaviour.
    [ObservableProperty] private bool _powerUseAllowed;
    // Dropdown hidden entirely when no ticket-system base URL is configured (Settings → Files tab).
    // Icon key into the UI icon library (IconKeyConverter -> "Icon.<key>" StreamGeometry).
@@ -30,6 +30,15 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
    // Cap on a list-handler run's wait<->merge handoff chain. 4 = two merge rounds (the long-standing
    // default); raise it for runs meant to keep going for hours. Bounds a runaway chain, so never 0.
    [ObservableProperty] private int _listHandlerMaxHandoffs = 4;
+    // PowerUse master switch: a handler run spends the rest of the window unattended. On its own it
+    // changes nothing — the run's LIST must also opt in (list settings → PowerUse).
+    [ObservableProperty] private bool _powerUseEnabled;
+    // Optional local-time window (HH:mm) narrowing when PowerUse applies; both blank = round the
+    // clock. Unparseable input is normalized to null on save, same as the worker does.
+    [ObservableProperty] private string? _powerUseWindowStart;
+    [ObservableProperty] private string? _powerUseWindowEnd;
+    // 5h-usage percentage at which a PowerUse handler session hands off. Clamped 50..99.
+    [ObservableProperty] private int _powerUseHandoffPct = 95;
    // Newline-separated path prefixes excluded from the weekly report.
    [ObservableProperty] private string _reportExcludedPaths = @"C:\Private";
    // 0=Sunday..6=Saturday (System.DayOfWeek); default Wednesday.
@@ -1,5 +1,6 @@
 using System.Linq;
 using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
 using ClaudeDo.Localization;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
@@ -130,14 +131,6 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
    // carried through load→save verbatim so saving Settings can never reset a dragged value.
    private (int FiveSoft, int FiveHard, int SevenSoft, int SevenHard) _throttleStages = (50, 65, 50, 65);

-    // Same deal: the PowerUse master switch is toggled on the usage monitor. Carried load→save so
-    // opening and saving Settings can't switch it off behind the user's back.
-    private bool _powerUseEnabled;
-
-    // Ditto for the PowerUse time window and handoff threshold — usage-monitor-owned, invisible
-    // here, but they must survive a Settings save.
-    private (string? Start, string? End, int HandoffPct) _powerUseWindow = (null, null, 95);
-
    public async Task LoadAsync()
    {
        IsBusy = true;
@@ -156,11 +149,10 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
                General.UsageGateSevenDayPct = dto.UsageGateSevenDayPct;
                General.AutoContinueOnUsageLimit = dto.AutoContinueOnUsageLimit;
                General.ListHandlerMaxHandoffs = dto.ListHandlerMaxHandoffs;
-                // Owned by the usage monitor, not editable here — but it MUST be round-tripped,
-                // because SaveAsync rebuilds the whole DTO positionally and would otherwise write
-                // the record default (false) back and silently switch PowerUse off.
-                _powerUseEnabled = dto.PowerUseEnabled;
-                _powerUseWindow = (dto.PowerUseWindowStart, dto.PowerUseWindowEnd, dto.PowerUseHandoffPct);
+                General.PowerUseEnabled = dto.PowerUseEnabled;
+                General.PowerUseWindowStart = dto.PowerUseWindowStart;
+                General.PowerUseWindowEnd = dto.PowerUseWindowEnd;
+                General.PowerUseHandoffPct = dto.PowerUseHandoffPct;
                _throttleStages = (
                    dto.UsageThrottleFiveHourSoftPct, dto.UsageThrottleFiveHourHardPct,
                    dto.UsageThrottleSevenDaySoftPct, dto.UsageThrottleSevenDayHardPct);
@@ -228,11 +220,13 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
                _throttleStages.SevenSoft,
                _throttleStages.SevenHard,
                General.AutoContinueOnUsageLimit,
-                _powerUseEnabled,
+                General.PowerUseEnabled,
                General.ListHandlerMaxHandoffs,
-                _powerUseWindow.Start,
-                _powerUseWindow.End,
-                _powerUseWindow.HandoffPct);
+                // The worker stores an unparseable time as null; normalize here too so the box
+                // shows what was actually saved instead of a typo that looks like a live window.
+                PowerUseWindow.Normalize(General.PowerUseWindowStart),
+                PowerUseWindow.Normalize(General.PowerUseWindowEnd),
+                Math.Clamp(General.PowerUseHandoffPct, 50, 99));
            await _worker.UpdateAppSettingsAsync(dto);
            await Prime.SaveAsync();
            await OnlineInbox.SaveAsync();
@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using ClaudeDo.Data.Models;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 using CommunityToolkit.Mvvm.ComponentModel;
@@ -101,77 +100,6 @@ public sealed partial class UsageMonitorModalViewModel : ViewModelBase
    [ObservableProperty]
    private IReadOnlyList<UsageGaugeRowViewModel> _gaugeRows = Array.Empty<UsageGaugeRowViewModel>();

-    /// <summary>
-    /// PowerUse master switch. It lives here rather than in Settings because turning it on is a
-    /// "spend the rest of the window" decision, made while looking at how much window is left.
-    /// On its own it changes nothing — a list-handler run only goes unattended when its LIST also
-    /// opted in (list settings → PowerUse), so this can stay on without affecting other lists.
-    /// </summary>
-    [ObservableProperty] private bool _powerUseEnabled;
-
-    /// <summary>Optional local-time window (<c>HH:mm</c>) narrowing when PowerUse applies. Both
-    /// blank = round the clock. Committed on focus loss / Enter, not per keystroke.</summary>
-    [ObservableProperty] private string? _powerUseWindowStart;
-    [ObservableProperty] private string? _powerUseWindowEnd;
-
-    /// <summary>5h-usage percentage at which a PowerUse handler session should hand off.</summary>
-    [ObservableProperty] private int _powerUseHandoffPct = 95;
-
-    // Set while LoadAsync writes the stored value in, so seeding the property doesn't immediately
-    // write it straight back to the worker.
-    private bool _loadingPowerUse;
-
-    partial void OnPowerUseEnabledChanged(bool value)
-    {
-        if (_loadingPowerUse) return;
-        _ = SavePowerUse();
-    }
-
-    /// Read-modify-write, same discipline as SaveStagesAsync: never clobber a field this modal
-    /// doesn't own. All four PowerUse fields go in one write, so committing one box can't drop a
-    /// value the user just typed into a sibling box.
-    [RelayCommand]
-    private async Task SavePowerUse()
-    {
-        if (_loadingPowerUse) return;
-        try
-        {
-            var settings = await _worker.GetAppSettingsAsync();
-            if (settings is null)
-            {
-                ErrorReported?.Invoke(Loc.T("vm.usageMonitor.powerUseSaveFailed", Loc.T("vm.settingsModal.workerOffline")));
-                return;
-            }
-
-            // The worker stores an unparseable time as null; normalize here too so the box shows
-            // what was actually saved instead of a typo that looks like a live window.
-            var start = PowerUseWindow.Normalize(PowerUseWindowStart);
-            var end = PowerUseWindow.Normalize(PowerUseWindowEnd);
-            var pct = Math.Clamp(PowerUseHandoffPct, 50, 99);
-
-            await _worker.UpdateAppSettingsAsync(settings with
-            {
-                PowerUseEnabled = PowerUseEnabled,
-                PowerUseWindowStart = start,
-                PowerUseWindowEnd = end,
-                PowerUseHandoffPct = pct,
-            });
-
-            _loadingPowerUse = true;
-            try
-            {
-                PowerUseWindowStart = start;
-                PowerUseWindowEnd = end;
-                PowerUseHandoffPct = pct;
-            }
-            finally { _loadingPowerUse = false; }
-        }
-        catch (Exception ex)
-        {
-            ErrorReported?.Invoke(Loc.T("vm.usageMonitor.powerUseSaveFailed", ex.Message));
-        }
-    }
-
    public bool IsStale => Snapshot?.IsStale == true;
    public string? LastError => Snapshot?.LastError;
    public bool IsGateBlocked => Snapshot?.IsGateBlocked == true;
@@ -221,20 +149,6 @@ public sealed partial class UsageMonitorModalViewModel : ViewModelBase
            _worker.UsageUpdatedEvent -= OnUsageUpdated;
            _worker.UsageUpdatedEvent += OnUsageUpdated;

-            var settings = await _worker.GetAppSettingsAsync();
-            if (settings is not null)
-            {
-                _loadingPowerUse = true;
-                try
-                {
-                    PowerUseEnabled = settings.PowerUseEnabled;
-                    PowerUseWindowStart = settings.PowerUseWindowStart;
-                    PowerUseWindowEnd = settings.PowerUseWindowEnd;
-                    PowerUseHandoffPct = settings.PowerUseHandoffPct;
-                }
-                finally { _loadingPowerUse = false; }
-            }
-
            ApplyPresetRange(SelectedPresetDays);
            await LoadUsageDataAsync();
        }
@@ -1,10 +1,14 @@
+using System;
 using System.Text.RegularExpressions;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Documents;
+using Avalonia.Input.Platform;
 using Avalonia.Layout;
 using Avalonia.Markup.Xaml;
 using Avalonia.Media;
+using Avalonia.Threading;
+using ClaudeDo.Ui.Localization;

 namespace ClaudeDo.Ui.Views.Controls;

@@ -13,12 +17,27 @@ public partial class MarkdownView : UserControl
    public static readonly StyledProperty<string?> MarkdownProperty =
        AvaloniaProperty.Register<MarkdownView, string?>(nameof(Markdown));

+    /// <summary>
+    /// Renders a bullet that starts with inline code as a command row: the command as a
+    /// monospace chip with a copy button, the rest as a description below it, and a rule under
+    /// each <c>##</c> section. Opt-in — the prompt-file viewer and the weekly report render
+    /// prose where nearly every bullet carries inline code, and copy buttons there are noise.
+    /// </summary>
+    public static readonly StyledProperty<bool> CommandRowsProperty =
+        AvaloniaProperty.Register<MarkdownView, bool>(nameof(CommandRows));
+
    public string? Markdown
    {
        get => GetValue(MarkdownProperty);
        set => SetValue(MarkdownProperty, value);
    }

+    public bool CommandRows
+    {
+        get => GetValue(CommandRowsProperty);
+        set => SetValue(CommandRowsProperty, value);
+    }
+
    private StackPanel? _host;

    public MarkdownView()
@@ -34,6 +53,8 @@ public partial class MarkdownView : UserControl
        base.OnPropertyChanged(change);
        if (change.Property == MarkdownProperty)
            Render(change.GetNewValue<string?>());
+        else if (change.Property == CommandRowsProperty)
+            Render(Markdown);
    }

    private static readonly Regex NumberedItem = new(@"^\s*(\d+)\.\s+(.*)$", RegexOptions.Compiled);
@@ -48,6 +69,9 @@ public partial class MarkdownView : UserControl
            return;

        var lines = md.Replace("\r\n", "\n").Split('\n');
+        // In CommandRows mode every "## " opens a collapsible section and blocks land inside it;
+        // otherwise this stays the host for the whole document.
+        var target = _host;
        int i = 0;
        while (i < lines.Length)
        {
@@ -56,19 +80,22 @@ public partial class MarkdownView : UserControl

            if (line.StartsWith("### "))
            {
-                _host.Children.Add(Heading(line[4..], 13));
+                target.Children.Add(Heading(line[4..], 13));
                i++;
                continue;
            }
            if (line.StartsWith("## "))
            {
-                _host.Children.Add(Heading(line[3..], 15));
+                if (CommandRows)
+                    target = OpenSection(line[3..]);
+                else
+                    target.Children.Add(Heading(line[3..], 15));
                i++;
                continue;
            }
            if (line.StartsWith("# "))
            {
-                _host.Children.Add(Heading(line[2..], 17));
+                target.Children.Add(Heading(line[2..], 17));
                i++;
                continue;
            }
@@ -77,7 +104,10 @@ public partial class MarkdownView : UserControl
            {
                while (i < lines.Length && (lines[i].StartsWith("- ") || lines[i].StartsWith("* ")))
                {
-                    _host.Children.Add(Bullet(lines[i][2..]));
+                    var item = lines[i][2..];
+                    target.Children.Add(CommandRows && TrySplitCommand(item, out var cmd, out var desc)
+                        ? CommandRow(cmd, desc)
+                        : Bullet(item));
                    i++;
                }
                continue;
@@ -89,7 +119,7 @@ public partial class MarkdownView : UserControl
                while (i < lines.Length && NumberedItem.IsMatch(lines[i]))
                {
                    var m = NumberedItem.Match(lines[i]);
-                    _host.Children.Add(Numbered(m.Groups[1].Value, m.Groups[2].Value));
+                    target.Children.Add(Numbered(m.Groups[1].Value, m.Groups[2].Value));
                    i++;
                }
                continue;
@@ -104,7 +134,7 @@ public partial class MarkdownView : UserControl
                paragraph.Append(lines[i].Trim());
                i++;
            }
-            _host.Children.Add(Paragraph(paragraph.ToString()));
+            target.Children.Add(Paragraph(paragraph.ToString()));
        }
    }

@@ -126,6 +156,120 @@ public partial class MarkdownView : UserControl
        return tb;
    }

+    /// <summary>
+    /// Adds a collapsible section for a <c>##</c> heading and returns the panel its blocks go
+    /// into. Native <see cref="Expander"/> — it carries the chevron, keyboard toggle and
+    /// animation, and the app already uses it unstyled in the worktrees overview.
+    /// </summary>
+    private StackPanel OpenSection(string title)
+    {
+        var header = new TextBlock
+        {
+            FontSize = 15,
+            FontWeight = FontWeight.SemiBold,
+            TextWrapping = TextWrapping.Wrap,
+        };
+        AppendInlines(header.Inlines!, title);
+
+        var body = new StackPanel { Spacing = 6 };
+        _host!.Children.Add(new Expander
+        {
+            Header = header,
+            Content = body,
+            IsExpanded = true,
+            HorizontalAlignment = HorizontalAlignment.Stretch,
+            HorizontalContentAlignment = HorizontalAlignment.Stretch,
+        });
+        return body;
+    }
+
+    /// <summary>
+    /// Splits <c>`command` — description</c> into its two parts. False when the bullet doesn't
+    /// open with inline code, so prose bullets keep the plain renderer.
+    /// </summary>
+    internal static bool TrySplitCommand(string text, out string command, out string description)
+    {
+        command = "";
+        description = "";
+        if (text.Length < 3 || text[0] != '`') return false;
+        var close = text.IndexOf('`', 1);
+        if (close <= 1) return false;
+        command = text[1..close];
+        description = text[(close + 1)..].TrimStart(' ', '—', '–', '-', ':').Trim();
+        return true;
+    }
+
+    private Control CommandRow(string command, string description)
+    {
+        var grid = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            Margin = new Thickness(0, 2, 0, 2),
+        };
+
+        var text = new SelectableTextBlock { Text = command, TextWrapping = TextWrapping.Wrap };
+        // Bound, not resolved: Render can run while detached, where a resource lookup finds
+        // nothing and would freeze on the fallback.
+        text.Bind(TextBlock.FontFamilyProperty, this.GetResourceObservable("MonoFont"));
+        text.Bind(TextBlock.FontSizeProperty, this.GetResourceObservable("FontSizeMono"));
+
+        var chip = new Border
+        {
+            CornerRadius = new CornerRadius(4),
+            Padding = new Thickness(7, 4),
+            HorizontalAlignment = HorizontalAlignment.Left,
+            Child = text,
+        };
+        chip.Bind(Border.BackgroundProperty, this.GetResourceObservable("Surface2Brush"));
+
+        var stack = new StackPanel { Spacing = 3, Children = { chip } };
+        if (description.Length > 0)
+        {
+            var desc = new TextBlock
+            {
+                Classes = { "body" },
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Thickness(2, 0, 0, 0),
+            };
+            AppendInlines(desc.Inlines!, description);
+            stack.Children.Add(desc);
+        }
+        Grid.SetColumn(stack, 0);
+        grid.Children.Add(stack);
+
+        var copy = CopyButton(command);
+        Grid.SetColumn(copy, 1);
+        grid.Children.Add(copy);
+        return grid;
+    }
+
+    private Button CopyButton(string command)
+    {
+        var copyIcon = new PathIcon { Width = 11, Height = 11 };
+        copyIcon.Bind(PathIcon.DataProperty, this.GetResourceObservable("Icon.Copy"));
+        var checkIcon = new PathIcon { Width = 11, Height = 11 };
+        checkIcon.Bind(PathIcon.DataProperty, this.GetResourceObservable("Icon.Check"));
+
+        var button = new Button
+        {
+            Classes = { "icon-btn" },
+            Content = copyIcon,
+            VerticalAlignment = VerticalAlignment.Top,
+            Margin = new Thickness(6, 0, 0, 0),
+        };
+        ToolTip.SetTip(button, Loc.T("controls.markdown.copy"));
+
+        button.Click += async (_, _) =>
+        {
+            if (TopLevel.GetTopLevel(this)?.Clipboard is not { } clipboard) return;
+            await clipboard.SetTextAsync(command);
+            // The clipboard gives no feedback of its own; a brief check mark is the confirmation.
+            button.Content = checkIcon;
+            DispatcherTimer.RunOnce(() => button.Content = copyIcon, TimeSpan.FromSeconds(1.5));
+        };
+        return button;
+    }
+
    private static Control Paragraph(string text)
    {
        var tb = new SelectableTextBlock { TextWrapping = TextWrapping.Wrap };
@@ -14,19 +14,21 @@
                    Background="{DynamicResource DeepBrush}"
                    BorderBrush="{DynamicResource LineBrush}"
                    BorderThickness="0,0,0,1">
-              <Grid ColumnDefinitions="*,Auto,Auto" Margin="14,0">
+              <Grid ColumnDefinitions="*,Auto,Auto,Auto" Margin="14,0">
                <TextBlock Text="{TemplateBinding Title}"
                           FontFamily="{DynamicResource MonoFont}"
                           FontSize="{DynamicResource FontSizeMono}"
                           LetterSpacing="1.4"
                           Foreground="{DynamicResource TextBrush}"
                           VerticalAlignment="Center"/>
-                <Button Name="PART_MaxButton" Grid.Column="1" Classes="icon-btn"
+                <ContentPresenter Grid.Column="1" Content="{TemplateBinding HeaderActions}"
+                                  VerticalAlignment="Center" Margin="0,0,8,0"/>
+                <Button Name="PART_MaxButton" Grid.Column="2" Classes="icon-btn"
                        IsVisible="{TemplateBinding ShowMaximizeButton}"
                        VerticalAlignment="Center">
                  <PathIcon Name="PART_MaxIcon" Data="{StaticResource Icon.WinMax}" Width="10" Height="10"/>
                </Button>
-                <Button Grid.Column="2" Classes="icon-btn" Content="✕"
+                <Button Grid.Column="3" Classes="icon-btn" Content="✕"
                        FontSize="{DynamicResource FontSizeBody}"
                        Command="{TemplateBinding CloseCommand}"
                        VerticalAlignment="Center"/>
@@ -17,6 +17,11 @@ public class ModalShell : ContentControl
    public static readonly StyledProperty<object?> FooterProperty =
        AvaloniaProperty.Register<ModalShell, object?>(nameof(Footer));

+    // Window-level actions rendered in the titlebar, left of maximise/close. Keeps a single
+    // always-visible action (e.g. the usage monitor's refresh) out of the body's vertical flow.
+    public static readonly StyledProperty<object?> HeaderActionsProperty =
+        AvaloniaProperty.Register<ModalShell, object?>(nameof(HeaderActions));
+
    public static readonly StyledProperty<ICommand?> CloseCommandProperty =
        AvaloniaProperty.Register<ModalShell, ICommand?>(nameof(CloseCommand));

@@ -27,6 +32,7 @@ public class ModalShell : ContentControl

    public string? Title { get => GetValue(TitleProperty); set => SetValue(TitleProperty, value); }
    public object? Footer { get => GetValue(FooterProperty); set => SetValue(FooterProperty, value); }
+    public object? HeaderActions { get => GetValue(HeaderActionsProperty); set => SetValue(HeaderActionsProperty, value); }
    public ICommand? CloseCommand { get => GetValue(CloseCommandProperty); set => SetValue(CloseCommandProperty, value); }
    public bool ShowMaximizeButton { get => GetValue(ShowMaximizeButtonProperty); set => SetValue(ShowMaximizeButtonProperty, value); }

@@ -4,7 +4,8 @@
             xmlns:term="using:Iciclecreek.Terminal"
             x:Class="ClaudeDo.Ui.Views.InteractiveTerminalView"
             x:DataType="vm:InteractiveTerminalViewModel"
-             x:Name="Root">
+             x:Name="Root"
+             DragDrop.AllowDrop="True">
  <!--
    Process="" suppresses TerminalView.OnLoaded's built-in auto-launch (it otherwise spawns its
    own cmd.exe/bash the moment this control loads). PtyTerminalSession sets Process/Args/
@@ -1,6 +1,10 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
 using ClaudeDo.Ui.ViewModels;

 namespace ClaudeDo.Ui.Views;
@@ -12,6 +16,12 @@ public partial class InteractiveTerminalView : UserControl
        InitializeComponent();
        TerminalHost.Loaded += OnTerminalHostLoaded;
        DataContextChanged += OnDataContextChanged;
+
+        // Tunnel: TerminalControl handles KeyDown itself and forwards Ctrl+V to the child as a raw
+        // control byte, where nothing acts on it — paste has to be intercepted before it gets there.
+        AddHandler(KeyDownEvent, OnPreviewKeyDown, RoutingStrategies.Tunnel);
+        AddHandler(DragDrop.DragOverEvent, OnDragOver);
+        AddHandler(DragDrop.DropEvent, OnDrop);
    }

    private void OnDataContextChanged(object? sender, EventArgs e)
@@ -25,4 +35,44 @@ public partial class InteractiveTerminalView : UserControl
        if (DataContext is InteractiveTerminalViewModel vm)
            vm.AttachControl(TerminalHost);
    }
+
+    private void OnPreviewKeyDown(object? sender, KeyEventArgs e)
+    {
+        if (e.Key != Key.V || !e.KeyModifiers.HasFlag(KeyModifiers.Control) || e.KeyModifiers.HasFlag(KeyModifiers.Alt))
+            return;
+        if (DataContext is not InteractiveTerminalViewModel vm) return;
+
+        e.Handled = true;
+        _ = vm.PasteAsync();
+    }
+
+    private static bool IsFilesDrop(DragEventArgs e) => e.DataTransfer?.Contains(DataFormat.File) == true;
+
+    private void OnDragOver(object? sender, DragEventArgs e)
+    {
+        e.DragEffects = IsFilesDrop(e) ? DragDropEffects.Copy : DragDropEffects.None;
+        e.Handled = true;
+    }
+
+    // Dropping files types their paths into the session's composer (no Enter) — the common case is
+    // "look at this file", not "run something".
+    private void OnDrop(object? sender, DragEventArgs e)
+    {
+        if (DataContext is not InteractiveTerminalViewModel vm || !IsFilesDrop(e)) return;
+        e.Handled = true;
+
+        var text = FormatDroppedPaths(e.DataTransfer!.TryGetFiles()?.Select(i => i.TryGetLocalPath()));
+        if (text.Length > 0) _ = vm.SendTextAsync(text);
+    }
+
+    /// <summary>Joins dropped file paths into one insertable chunk: quoted when they contain a
+    /// space, space-separated, with a trailing space so the user can keep typing.</summary>
+    internal static string FormatDroppedPaths(IEnumerable<string?>? paths)
+    {
+        var usable = (paths ?? Enumerable.Empty<string?>())
+            .Where(p => !string.IsNullOrWhiteSpace(p))
+            .Select(p => p!.Contains(' ') ? $"\"{p}\"" : p)
+            .ToList();
+        return usable.Count == 0 ? string.Empty : string.Join(" ", usable) + " ";
+    }
 }
@@ -64,8 +64,6 @@
                      Foreground="{DynamicResource TextDimBrush}">
              <MenuItem Header="{loc:Tr shell.menu.restartWorker}"
                        Command="{Binding RestartWorkerCommand}"/>
-              <MenuItem Header="{loc:Tr shell.menu.checkForUpdates}"
-                        Command="{Binding CheckForUpdatesCommand}"/>
              <MenuItem Header="{loc:Tr shell.menu.usageMonitor}"
                        Command="{Binding OpenUsageMonitorCommand}"/>
            </MenuItem>
@@ -79,7 +77,23 @@
            <MenuItem Header="{loc:Tr shell.menu.help}"
                      FontSize="{StaticResource FontSizeMono}"
                      Foreground="{DynamicResource TextDimBrush}">
+              <MenuItem Header="{loc:Tr shell.menu.checkForUpdates}"
+                        Command="{Binding CheckForUpdatesCommand}"/>
              <MenuItem Header="{loc:Tr shell.menu.weeklyReport}" Command="{Binding OpenWeeklyReportCommand}"/>
+              <MenuItem Header="{loc:Tr shell.menu.cheatSheets}">
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetGit}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="git"/>
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetCommits}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="conventional-commits"/>
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetClaude}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="claude-cli"/>
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetClaudeConfig}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="claude-config"/>
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetDotnet}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="dotnet-cli"/>
+                <MenuItem Header="{loc:Tr shell.menu.cheatSheetPowershell}"
+                          Command="{Binding OpenCheatSheetCommand}" CommandParameter="powershell"/>
+              </MenuItem>
              <MenuItem Header="{loc:Tr shell.menu.about}" Command="{Binding OpenAboutCommand}"/>
            </MenuItem>
          </Menu>
@@ -0,0 +1,45 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:vm="using:ClaudeDo.Ui.ViewModels.Modals"
+        xmlns:ctl="using:ClaudeDo.Ui.Views.Controls"
+        xmlns:loc="using:ClaudeDo.Ui.Localization"
+        x:Class="ClaudeDo.Ui.Views.Modals.CheatSheetsWindow"
+        x:DataType="vm:CheatSheetsViewModel"
+        Title="{loc:Tr modals.cheatSheets.windowTitle}"
+        Width="480" Height="820" MinWidth="320" MinHeight="300"
+        CanResize="True"
+        Topmost="{Binding IsPinned}"
+        WindowDecorations="BorderOnly"
+        ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
+        WindowStartupLocation="CenterOwner"
+        Background="{DynamicResource SurfaceBrush}">
+
+  <Window.KeyBindings>
+    <KeyBinding Gesture="Escape" Command="{Binding CloseCommand}"/>
+  </Window.KeyBindings>
+
+  <ctl:ModalShell Title="{loc:Tr modals.cheatSheets.title}" CloseCommand="{Binding CloseCommand}">
+    <DockPanel>
+      <!-- Sheet picker + pin. Pin keeps the window above the shell while it sits at a screen edge. -->
+      <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Spacing="8" Margin="16,10,16,0">
+        <ComboBox ItemsSource="{Binding Sheets}"
+                  SelectedItem="{Binding SelectedSheet}"
+                  DisplayMemberBinding="{Binding Title}"
+                  MinWidth="180"
+                  VerticalAlignment="Center"/>
+        <ToggleButton Content="{loc:Tr modals.cheatSheets.pin}"
+                      IsChecked="{Binding IsPinned}"
+                      VerticalAlignment="Center"
+                      ToolTip.Tip="{loc:Tr modals.cheatSheets.pinTooltip}"/>
+      </StackPanel>
+
+      <ScrollViewer HorizontalScrollBarVisibility="Disabled">
+        <!-- Inset on the content, not the ScrollViewer: Avalonia 12 leaves ScrollViewer.Padding
+             out of the Extent, which clips the last lines at max scroll. -->
+        <ctl:MarkdownView Markdown="{Binding SelectedSheet.Body}" CommandRows="True"
+                          Margin="16,12,16,16"/>
+      </ScrollViewer>
+    </DockPanel>
+  </ctl:ModalShell>
+</Window>
@@ -0,0 +1,10 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace ClaudeDo.Ui.Views.Modals;
+
+public partial class CheatSheetsWindow : Window
+{
+    public CheatSheetsWindow() => InitializeComponent();
+    private void InitializeComponent() => AvaloniaXamlLoader.Load(this);
+}
@@ -252,8 +252,8 @@
                <TextBlock Text="{loc:Tr settings.general.autoContinueOnUsageLimitHint}"
                           Opacity="0.6" FontSize="12" TextWrapping="Wrap"/>

-                <!-- PowerUse itself is toggled on the usage monitor; only its handoff budget is
-                     typed here, because it also applies to a normal (interactive) handler run. -->
+                <!-- Outside the PowerUse section below on purpose: the handoff budget also bounds
+                     a normal (interactive) handler run. -->
                <StackPanel Spacing="4">
                  <TextBlock Classes="eyebrow" Text="{loc:Tr settings.general.listHandlerMaxHandoffs}"/>
                  <NumericUpDown Value="{Binding General.ListHandlerMaxHandoffs, Mode=TwoWay, Converter={StaticResource KeepLastNumber}}"
@@ -264,6 +264,34 @@
                </StackPanel>
              </StackPanel>

+              <!-- PowerUse: a master switch plus its time window. Never sufficient on its own —
+                   the run's list must also allow PowerUse in its list settings. -->
+              <StackPanel Spacing="4">
+                <TextBlock Classes="field-label" Text="{loc:Tr settings.general.powerUseHeading}"/>
+                <CheckBox IsChecked="{Binding General.PowerUseEnabled, Mode=TwoWay}"
+                          Content="{loc:Tr settings.general.powerUse}"/>
+                <TextBlock Text="{loc:Tr settings.general.powerUseHint}"
+                           Opacity="0.6" FontSize="12" TextWrapping="Wrap"/>
+                <StackPanel Orientation="Horizontal" Spacing="8" Margin="0,6,0,0">
+                  <TextBlock Classes="eyebrow" VerticalAlignment="Center"
+                             Text="{loc:Tr settings.general.powerUseWindow}"/>
+                  <TextBox Width="70" FontSize="12" Padding="6,2"
+                           Watermark="{loc:Tr settings.general.powerUseWindowPlaceholder}"
+                           Text="{Binding General.PowerUseWindowStart, Mode=TwoWay}"/>
+                  <TextBlock Classes="meta" VerticalAlignment="Center" Text="–"/>
+                  <TextBox Width="70" FontSize="12" Padding="6,2"
+                           Watermark="{loc:Tr settings.general.powerUseWindowPlaceholder}"
+                           Text="{Binding General.PowerUseWindowEnd, Mode=TwoWay}"/>
+                  <TextBlock Classes="eyebrow" VerticalAlignment="Center" Margin="12,0,0,0"
+                             Text="{loc:Tr settings.general.powerUseHandoffPct}"/>
+                  <NumericUpDown Width="80" FontSize="12" Padding="6,2" ShowButtonSpinner="False"
+                                 Minimum="50" Maximum="99" Increment="1" FormatString="0"
+                                 Value="{Binding General.PowerUseHandoffPct, Mode=TwoWay, Converter={StaticResource KeepLastNumber}}"/>
+                </StackPanel>
+                <TextBlock Text="{loc:Tr settings.general.powerUseWindowHint}"
+                           Opacity="0.6" FontSize="12" TextWrapping="Wrap"/>
+              </StackPanel>
+
              <!-- Throttle stages live on the usage-monitor gauges (drag + spinner per stage);
                   echoed read-only here so they aren't invisible on the tab that owns the gate. -->
              <StackPanel Spacing="4">
@@ -19,6 +19,18 @@
  </Window.KeyBindings>

  <ctl:ModalShell Title="{loc:Tr modals.usageMonitor.title}" CloseCommand="{Binding CloseCommand}">
+    <!-- Refresh sits in the titlebar: the worker polls on a slow cadence to avoid the endpoint's
+         429s, so this is the way to get a number now — but it doesn't earn a row in the body. -->
+    <ctl:ModalShell.HeaderActions>
+      <StackPanel Orientation="Horizontal" Spacing="6">
+        <Ellipse Classes="spinner" Width="12" Height="12" VerticalAlignment="Center"
+                 IsVisible="{Binding IsRefreshing}"/>
+        <Button Classes="icon-btn" Content="⟳" FontSize="{DynamicResource FontSizeBody}"
+                Command="{Binding RefreshCommand}"
+                IsEnabled="{Binding !IsRefreshing}"
+                ToolTip.Tip="{loc:Tr modals.usageMonitor.refreshHint}"/>
+      </StackPanel>
+    </ctl:ModalShell.HeaderActions>
    <DockPanel>

      <!-- Stale / gate bands -->
@@ -47,18 +59,6 @@
        </Border>
      </StackPanel>

-      <!-- Refresh: the worker polls on a slow cadence to avoid the endpoint's 429s -->
-      <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Spacing="8"
-                  Margin="20,12,20,0" VerticalAlignment="Center">
-        <Button Classes="btn" Content="{loc:Tr modals.usageMonitor.refresh}"
-                Command="{Binding RefreshCommand}"
-                IsEnabled="{Binding !IsRefreshing}"/>
-        <Ellipse Classes="spinner" Width="14" Height="14" VerticalAlignment="Center"
-                 IsVisible="{Binding IsRefreshing}"/>
-        <TextBlock Classes="meta" VerticalAlignment="Center"
-                   Text="{loc:Tr modals.usageMonitor.refreshHint}"/>
-      </StackPanel>
-
      <!-- Gauges -->
      <ItemsControl DockPanel.Dock="Top" Margin="20,12,20,0" ItemsSource="{Binding GaugeRows}">
        <ItemsControl.ItemsPanel>
@@ -134,42 +134,6 @@
                 Text="{loc:Tr modals.usageMonitor.noGauges}"
                 IsVisible="{Binding !GaugeRows.Count}"/>

-      <!-- PowerUse: sits under the gauges on purpose — "spend the rest of the window" is a
-           decision made while looking at how much window is left. Saves immediately on toggle. -->
-      <Border DockPanel.Dock="Top" Margin="20,12,20,0" Padding="12,10"
-              Background="{DynamicResource DeepBrush}" BorderBrush="{DynamicResource LineBrush}"
-              BorderThickness="1" CornerRadius="6">
-        <StackPanel Spacing="4">
-          <CheckBox IsChecked="{Binding PowerUseEnabled, Mode=TwoWay}"
-                    Content="{loc:Tr modals.usageMonitor.powerUse}"/>
-          <TextBlock Classes="meta" TextWrapping="Wrap"
-                     Text="{loc:Tr modals.usageMonitor.powerUseHint}"/>
-          <!-- Window + handoff threshold. Same commit-on-blur/Enter discipline as the gauge
-               legend boxes: a hub write per keystroke would be one save per typed digit. -->
-          <StackPanel Orientation="Horizontal" Spacing="8" Margin="0,6,0,0">
-            <TextBlock Classes="meta" VerticalAlignment="Center"
-                       Text="{loc:Tr modals.usageMonitor.powerUseWindow}"/>
-            <TextBox Width="70" FontSize="12" Padding="6,2"
-                     Watermark="{loc:Tr modals.usageMonitor.powerUseWindowPlaceholder}"
-                     Text="{Binding PowerUseWindowStart, Mode=TwoWay}"
-                     LostFocus="OnPowerUseBoxCommit" KeyDown="OnPowerUseBoxKeyDown"/>
-            <TextBlock Classes="meta" VerticalAlignment="Center" Text="–"/>
-            <TextBox Width="70" FontSize="12" Padding="6,2"
-                     Watermark="{loc:Tr modals.usageMonitor.powerUseWindowPlaceholder}"
-                     Text="{Binding PowerUseWindowEnd, Mode=TwoWay}"
-                     LostFocus="OnPowerUseBoxCommit" KeyDown="OnPowerUseBoxKeyDown"/>
-            <TextBlock Classes="meta" VerticalAlignment="Center" Margin="12,0,0,0"
-                       Text="{loc:Tr modals.usageMonitor.powerUseHandoffPct}"/>
-            <NumericUpDown Width="80" FontSize="12" Padding="6,2" ShowButtonSpinner="False"
-                           Minimum="50" Maximum="99" Increment="1" FormatString="0"
-                           Value="{Binding PowerUseHandoffPct, Mode=TwoWay, Converter={StaticResource KeepLastNumber}}"
-                           LostFocus="OnPowerUseBoxCommit" KeyDown="OnPowerUseBoxKeyDown"/>
-          </StackPanel>
-          <TextBlock Classes="meta" TextWrapping="Wrap" Opacity="0.75"
-                     Text="{loc:Tr modals.usageMonitor.powerUseWindowHint}"/>
-        </StackPanel>
-      </Border>
-
      <!-- Period picker -->
      <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Spacing="8" Margin="20,12,20,0">
        <TextBlock Classes="meta" Text="{loc:Tr modals.usageMonitor.period}" VerticalAlignment="Center"/>
@@ -33,19 +33,4 @@ public partial class UsageMonitorModalView : Window
        OnStageBoxCommit(sender, e);
        e.Handled = true;
    }
-
-    /// <summary>Persists the PowerUse window / handoff threshold on blur — a save per keystroke
-    /// would be one hub round-trip per typed digit.</summary>
-    private void OnPowerUseBoxCommit(object? sender, RoutedEventArgs e)
-    {
-        if (DataContext is not UsageMonitorModalViewModel vm) return;
-        if (vm.SavePowerUseCommand.CanExecute(null)) vm.SavePowerUseCommand.Execute(null);
-    }
-
-    private void OnPowerUseBoxKeyDown(object? sender, KeyEventArgs e)
-    {
-        if (e.Key != Key.Enter) return;
-        OnPowerUseBoxCommit(sender, e);
-        e.Handled = true;
-    }
 }
@@ -28,6 +28,7 @@ public sealed class WindowDialogService : IDialogService
    private readonly Window _owner;
    private MissionControlWindow? _missionControl;
    private DiffViewerView? _diffViewerWindow;
+    private CheatSheetsWindow? _cheatSheets;

    public WindowDialogService(Window owner) => _owner = owner;

@@ -182,9 +183,29 @@ public sealed class WindowDialogService : IDialogService
        _missionControl ??= new MissionControlWindow { DataContext = vm };
        if (!_missionControl.IsVisible)
            _missionControl.Show();          // modeless, independent top-level window
+        // Activate() alone does not restore a minimised window — it stays in the taskbar and the
+        // button looks dead. Un-minimise first, then take focus.
+        if (_missionControl.WindowState == WindowState.Minimized)
+            _missionControl.WindowState = WindowState.Normal;
        _missionControl.Activate();          // bring to front / focus
    }

+    public void ShowCheatSheets(CheatSheetsViewModel vm)
+    {
+        // Modeless and single-instance, like Mission Control: the point is to park it beside the
+        // shell, so a second window (or a modal that blocks the shell) would defeat it.
+        if (_cheatSheets is null)
+        {
+            _cheatSheets = new CheatSheetsWindow { DataContext = vm };
+            vm.CloseAction = () => _cheatSheets?.Close();
+            _cheatSheets.Closed += (_, _) => _cheatSheets = null;
+            _cheatSheets.Show(_owner);
+        }
+        if (_cheatSheets.WindowState == WindowState.Minimized)
+            _cheatSheets.WindowState = WindowState.Normal;
+        _cheatSheets.Activate();
+    }
+
    public Task<bool> ConfirmAsync(string message)
    {
        var tcs = new TaskCompletionSource<bool>();
@@ -78,10 +78,14 @@ builder.Services.AddHostedService<AttachmentOrphanRecovery>();
 builder.Services.AddHostedService<PromptFileRecovery>();
 builder.Services.AddHostedService<LegacyWorktreeFolderRecovery>();
 builder.Services.AddHostedService<UntrackedWorktreeRecovery>();
-builder.Services.AddSignalR().AddJsonProtocol(options =>
-{
-    options.PayloadSerializerOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter());
-});
+// Default MaximumParallelInvocationsPerClient=1 serializes every hub call on one connection —
+// a slow one (e.g. GetTicketProjects hitting an unreachable ticket system) blocks unrelated
+// calls like UpdateList/UpdateListConfig behind it for the same 10s.
+builder.Services.AddSignalR(options => options.MaximumParallelInvocationsPerClient = 10)
+    .AddJsonProtocol(options =>
+    {
+        options.PayloadSerializerOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter());
+    });

 // Runner stack.
 builder.Services.AddSingleton<IClaudeProcess, ClaudeProcess>();
@@ -75,7 +75,8 @@ public sealed class InteractiveLaunchSpecService
    /// Throws KeyNotFoundException if the task doesn't exist, InvalidOperationException
    /// if it's Running/Queued. If the task has no usable worktree yet, one is created on
    /// demand (same mechanism as an autonomous run) provided the task's list has a working
-    /// directory pointing at a git repo -- otherwise throws InvalidOperationException. Resumes
+    /// directory pointing at a git repo; a non-repo directory is opened directly, and a list with
+    /// no working directory at all (manual/reminder list) opens in the user's home dir. Resumes
    /// (--resume) this task's own last interactive session (TaskEntity.InteractiveSessionId) if
    /// it has one, else the latest autonomous run's session; a task that has never run either
    /// way, or whose worktree was just created fresh, gets a fresh-start spec instead -- pre-
@@ -94,6 +95,7 @@ public sealed class InteractiveLaunchSpecService
        var isFreshWorktree = false;
        string sessionDir;
        bool sessionIsWorktree;
+        var seedSkills = true;

        if (worktree is null || worktree.State is not (WorktreeState.Active or WorktreeState.Kept))
        {
@@ -105,10 +107,17 @@ public sealed class InteractiveLaunchSpecService
            // existing shape in the codebase (a list-handler task also has no worktree and commits
            // straight to the list's working dir), so no WorktreeEntity is created here either.
            var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct);
-            if (list?.WorkingDir is null)
-                throw new InvalidOperationException("This task has no working directory configured -- can't create a worktree.");
-
-            if (await _git.IsGitRepoAsync(list.WorkingDir, ct))
+            if (list is null || string.IsNullOrEmpty(list.WorkingDir))
+            {
+                // A manual/reminder list has no repo at all -- open the session in the user's
+                // home directory instead of refusing it. Skills are deliberately NOT seeded
+                // there: the destination would be the user's REAL ~/.claude/skills, not a
+                // throwaway session copy.
+                sessionDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+                sessionIsWorktree = false;
+                seedSkills = false;
+            }
+            else if (await _git.IsGitRepoAsync(list.WorkingDir, ct))
            {
                // A stale (Merged/Discarded) row is already tracked in `ctx`'s identity map from
                // the read above -- CreateAsync replaces it via its OWN context, so re-querying on
@@ -146,9 +155,12 @@ public sealed class InteractiveLaunchSpecService
        // history the task accumulated before its previous worktree went away.
        var run = isFreshWorktree ? null : await new TaskRunRepository(ctx).GetLatestByTaskIdAsync(taskId, ct);

-        var requestedSkills = TaskRunner.UnionSkillNames(task.SessionSkills, listConfig?.SessionSkills, globalSettings.SessionSkills);
-        var skillNames = await FilterToInstalledSkillsAsync(requestedSkills, ct);
-        await _skillSeeder.SeedAsync(sessionDir, skillNames, isWorktree: sessionIsWorktree, ct);
+        if (seedSkills)
+        {
+            var requestedSkills = TaskRunner.UnionSkillNames(task.SessionSkills, listConfig?.SessionSkills, globalSettings.SessionSkills);
+            var skillNames = await FilterToInstalledSkillsAsync(requestedSkills, ct);
+            await _skillSeeder.SeedAsync(sessionDir, skillNames, isWorktree: sessionIsWorktree, ct);
+        }

        var resolvedClaude = WindowsTerminalLauncher.Resolve(_claudePath)
            ?? throw new InvalidOperationException($"claude executable not found: {_claudePath}");
@@ -595,8 +607,8 @@ public sealed class InteractiveLaunchSpecService

    // The list-handler system prompt, plus the PowerUse addendum when this run is in PowerUse.
    //
-    // PowerUse requires BOTH the global switch (AppSettingsEntity.PowerUseEnabled, toggled on the
-    // usage monitor) AND the list's own opt-in (ListConfigEntity.PowerUseAllowed). That is the whole
+    // PowerUse requires BOTH the global switch (AppSettingsEntity.PowerUseEnabled, Settings →
+    // Execution) AND the list's own opt-in (ListConfigEntity.PowerUseAllowed). That is the whole
    // point of the two-key design: the global switch can be left on overnight without turning some
    // unrelated list's handler run unattended, because a list that never opted in keeps the
    // interactive prompt unchanged.
@@ -0,0 +1,34 @@
+using System.Linq;
+using ClaudeDo.Ui.ViewModels.Modals;
+using Xunit;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+public class CheatSheetsViewModelTests
+{
+    [Fact]
+    public void LoadsEverySheetWithTitleFromHeading()
+    {
+        var vm = new CheatSheetsViewModel();
+
+        Assert.Equal(6, vm.Sheets.Count);
+        Assert.Equal(
+            ["Git", "Conventional Commits", "Claude CLI", "Claude Konfiguration", "dotnet CLI", "PowerShell"],
+            vm.Sheets.Select(s => s.Title));
+        // The heading is stripped so the window doesn't render the title twice.
+        Assert.All(vm.Sheets, s => Assert.StartsWith("## ", s.Body));
+    }
+
+    [Fact]
+    public void SelectSwitchesSheetAndIgnoresUnknownKeys()
+    {
+        var vm = new CheatSheetsViewModel();
+        Assert.Equal("git", vm.SelectedSheet!.Key);
+
+        vm.Select("dotnet-cli");
+        Assert.Equal("dotnet-cli", vm.SelectedSheet!.Key);
+
+        vm.Select("nope");
+        Assert.Equal("dotnet-cli", vm.SelectedSheet!.Key);
+    }
+}
@@ -65,6 +65,7 @@ public class ListsIslandCreateListCancelTests : IDisposable
        public Task<bool> ConfirmAsync(string message) => Task.FromResult(true);
        public Task ShowErrorAsync(string message) => Task.CompletedTask;
        public void ShowMissionControl(MissionControlViewModel vm) => throw new NotImplementedException();
+        public void ShowCheatSheets(CheatSheetsViewModel vm) => throw new NotImplementedException();
    }

    private sealed class ListSettingsProvider(Func<ListSettingsModalViewModel> create) : IServiceProvider
@@ -254,11 +254,11 @@ public class MissionControlViewModelTests : IDisposable

        await vm.RefreshSessionTargetsAsync();

-        // Browse first (survives a failing list query), then the lists in sort order.
-        Assert.Equal(3, vm.SessionTargets.Count);
-        Assert.Equal(new[] { "Beta", "Alpha" }, vm.SessionTargets.Skip(1).Select(t => t.Label).ToArray());
+        // Home + browse first (they survive a failing list query), then the lists in sort order.
+        Assert.Equal(4, vm.SessionTargets.Count);
+        Assert.Equal(new[] { "Beta", "Alpha" }, vm.SessionTargets.Skip(2).Select(t => t.Label).ToArray());

-        vm.SessionTargets[0].StartCommand.Execute(null);
+        vm.SessionTargets[1].StartCommand.Execute(null);
        Assert.True(browsed);
    }

@@ -131,6 +131,38 @@ public class SettingsModalViewModelTests : IDisposable
        Assert.Equal(77, worker.Saved.UsageGateSevenDayPct);
    }

+    [Fact]
+    public async Task PowerUse_survives_a_load_edit_save_round_trip()
+    {
+        // PowerUse moved off the usage monitor onto this tab, so Settings is now its only writer.
+        // A binding that doesn't reach General silently resets the switch to the record default.
+        var worker = new FakeWorker
+        {
+            AppToReturn = DtoWith(80, 90) with
+            {
+                PowerUseEnabled = true,
+                PowerUseWindowStart = "18:00",
+                PowerUseWindowEnd = "06:00",
+                PowerUseHandoffPct = 88,
+            },
+        };
+        var vm = MakeVm(worker);
+        await vm.LoadAsync();
+
+        Assert.True(vm.General.PowerUseEnabled);
+        Assert.Equal("18:00", vm.General.PowerUseWindowStart);
+        Assert.Equal(88, vm.General.PowerUseHandoffPct);
+
+        // A typo in the window is normalized to null on save, not stored as a fake window.
+        vm.General.PowerUseWindowEnd = "not a time";
+        await vm.SaveCommand.ExecuteAsync(null);
+
+        Assert.True(worker.Saved!.PowerUseEnabled);
+        Assert.Equal("18:00", worker.Saved.PowerUseWindowStart);
+        Assert.Null(worker.Saved.PowerUseWindowEnd);
+        Assert.Equal(88, worker.Saved.PowerUseHandoffPct);
+    }
+
    [Fact]
    public async Task HasLinkedRepo_false_when_no_list_has_a_working_dir()
    {
@@ -63,6 +63,7 @@ public class TasksIslandMoveToListTests : IDisposable
        public Task ShowLogVisualizerAsync(LogVisualizerViewModel vm) => throw new NotImplementedException();
        public Task ShowErrorAsync(string message) => Task.CompletedTask;
        public void ShowMissionControl(MissionControlViewModel vm) => throw new NotImplementedException();
+        public void ShowCheatSheets(CheatSheetsViewModel vm) => throw new NotImplementedException();
    }

    private TasksIslandViewModel BuildViewModel() => new(new TestDbFactory(NewContext), worker: null);
@@ -0,0 +1,26 @@
+using ClaudeDo.Ui.Views;
+using Xunit;
+
+namespace ClaudeDo.Ui.Tests.Views;
+
+public class InteractiveTerminalDropPathsTests
+{
+    [Fact]
+    public void Quotes_only_paths_with_spaces_and_ends_with_a_separator()
+    {
+        var text = InteractiveTerminalView.FormatDroppedPaths(
+            new[] { @"C:\repo\a.cs", @"C:\my repo\b.cs" });
+
+        Assert.Equal("C:\\repo\\a.cs \"C:\\my repo\\b.cs\" ", text);
+    }
+
+    [Fact]
+    public void Skips_items_without_a_local_path()
+    {
+        // IStorageItem.TryGetLocalPath() returns null for non-filesystem items (e.g. a virtual
+        // shell folder) — those must not turn into empty quotes in the composer.
+        Assert.Equal(@"C:\repo\a.cs ", InteractiveTerminalView.FormatDroppedPaths(new[] { null, @"C:\repo\a.cs", "  " }));
+        Assert.Equal(string.Empty, InteractiveTerminalView.FormatDroppedPaths(new string?[] { null }));
+        Assert.Equal(string.Empty, InteractiveTerminalView.FormatDroppedPaths(null));
+    }
+}
@@ -0,0 +1,32 @@
+using ClaudeDo.Ui.Views.Controls;
+using Xunit;
+
+namespace ClaudeDo.Ui.Tests.Views;
+
+/// <summary>
+/// Covers the command-row split only — rendering itself needs an Avalonia app, which this
+/// project has no host for.
+/// </summary>
+public class MarkdownCommandRowTests
+{
+    [Theory]
+    [InlineData("`git status -sb` — Kurzstatus mit Branch-Zeile", "git status -sb", "Kurzstatus mit Branch-Zeile")]
+    [InlineData("`git branch -d <name>` — löschen (`-D` erzwingt)", "git branch -d <name>", "löschen (`-D` erzwingt)")]
+    [InlineData("`dotnet build`", "dotnet build", "")]
+    public void SplitsCommandFromDescription(string line, string cmd, string desc)
+    {
+        Assert.True(MarkdownView.TrySplitCommand(line, out var actualCmd, out var actualDesc));
+        Assert.Equal(cmd, actualCmd);
+        Assert.Equal(desc, actualDesc);
+    }
+
+    [Theory]
+    [InlineData("Prosa ohne Befehl")]
+    [InlineData("Text mit `code` in der Mitte")]
+    [InlineData("`unclosed backtick")]
+    [InlineData("``")]
+    public void LeavesNonCommandBulletsToThePlainRenderer(string line)
+    {
+        Assert.False(MarkdownView.TrySplitCommand(line, out _, out _));
+    }
+}
@@ -4,9 +4,8 @@ using Xunit;

 namespace ClaudeDo.Worker.Tests.Hub;

-/// The PowerUse window and handoff threshold are edited on the usage monitor, but Settings→General
-/// rebuilds the whole DTO positionally on save. So the contract that matters is: whatever
-/// GetAppSettings hands out, feeding it straight back must change nothing.
+/// Settings rebuilds the whole AppSettings DTO positionally on save, so the contract that matters
+/// is: whatever GetAppSettings hands out, feeding it straight back must change nothing.
 public sealed class PowerUseSettingsHubTests : IDisposable
 {
    private readonly DbFixture _db = new();
@@ -72,8 +72,8 @@ public sealed class HandlerRestartCoordinatorTests : IDisposable
            });
            await ctx.SaveChangesAsync();

-            // Written straight to the row: AppSettingsRepository.UpdateAsync deliberately doesn't
-            // copy PowerUseEnabled (the usage monitor owns that toggle, not the settings modal).
+            // Written straight to the row so the fixture doesn't depend on the repository's
+            // clamping/normalizing copy block.
            await new AppSettingsRepository(ctx).GetAsync(); // materializes the singleton row
            var settings = await ctx.AppSettings.FirstAsync(s => s.Id == AppSettingsEntity.SingletonId);
            settings.PowerUseEnabled = powerUseEnabled;
@@ -68,8 +68,8 @@ public sealed class HandlerUsageGuardTests : IDisposable
            });
            await ctx.SaveChangesAsync();

-            // Written straight to the row: AppSettingsRepository.UpdateAsync deliberately doesn't
-            // copy PowerUseEnabled (the usage monitor owns that toggle, not the settings modal).
+            // Written straight to the row so the fixture doesn't depend on the repository's
+            // clamping/normalizing copy block.
            await new AppSettingsRepository(ctx).GetAsync();
            var settings = await ctx.AppSettings.FirstAsync(s => s.Id == AppSettingsEntity.SingletonId);
            settings.PowerUseEnabled = powerUseEnabled;
@@ -220,8 +220,15 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
    }

    [Fact]
-    public async Task BuildForTaskAsync_NoWorktreeRow_NoWorkingDirConfigured_ThrowsInvalidOperation()
+    public async Task BuildForTaskAsync_NoWorktreeRow_NoWorkingDirConfigured_OpensInUserHomeWithoutSeedingSkills()
    {
+        _registry.Installed.Add(new SessionSkillEntity
+        {
+            Name = "installed-skill", SourceUrl = "https://example.com/x.git",
+            PinnedRef = "abc", Subpath = "skills/installed-skill", Description = "d",
+            AddedAt = DateTimeOffset.UtcNow,
+        });
+
        var listId = await SeedListAsync();
        using (var ctx = _db.CreateContext())
        {
@@ -230,11 +237,18 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
            await ctx.SaveChangesAsync();
        }
        var taskId = Guid.NewGuid().ToString();
-        await SeedTaskAsync(taskId, listId, TaskStatus.Idle);
+        await SeedTaskAsync(taskId, listId, TaskStatus.Idle,
+            sessionSkillsJson: "[\"installed-skill\"]");

        var svc = BuildService();
-        await Assert.ThrowsAsync<InvalidOperationException>(
-            () => svc.BuildForTaskAsync(taskId, CancellationToken.None));
+        var spec = await svc.BuildForTaskAsync(taskId, CancellationToken.None);
+
+        Assert.Equal(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), spec.Cwd);
+        // Seeding here would copy into the user's REAL ~/.claude/skills.
+        Assert.Empty(_seeder.Calls);
+
+        using var readCtx = _db.CreateContext();
+        Assert.Null(await new WorktreeRepository(readCtx).GetByTaskIdAsync(taskId));
    }

    [Fact]
Author	SHA1	Message	Date
mika kuns	f231f08a27	feat(ui): Home-Ordner als Sitzungsziel in Mission Control Changelog / changelog (push) Successful in 2s Details Release / release (push) Successful in 41s Details Erster Eintrag im Sitzungsmenue, fuer schnelle allgemeine Fragen, die zu keinem Projekt gehoeren.	2026-09-07 08:17:37 +02:00
mika kuns	23491d3b49	feat(ui): Einfuegen und Datei-Drop im interaktiven Terminal Ctrl+V wurde von TerminalControl als rohes Control-Byte an das Kind weitergegeben und tat nichts; jetzt wird es im Tunnel abgefangen und geht ueber TerminalView.PasteAsync, damit Bracketed Paste greift und ein mehrzeiliger Paste nicht auf der ersten Zeile abschickt. Gedroppte Dateien werden als Pfade in den Composer getippt, ohne Enter.	2026-09-07 08:17:37 +02:00
mika kuns	0db9fadee9	feat(ui): Cheat-Sheet-Fenster im Hilfe-Menue Sechs Markdown-Sheets (git, Conventional Commits, Claude CLI, Claude-Config, dotnet CLI, PowerShell) als EmbeddedResource, gerendert im modelosen, per Topmost anpinnbaren CheatSheetsWindow. MarkdownView bekommt dafuer das Opt-in CommandRows: `befehl` - beschreibung wird zu Mono-Chip + Copy-Button, jede ##-Sektion landet in einem Expander. Enthaelt ausserdem: Mission Control wird beim Oeffnen aus dem Minimiert-Zustand geholt, nicht nur aktiviert.	2026-09-07 08:17:37 +02:00
mika kuns	7c7c33d677	feat(ui): PowerUse-Einstellungen nach Settings -> Ausfuehrung verschieben Schalter, Zeitfenster und Handoff-Prozent lagen im Usage-Monitor und mussten in SettingsModalViewModel nur load->save durchgeschleift werden, damit ein Settings-Speichern sie nicht zurueckwirft. Jetzt gehoeren sie dem General-Tab, der Monitor ist wieder nur Anzeige + Threshold-Drag, und "Jetzt aktualisieren" sitzt als Icon in der Titelleiste (neuer ModalShell.HeaderActions-Slot).	2026-09-07 08:17:37 +02:00
ClaudeDo CI	c7392e085f	docs(changelog): update for v2.13.5	2026-09-03 08:20:49 +00:00
mika kuns	c16c7b97ef	refactor(ui): "Nach Updates suchen" ins Hilfe-Menue verschieben Changelog / changelog (push) Successful in 2s Details Release / release (push) Successful in 41s Details	2026-09-03 10:20:35 +02:00
mika kuns	cccfe2eca1	fix(ui): Version im About-Dialog aus der FileVersion lesen MinVer setzt die AssemblyVersion auf {Major}.0.0.0 (Binding-Kompatibilitaet), darum zeigte der Dialog immer "2.0.0". Die echte Major.Minor.Patch steckt in der FileVersion.	2026-09-03 10:20:35 +02:00
ClaudeDo CI	a8ec550740	docs(changelog): update for v2.13.4	2026-09-03 08:18:22 +00:00
mika kuns	40d2537486	Merge remote-tracking branch 'origin/main' Changelog / changelog (push) Successful in 2s Details Release / release (push) Successful in 42s Details	2026-09-03 10:17:58 +02:00
mika kuns	f70503d038	fix(worker): interaktive Session ohne Arbeitsverzeichnis im User-Verzeichnis starten Eine manuelle Liste (Erinnerungen) hat kein WorkingDir. BuildForTaskAsync warf dafuer bisher "no working directory configured", die interaktive Session liess sich also nicht oeffnen. Jetzt faellt der Pfad auf das User-Verzeichnis zurueck; Session-Skills werden dort bewusst nicht geseedet, weil das Ziel das echte ~/.claude/skills waere.	2026-09-03 10:17:06 +02:00
ClaudeDo CI	9360cd2fe6	docs(changelog): update for v2.13.3	2026-09-03 05:48:10 +00:00
mika kuns	ee502883f8	chore(claudedo): update CHANGELOG for v2.13.3 Changelog / changelog (push) Successful in 2s Details Release / release (push) Successful in 40s Details	2026-09-03 07:47:43 +02:00
mika kuns	e64d570554	fix(worker): raise SignalR MaximumParallelInvocationsPerClient Default of 1 serializes every hub call on a connection - a slow one (GetTicketProjects hitting an unreachable ticket system, 10s timeout) blocked unrelated calls like UpdateList/UpdateListConfig behind it for the same duration, making list-settings save appear to hang.	2026-09-03 07:47:26 +02:00
ClaudeDo CI	fc25ee45d1	docs(changelog): update for v2.13.2	2026-09-03 05:23:15 +00:00