kimal3 0.4.0 → 0.5.0

package/skill/commands/k3zeigen.md

@@ -0,0 +1,303 @@
+---
+description: Eine Aufgabe vormachen statt beschreiben — ich nehme auf und mache daraus einen Plan
+---
+
+<!-- kimal3:erzeugt — diese Datei wird von `kimal3 skill install` gepflegt und bei
+     jedem Update ueberschrieben. Eigene Aenderungen gehen dabei verloren; wer sie
+     behalten will, kopiert die Datei unter einem anderen Namen. -->
+# Zeigen
+
+> Du machst eine Aufgabe einmal am Bildschirm vor und sagst dabei laut, was du tust und warum.
+> Ich nehme das auf, werte es auf deinem Rechner aus und schreibe daraus eine Beschreibung ins
+> Projekt — damit wir die Aufgabe danach automatisieren können, ohne dass du sie erst als
+> Anforderung aufschreiben musst.
+
+Führe die Schritte der Reihe nach aus. Bleib im Coaching-Ton: Deutsch, freundlich, **eine Frage
+auf einmal und immer mit Vorschlag**, das Warum vor dem Wie, null Vorwissen vorausgesetzt. Das
+Mechanische macht das Programm (`kimal3 zeigen …`), du führst das Gespräch mit dem Menschen. Wie du
+allgemein mit den Rückgabewerten von `kimal3` umgehst, steht in `~/.claude/skills/kimal3/SKILL.md`;
+hier stehen nur die Fälle dieses Befehls.
+
+## 🔴 Drei Regeln für das ganze Gespräch
+
+1. **Vor dem Ja in Schritt 10 liest du nichts aus der Aufnahme.** Kein `zeitleiste.md`, kein Bild,
+   kein Protokoll, keine andere Datei aus `material/aufnahmen/` — und du **suchst** dort auch nicht:
+   kein Grep, kein Glob, keine Dateisuche über das Projekt, die diesen Ordner einschließt. Was dort
+   liegt, verlässt den Rechner erst mit dem Ja des Menschen. Die Ausgaben von `kimal3 zeigen …`
+   darfst du lesen — sie enthalten nur Zahlen, Uhrzeiten und Ordnernamen.
+2. **Nichts installieren, nichts aufnehmen, nichts löschen ohne ein ausdrückliches Ja zu genau
+   diesem Schritt.** Eine Datei aus der Aufnahme öffnest du für den Menschen nur in Notepad, und so,
+   dass dein Aufruf sofort zurückkommt: in Bash `cmd //c start "" notepad "<pfad>"`, in PowerShell
+   `Start-Process notepad -ArgumentList '"<pfad>"'`. Ein nacktes `notepad "<pfad>"` blockiert, bis
+   das Fenster wieder zu ist. Nie in einer IDE oder einem Editor, an dem Claude Code hängt (dort
+   landen markierte Zeilen von selbst im Gespräch).
+3. **Ein Fehlschlag sieht nie aus wie ein Erfolg.** Endet ein `kimal3 zeigen …` nicht mit `0`,
+   sag ehrlich, was seine Meldung sagt, und mach nicht weiter, als hätte es geklappt.
+
+Alle `kimal3 zeigen …` laufen **im Projektordner** (Schritt 3) — das Programm findet die Aufnahme
+über den Ordner, in dem es gestartet wird. Liegt eine Aufnahme in einem anderen Projekt, wechselst
+du zuerst dorthin: Der Projektordner ist der Teil des Pfads vor `material/aufnahmen/`.
+
+## 1. Ankommen und nachsehen
+
+Führe zuerst `kimal3 zeigen status` aus. Es liest nur. Den Block „Eingerichtet:" liest du dem
+Menschen **nicht** vor — du merkst dir nur, ob darin etwas fehlt (eine Zeile mit „fehlt", „nicht
+prüfbar", „kann ich nicht feststellen" oder „(gebraucht wird …)" → Schritt 4).
+
+| Die Ausgabe sagt | Was du tust |
+|---|---|
+| `kimal3 zeigen` gibt es bisher nur unter Windows; der Mac folgt. | Sag genau das, freundlich: Vormachen geht auf diesem Rechner noch nicht, der Mac kommt. Biete an, dass der Mensch die Aufgabe stattdessen in Worten beschreibt. Hier endet der Befehl. |
+| „Ob gerade aufgenommen wird, kann ich nicht feststellen." (Rückgabewert 1) | Sag ehrlich, dass du es gerade nicht feststellen kannst. **Starte nichts.** Biete an, in einer Minute noch einmal nachzusehen. |
+| „Läuft seit 09:12 (3 Minuten), Ordner `…`, stoppt spätestens 09:27." | Eine Aufnahme aus einer früheren Sitzung läuft noch. Steht im Ordner ein voller Pfad außerhalb dieses Projekts, wechsle zuerst in dessen Projektordner. Dann frag: „Da läuft noch eine Aufnahme von 09:12 — bist du mit dem Vormachen durch? Dann stoppe ich sie jetzt." Ja → Schritt 8. |
+| „Läuft (in einer anderen Sitzung gestartet)." | Es läuft eine Aufnahme, die dieses Projekt nicht zuordnen kann. Sag das, **starte keine zweite**, und schlag vor, mit `kimal3 zeigen status` nachzusehen, sobald sie zu Ende ist. |
+| „Keine Aufnahme läuft." und darunter „Die letzte (`…`) hat nach 15 Minuten von selbst gestoppt." | Eine Aufnahme ist fertig, aber vermutlich noch nicht ausgewertet. **Starte nicht still eine neue darüber.** Frag mit Vorschlag: „Die Aufnahme von 09:12 hat nach 15 Minuten von selbst aufgehört — soll ich sie auswerten, oder machst du die Aufgabe neu vor? Ich würde sie auswerten; was du nach den 15 Minuten gemacht hast, fehlt dann." Auswerten → Schritt 9 (die Uhrzeit steht im Ordnernamen, `…-0912`). Neu → weiter hier. |
+| „Keine Aufnahme läuft." und darunter „Die letzte (`…`) ist abgebrochen." | Freundlich: Die letzte Aufnahme ist mittendrin abgebrochen — der Mensch hat nichts falsch gemacht. Biete an, die Aufgabe neu vorzumachen. |
+| „Keine Aufnahme läuft." | Weiter. |
+
+Die letzte Zeile sagt, ob der Ordner passt — merk sie dir für Schritt 3:
+„Aufnahmen landen hier in: …" (passt) · „Wechsle zuerst in ein Projekt …" (die Sitzung steht in
+der Werkbank) · „Der Projektordner liegt zu tief für den Aufnehmer …" (der Pfad ist zu lang).
+
+Steht die Sitzung in der Werkbank, sag **das zuerst**, in einem Satz: Die Aufnahme gehört in ein
+Projekt, und eins schlägst du gleich vor. Dann erklär in höchstens fünf kurzen Sätzen, was
+passiert, und stell **eine** Frage:
+
+> „Du machst mir die Aufgabe einmal vor und sprichst dabei. Ich nehme dabei Bildschirm, Ton,
+> Klicks und Tasten auf. Das bleibt auf deinem Rechner. Bevor ich etwas davon lese, frage ich
+> dich. Welche Aufgabe willst du mir zeigen — in einem Satz?"
+
+Bis der Mensch geantwortet hat, ist nichts installiert und nichts aufgenommen.
+
+## 2. Die Aufgabe in einem Satz
+
+Warte auf die Antwort. Den Satz des Menschen übernimmst du **unverändert** — er steht später im
+Kopf der Zeitleiste, und gerade dort, wo er und die Vorführung auseinandergehen, steckt die
+wichtigste Rückfrage (Schritt 11). Ein grober Satz reicht; bohr nicht nach.
+
+## 3. Der richtige Ordner
+
+- **Aufnahmen landen hier schon richtig?** Weiter mit Schritt 4.
+- **Die Sitzung steht in der Werkbank** (`werkbank-…`): Schlag ein Projekt mit einem kurzen Namen
+  aus der Aufgabe vor — Kleinbuchstaben, Bindestriche: „Ich würde dafür das Projekt
+  `projekte/angebotsliste` anlegen — passt das?" (heißt der Ordner in der Werkbank `projects/`,
+  dann dort). Erst nach dem Ja legst du **nur** `plan/` und `material/` darin an, nichts auf
+  Vorrat. Ab jetzt läuft jeder `kimal3 zeigen …` in diesem Projektordner (z. B.
+  `cd "<projektordner>" && kimal3 zeigen status`). Sieh mit `kimal3 zeigen status` nach, dass
+  die letzte Zeile jetzt „Aufnahmen landen hier in: …" sagt.
+- **Der Pfad ist zu tief:** Nenn die Zahl aus der Meldung und warum (der Aufnehmer scheitert an
+  langen Pfaden). Schlag vor, das Projekt näher am Laufwerk anzulegen, und frag, bevor du etwas
+  anlegst.
+
+## 4. Einrichten — nur wenn etwas fehlt
+
+Fehlt nichts, überspring diesen Schritt ohne ein Wort darüber. Fehlt etwas, sag **vorher genau
+das** und warte auf die Antwort:
+
+> „Dafür richte ich einmal den Aufnehmer ein — ein freies Programm, das Bildschirm, Ton, Klicks
+> und Tasten aufzeichnet. Etwa 2,1 GB, je nach Leitung 10 bis 20 Minuten, nur in deinem
+> Benutzerordner, ohne Adminrechte. Weil er Tasten mitschreibt, kann der Virenschutz deiner Firma
+> ihn melden; auf einem Firmenrechner frag im Zweifel vorher die IT. Soll ich?"
+
+- **Ja:** Starte `kimal3 zeigen einrichten` **im Hintergrund** — es kann länger dauern als die zehn
+  Minuten, die ein Befehl im Vordergrund laufen darf. Sag, dass es läuft und der Mensch solange
+  etwas anderes tun kann. **Warte auf die Meldung, dass es fertig ist** — frag nicht
+  zwischendurch nach, und schlaf nicht in einer Schleife. Danach:
+  - Rückgabewert `0` → `kimal3 zeigen status`; stehen alle vier Teile da (uv, Aufnehmer, FFmpeg,
+    Sprachmodell), weiter mit Schritt 5.
+  - Rückgabewert `1` („Schritt … hat nicht geklappt.") → nenn diesen Schritt und biete eine
+    fertige Nachricht an die IT an: **was** (uv von Astral · der Aufnehmer openadapt-capture 1.3.0,
+    Lizenz MIT, mit Python 3.12 · FFmpeg · das Sprachmodell large-v3-turbo von Hugging Face),
+    **wozu** (eine Arbeitsaufgabe einmal am Bildschirm vorführen und auf dem Rechner auswerten),
+    **woher** (astral.sh bzw. winget, pypi.org, huggingface.co), **welche Ordner** (nur der
+    Benutzerordner, ohne Adminrechte).
+- **Nein:** „Kein Problem — mit `/k3zeigen` geht es jederzeit später." Hier endet der Befehl.
+
+## 5. Die Ansage vor dem Start
+
+Sag diese vier Punkte, bevor irgendetwas aufnimmt:
+
+1. Aufgenommen werden **alle Bildschirme**. Schließ, was fremde Daten zeigt, schalte „Nicht
+   stören" ein, und nicht während eines Anrufs. Wenn es geht, nimm einen **Testkunden** statt
+   eines echten.
+2. **Tippe kein Passwort** — jede Taste wird mitgeschrieben.
+3. Sprich laut, **warum** du etwas tust.
+4. Wenn du fertig bist, komm hierher zurück und schreib **„fertig"**; spätestens nach 15 Minuten
+   stoppt die Aufnahme von selbst.
+
+Dann: „Schreib ‚los‘, wenn alles bereit ist." — und warte.
+
+- **Ein klares Startsignal** — „los", „bereit", „kann losgehen", „start" — → Schritt 6.
+- **Ein bloßes „ok" oder „ja"** → frag einmal: „Soll ich jetzt starten?"
+- **Etwas anderes** → antworte und sag, dass es mit „los" losgeht.
+
+**Vor dem Startsignal startet nichts.**
+
+## 6. Starten
+
+Nach dem Startsignal: `kimal3 zeigen start '<Satz des Menschen>'`. Übergib den Satz als **ein**
+Argument, so dass die Shell nichts daran ändert — in Bash in einfachen Anführungszeichen (ein `'`
+darin als `'\''`), in PowerShell in einfachen Anführungszeichen (ein `'` darin verdoppelt).
+`--hoechstens` (1 bis 15 Minuten) nur, wenn der Mensch ausdrücklich kürzer will.
+
+| Die Ausgabe sagt | Was du tust |
+|---|---|
+| „Die Aufnahme läuft (Ordner …), stoppt spätestens um …" (Rückgabewert 0) | Sag genau: „Läuft. Mach vor — und schreib hier ‚fertig‘, wenn du durch bist." **Dann beende deinen Zug** — kein weiterer Befehl, kein Nachsehen. |
+| „Es läuft schon eine Aufnahme (seit 09:12, Ordner `…`)." · „Gerade startet schon eine Aufnahme …" | Es entsteht keine zweite. Frag: „Da läuft noch eine Aufnahme von 09:12 — soll ich sie stoppen, damit wir neu anfangen?" Ja → `kimal3 zeigen stopp` (Schritt 8), danach zurück zu Schritt 5. |
+| „Es läuft schon eine Aufnahme (in einer anderen Sitzung gestartet)." | Frag: „Da läuft noch eine Aufnahme aus einer anderen Sitzung — soll ich sie stoppen, damit wir neu anfangen?" Ja → `kimal3 zeigen stopp`; sagt es, dass es sie hier nicht zuordnen kann, sag das ehrlich und schlag vor, zu warten, bis sie von selbst aufhört (`kimal3 zeigen status`). |
+| „Ob gerade aufgenommen wird, kann ich nicht feststellen — deshalb starte ich keine zweite." | Ehrlich sagen, nichts erzwingen, später noch einmal nachsehen. |
+| „Der Aufnehmer ist noch nicht eingerichtet: `kimal3 zeigen einrichten`." | Zurück zu Schritt 4. |
+| „Die Aufnahme ist nicht gestartet: <Grund>. Protokoll: …" | Nenn den Grund. **Öffne das Protokoll nicht** — darin stehen Fenstertitel. Folgt „Ob der Aufnehmer noch läuft, sagt `kimal3 zeigen status`.", führ `kimal3 zeigen status` aus und sag, was es meldet. Biete einen neuen Versuch an. |
+| „Wechsle zuerst in ein Projekt …" · „Der Projektordner liegt zu tief …" | Zurück zu Schritt 3. |
+
+## 7. Während der Aufnahme
+
+Schreibt der Mensch etwas anderes als „fertig" (eine Frage, einen Gedanken), antworte kurz und
+schließ mit: „Die Aufnahme läuft noch — schreib ‚fertig‘, wenn du durch bist." Öffne dabei nichts
+auf dem Bildschirm (es landete im Video) und stoppe die Aufnahme nicht von dir aus.
+„fertig", „bin durch", „done" und Ähnliches → Schritt 8.
+
+## 8. Stoppen
+
+Sag zuerst: „Ich schließe die Aufnahme ab — das kann eine Minute dauern, bei einer langen Aufnahme
+auch mehrere." Während des Abschließens sieht der Mensch sonst nichts passieren.
+
+Dann `kimal3 zeigen stopp` — mit der **längsten Wartezeit, die das Werkzeug erlaubt (10 Minuten)**: Der
+Aufnehmer schließt dabei das Video ab, und bei einer langen Aufnahme dauert das; mit der
+Voreinstellung von 2 Minuten bräche der Aufruf mittendrin ab. Das Programm antwortet spätestens nach
+gut 8 Minuten, also bevor die 10 Minuten um sind.
+
+| Die Ausgabe sagt | Was du tust |
+|---|---|
+| „Aufnahme gestoppt: 1:33 Minuten, 30 Klicks, 49 Tasten, Ton ist da." | Die Zahlen in einem Satz wiederholen, weiter mit Schritt 9. |
+| „Die Aufnahme wird noch abgeschlossen — gleich noch einmal `kimal3 zeigen stopp`." (Rückgabewert 1) | Sag: „Der Aufnehmer schließt die Aufnahme noch ab — ich frag gleich noch einmal nach." Dann `kimal3 zeigen stopp` noch einmal, wieder mit 10 Minuten Wartezeit. **Nie** „nicht sauber" und keine neue Aufnahme anbieten. |
+| „Die Aufnahme hat nach 15 Minuten von selbst gestoppt: …" (Rückgabewert 0) | Sag: „Die Aufnahme hat nach 15 Minuten von selbst aufgehört — was du danach gemacht hast, ist nicht drin." Weiter mit Schritt 9. |
+| „Es läuft keine Aufnahme." | Sieh mit `kimal3 zeigen status` nach. Steht dort „Die letzte (`…`) hat nach … Minuten von selbst gestoppt.", geht es mit Schritt 9 weiter; sonst sag ehrlich, dass keine Aufnahme da ist. |
+| „Ob gerade aufgenommen wird, kann ich nicht feststellen." | Ehrlich sagen — **nie** „gestoppt". Biete an, in einer Minute mit `kimal3 zeigen status` noch einmal nachzusehen. |
+| „Die Aufnahme ist nicht sauber abgeschlossen: <Grund>." (Rückgabewert 1) | Nenn den Grund und biete eine neue Aufnahme an. |
+| „Die Aufnahme ist abgebrochen: <Grund>. …" (Rückgabewert 1) | Freundlich: Der Mensch hat nichts falsch gemacht. Nenn den Grund und biete eine neue Aufnahme an. |
+| „Die Aufnahme ließ sich nicht stoppen …" · „Es läuft eine Aufnahme, die ich hier nicht zuordnen kann …" | `kimal3 zeigen status` ausführen und ehrlich sagen, was es meldet — **nie** „gestoppt". Läuft die Sitzung im falschen Ordner, wechsle in das Projekt der Aufnahme. |
+
+## 9. Auswerten — auf dem Rechner des Menschen
+
+`kimal3 zeigen auswerten` (ohne Ordner nimmt es die jüngste Aufnahme des Projekts; die Sprache
+der Erkennung folgt dem Konto — `--sprache en` oder `--sprache de` nur, wenn der Mensch in der
+anderen Sprache gesprochen hat). Das dauert etwa so lange wie die Aufnahme:
+
+- **Aufnahme bis etwa 3 Minuten:** im Vordergrund, mit der längsten Wartezeit (10 Minuten).
+- **Länger — und immer, wenn sie nach 15 Minuten von selbst aufgehört hat:** **im Hintergrund**,
+  wie beim Einrichten. Sag, dass es etwa so lange dauert wie die Aufnahme, und **warte auf die
+  Meldung, dass es fertig ist** — kein Nachfragen zwischendurch, keine Schleife.
+
+| Die Ausgabe sagt | Was du tust |
+|---|---|
+| „Zeitleiste fertig: … Datei: `…`." | Die Zahlen in einem Satz sagen. Den Pfad merken — **die Datei nicht öffnen**. Weiter mit Schritt 10. |
+| „Ich habe keine Sprache erkannt — war das Mikrofon stumm oder das falsche gewählt?" | Genau das fragen und eine neue Aufnahme anbieten. |
+| „Die Aufnahme hat keine Tonspur — ohne Ton entsteht keine Zeitleiste. Eine neue Aufnahme hilft." | Eine neue Aufnahme anbieten. |
+| „In diesem Projekt finde ich keine Aufnahme (`material/aufnahmen/`)." | Die Sitzung steht nicht im Projekt der Aufnahme: Wechsle dorthin (der Teil des Pfads vor `material/aufnahmen/`, aus `kimal3 zeigen status` oder der Stopp-Meldung) und werte noch einmal aus. |
+| „Den Aufnahmeordner gibt es nicht: …" | Sag ehrlich, dass die Aufnahme dort nicht (mehr) liegt. Mit `kimal3 zeigen status` nachsehen; sonst eine neue Aufnahme anbieten. |
+| „Der Aufnehmer ist noch nicht eingerichtet: `kimal3 zeigen einrichten`." | Zurück zu Schritt 4, danach noch einmal auswerten. |
+| „Die Zeitleiste ist nicht entstanden: <Grund>." | Nenn den Grund; fehlt das Sprachmodell, zurück zu Schritt 4. |
+| „Die Aufnahme läuft noch — erst `kimal3 zeigen stopp`." | Zurück zu Schritt 8. |
+
+## 10. Datenschutz — bevor du liest
+
+Zuerst eine Frage, und warte auf die Antwort:
+
+> „Waren in der Vorführung echte Daten von Menschen zu sehen — Kundennamen, Mailadressen?"
+
+**Ja:** Dann gehen die vier Fragen aus `kontext/sicherheit.md` (im Arbeitsplatz über der Werkbank)
+**jetzt**, vor dem Lesen — einzeln, jede mit Vorschlag: welche Felder · wohin (an Anthropic, die
+Firma hinter Claude, Rechenzentren in den USA) · auf welcher Grundlage · geht es sparsamer, z. B.
+noch einmal mit Testkunden. Die Antworten schreibst du nach `ergebnisse/datenschutz-vorfuehrung.md`.
+Ist die Antwort „noch einmal mit Testkunden", lies nichts, schlag vor, diese Aufnahme zu löschen
+(Schritt 13, Satz **ohne** Plan), und fang bei Schritt 5 neu an.
+
+Dann diese Frage, wörtlich:
+
+> „Damit ich die Zeitleiste lesen kann, geht sie an Anthropic: was du gesagt hast, wohin du
+> geklickt hast (mit den Namen der Knöpfe und Felder, darin können Namen stehen) und was du
+> getippt hast. Bildschirmfotos zeigen deinen ganzen Bildschirm — die schaue ich mir nur an, wo
+> der Text nicht reicht, und frage dich vor jedem einzeln. Soll ich die Datei für dich öffnen,
+> damit du vorher hineinsehen kannst? Einverstanden — oder lieber ohne die getippten Stellen?"
+
+- **„Öffnen":** in Notepad, wie in Regel 2 (`cmd //c start "" notepad "<voller pfad>"` bzw.
+  `Start-Process`), mit dem vollen Pfad zur `zeitleiste.md` (Projektordner plus der Pfad aus
+  Schritt 9). Der Mensch liest selbst; du liest nicht mit. Danach dieselbe Frage nach dem
+  Einverständnis noch einmal.
+- **„Ohne die getippten Stellen":** `kimal3 zeigen auswerten --ohne-getipptes` — mit demselben
+  `--sprache` wie beim ersten Mal, falls du eins gesetzt hattest, und mit derselben Wartezeit-Regel
+  wie in Schritt 9. Die Zeitleiste wird neu geschrieben, Getipptes steht dann als
+  „[getippt, ausgelassen]". Der Mensch hat damit dieser Fassung zugestimmt → Schritt 11.
+- **Einverstanden:** → Schritt 11.
+- **Nein:** Lies nichts. Sag: „Du kannst die Datei selbst lesen und mir die Aufgabe beschreiben —
+  oder ich lösche die Aufnahme."
+  - **Beschreibt der Mensch selbst:** Nimm seine Beschreibung, frag wie in Schritt 11, Punkt 4,
+    nach (eine Frage auf einmal), und weiter mit Schritt 12 — Plan und Bauweg **aus der
+    Beschreibung**, ohne etwas aus der Aufnahme zu lesen. Danach Schritt 13.
+  - **Löschen:** Schritt 13, Satz **ohne** Plan.
+
+## 11. Lesen, zurückerzählen, nachfragen
+
+Jetzt — und erst jetzt — liest du `zeitleiste.md`, und nur diese Datei.
+
+1. **Erzähl die Aufgabe zurück:** in nummerierten Schritten, in den **Worten des Menschen** (zitier,
+   was gesagt wurde), je Schritt mit dem Zeitpunkt aus der Zeitleiste (`0:26`).
+2. **Such die Widersprüche, ausdrücklich.** Drei Quellen sagen etwas über die Aufgabe: der
+   Aufgabensatz im Kopf der Zeitleiste, was der Mensch **sagt**, und was er **anklickt und tippt**.
+   Geh den Aufgabensatz Teil für Teil durch (was, wohin, an wen, wann) und frag bei jedem Teil:
+   Zeigt die Vorführung genau das? Dann jeden gesprochenen Satz gegen den Klick daneben. Jede
+   Stelle, an der zwei Quellen auseinandergehen, nennst du im Zurückerzählen mit ⚠️ — zum Beispiel:
+   „Du hast auf ‚morgen‘ geklickt, aber gesagt ‚für den aktuellen Tag‘ — was gilt?" oder „Im
+   Aufgabensatz steht ‚in einen Channel‘, vorgemacht hast du eine Direktnachricht — was gilt?"
+   *Genau diese Stellen sind der Grund, warum Vormachen mehr verrät als Beschreiben.*
+3. **Bildschirmfotos nur einzeln und nur gefragt.** Reicht der Text an einer Stelle nicht (ein
+   Klick ohne Namen, ein Satz, der auf etwas Sichtbares zeigt), frag vorher: „Bei 0:26 sagt der
+   Text nur ‚…‘. Darf ich mir den Bildschirm an der Stelle ansehen?" Ja → `kimal3 zeigen bild 0:26`;
+   es meldet „Bild: <pfad>", und du siehst dir **nur dieses eine** Bild an. Nein → frag, was dort
+   zu sehen war.
+4. **Dann fragen — eine Frage auf einmal, immer mit Vorschlag:** zuerst die Widersprüche, einer
+   nach dem anderen. Danach, was eine einzige Vorführung nie zeigen kann: **wie oft und wann**
+   („Ich vermute jeden Montag früh — stimmt das?") · **was bei einer Ausnahme passiert**
+   (Feiertag, leere Liste, das System ist nicht erreichbar) · **an wen das Ergebnis geht**.
+
+## 12. In den Plan schreiben und einen Bauweg vorschlagen
+
+Schreib `plan/aufgabe-vorgefuehrt.md` mit diesen Teilen:
+
+- **Ziel** in einem Satz
+- **Die Schritte**, nummeriert
+- **Regeln und Ausnahmen** aus den Antworten
+- **Was offen ist**
+- **Woher es stammt:** Vorführung vom <Datum> (oder: Beschreibung vom <Datum>, wenn nichts gelesen
+  wurde)
+
+Der Plan trägt den Inhalt **selbst** und verweist nicht auf Dateien in der Aufnahme — die soll
+gleich weg. Getipptes, das nach Zugangsdaten aussieht, kommt nicht hinein.
+
+Dann sag, wie du es **bauen würdest**: über die Schnittstellen der Programme (die Daten direkt
+holen, die Nachricht direkt schicken), **nicht** durch Nachklicken der Klicks — so bricht es
+nicht, wenn sich eine Oberfläche ändert. Gebaut wird nicht hier; das ist der nächste Schritt im
+Projekt, gern gleich oder in der nächsten Sitzung mit `/k3start`.
+
+## 13. Die Aufnahme löschen — nur nach Ja
+
+Miss die Größe des Aufnahmeordners und schlag vor, mit den echten Werten. Steht die Aufgabe im
+Plan (Schritt 12):
+
+> „Die Aufnahme ist 12,9 MB groß und liegt in `material/aufnahmen/2026-10-19-0912`. Ich würde sie
+> löschen — die Beschreibung steht im Plan, und in der Aufnahme steckt alles, was du getippt hast.
+> Was ich davon gelesen habe, steht noch im Gesprächsverlauf auf diesem Rechner. Passt das?"
+
+Kommt der Vorschlag ohne Plan (Nein in Schritt 10, oder „noch einmal mit Testkunden"), lass den
+Satz über den Plan weg:
+
+> „Die Aufnahme ist 12,9 MB groß und liegt in `material/aufnahmen/2026-10-19-0912`. Ich würde sie
+> löschen — in der Aufnahme steckt alles, was du getippt hast. Was ich davon gelesen habe, steht noch
+> im Gesprächsverlauf auf diesem Rechner. Passt das?"
+
+- **Ja:** Lösch **genau diesen einen** Ordner — nicht `material/aufnahmen/` als Ganzes, nicht die
+  `.gitignore` und `.ignore` daneben — und sieh nach, dass er weg ist.
+- **Nein:** Er bleibt liegen. Sag, wo, und dass er nicht in Git landet.
+
+Zum Schluss in zwei Sätzen ohne Fachjargon, was jetzt im Projekt steht, und **ein** konkreter
+nächster Schritt.

package/skill/en/SKILL.md

@@ -13,7 +13,7 @@ description: Add projects to the kimal3 success profile or list them, analyse co
 As soon as the person says a project is finished, or explicitly asks for it to be added.
 **Or** when they want to set up their AI Workplace — then see “Setting up the workplace”.
 
-## The eight slash commands the person has
+## The nine slash commands the person has
 
 `kimal3 skill install` puts them in the global folder (`~/.claude/commands/`) — so the person can
 type them in **any** folder. They are the route the person triggers themselves; this skill is the
@@ -29,6 +29,7 @@ route you recognise.
 | `/k3list` (German: `/k3liste`) | Show the projects they have added |
 | `/k3analyse` | Fetch company data and answer their question about it |
 | `/k3context` (German: `/k3kontext`) | Answer the open questions about their company in conversation |
+| `/k3show` (German: `/k3zeigen`) | Show a task instead of describing it — records with `kimal3 show …`, evaluates on the computer and writes the plan; nothing is read before their yes |
 
 `/k3`, `/k3start` and `/k3analyse` have the same name in German. Colleagues whose account is set to German have the German names — if someone says they ran `/k3feierabend`, that is `/k3wrapup`.
 
@@ -39,7 +40,7 @@ of pointing to a command.
 
 ⚠️ **`/k3start`, `/k3wrapup` and `/k3course` came ONLY with the course folder up to 0.2.4** — Pro
 customers without the Mini course never had them, and they could not be updated at all. Since 0.2.5
-the program delivers all eight. *If you meet someone on an older version, a missing command there
+the program delivers all of them. *If you meet someone on an older version, a missing command there
 is not an error but the old state.*
 
 ## 🔴 Several companies: YOU DO NOT CHOOSE

package/skill/en/commands/k3.md

@@ -84,17 +84,18 @@ Show the list in two groups:
 | `/k3project <what you built>` (German: `/k3projekt`) | Add a finished project to the success profile |
 | `/k3list` (German: `/k3liste`) | Show the projects you have added |
 | `/k3analyse <your question>` | Fetch company data and answer your question about it |
+| `/k3show` (German: `/k3zeigen`) | Show a task instead of describing it — I record it and turn it into a plan |
 
 Also tell them: the slash commands are the **safe** route — you don't have to remember any sentence.
 It works without them too: “the project is finished” is enough, and then I use the skill.
 
-## 6. The ninth entry in the menu: `/kimal3` is NOT a command
+## 6. The tenth entry in the menu: `/kimal3` is NOT a command
 
 The same `/` list also shows **`/kimal3`**. Explain the difference **without being asked** — the
 menu throws two different kinds into one list, and that is exactly what tripped up the first
 person who saw the family (Dennis, 19 August 2026):
 
-- The eight **`/k3…`** are **slash commands** (files in `~/.claude/commands/`) — **the person**
+- The nine **`/k3…`** are **slash commands** (files in `~/.claude/commands/`) — **the person**
   types them on purpose.
 - **`/kimal3`** is the **skill** (`~/.claude/skills/kimal3/SKILL.md`) — my
   operating manual. It is the reason “the project is finished” is enough: I open it
@@ -102,5 +103,5 @@ person who saw the family (Dennis, 19 August 2026):
   names several things at once and doesn't read like a menu item.
 
 Also say what `/kimal3` is **not**: **not the installation.** That is `kimal3 skill install`
-in the terminal — the one command that puts both in place, the skill **and** the eight `/k3…`.
+in the terminal — the one command that puts both in place, the skill **and** the nine `/k3…`.
 What appears in the menu is its result.

package/skill/en/commands/k3course.md

@@ -1,41 +1,41 @@
----
-description: Back into the Mini course — pick up where you left off
----
-
-<!-- kimal3:erzeugt — this file is maintained by `kimal3 skill install` and
-     overwritten on every update. Your own changes will be lost; if you want
-     to keep them, copy the file under a different name. -->
-# Course
-
-> Back into the Mini course: “Where was I again?” — picks up where you left off.
-> `kimal3 course` fetches the status fresh from kimal3 — the same ticks the person sees in the browser at
-> https://app.kimal3.de/kurs.
-
-Carry out the steps in order. Stay in the coaching tone: English, friendly, one step at a
-time, the why before the how, no prior knowledge assumed.
-
-## 1. Fetch the status
-- Run `kimal3 course` (on Windows the way `SKILL.md` describes).
-- Exit code **2**: the person is not signed in. Show them `kimal3 login`, let them confirm in the browser themselves
-  and name **no** course status.
-- Exit code **3**: the status can't be fetched right now. Say so in one sentence and **do not retell the course from
-  memory**.
-- If the program doesn't know the command, it is too old: name `npm install -g kimal3@latest`, then `kimal3 skill install`.
-
-## 2. Say where you stand in one sentence
-- Say in **one** sentence where you are in the course — from the output (the `Course:` line), invent nothing. No lecture.
-
-## 3. Lead on with what comes next
-- The line `Next:` names the next step. Lead on **one** step at a time: show, let them do it, make sure they understand.
-  Never the whole list at once.
-- If it says **“(you tick it off)”** after it and the person has obviously already done the step (for example “closed
-  Claude completely and reopened it” — they are sitting in Claude right now), don't lead it again: ask briefly and
-  ask them to tick it off at https://app.kimal3.de/kurs.
-- If it says **“(Claude sets it)”** and it is open, run the setup once more — through the guide
-  `https://app.kimal3.de/setup` (load it the way the course sentence does and follow it), **not** with a freely called
-  `kimal3 setup`. If the step is still open afterwards, name the reason from the output of `setup` and don't suggest
-  a third run.
-
-## 4. Finished
-- If the output says `Course: complete`, congratulate them briefly and ask, with a suggestion, what they would like to
-  work on here. No more course talk.
+---
+description: Back into the Mini course — pick up where you left off
+---
+
+<!-- kimal3:erzeugt — this file is maintained by `kimal3 skill install` and
+     overwritten on every update. Your own changes will be lost; if you want
+     to keep them, copy the file under a different name. -->
+# Course
+
+> Back into the Mini course: “Where was I again?” — picks up where you left off.
+> `kimal3 course` fetches the status fresh from kimal3 — the same ticks the person sees in the browser at
+> https://app.kimal3.de/kurs.
+
+Carry out the steps in order. Stay in the coaching tone: English, friendly, one step at a
+time, the why before the how, no prior knowledge assumed.
+
+## 1. Fetch the status
+- Run `kimal3 course` (on Windows the way `SKILL.md` describes).
+- Exit code **2**: the person is not signed in. Show them `kimal3 login`, let them confirm in the browser themselves
+  and name **no** course status.
+- Exit code **3**: the status can't be fetched right now. Say so in one sentence and **do not retell the course from
+  memory**.
+- If the program doesn't know the command, it is too old: name `npm install -g kimal3@latest`, then `kimal3 skill install`.
+
+## 2. Say where you stand in one sentence
+- Say in **one** sentence where you are in the course — from the output (the `Course:` line), invent nothing. No lecture.
+
+## 3. Lead on with what comes next
+- The line `Next:` names the next step. Lead on **one** step at a time: show, let them do it, make sure they understand.
+  Never the whole list at once.
+- If it says **“(you tick it off)”** after it and the person has obviously already done the step (for example “closed
+  Claude completely and reopened it” — they are sitting in Claude right now), don't lead it again: ask briefly and
+  ask them to tick it off at https://app.kimal3.de/kurs.
+- If it says **“(Claude sets it)”** and it is open, run the setup once more — through the guide
+  `https://app.kimal3.de/setup` (load it the way the course sentence does and follow it), **not** with a freely called
+  `kimal3 setup`. If the step is still open afterwards, name the reason from the output of `setup` and don't suggest
+  a third run.
+
+## 4. Finished
+- If the output says `Course: complete`, congratulate them briefly and ask, with a suggestion, what they would like to
+  work on here. No more course talk.