kimal3 0.4.0-durchstich.3 → 0.5.0

package/skill/SKILL.md

@@ -13,7 +13,7 @@ description: Projekte ins kimal3-Erfolgsprofil eintragen oder auflisten, Firmend
 Sobald der Mensch sagt, ein Projekt sei fertig, oder ausdrücklich bittet, es einzutragen.
 **Oder** wenn er seinen KI-Arbeitsplatz anlegen will — dann s. „Den Arbeitsplatz anlegen".
 
-## Die acht Slash-Befehle, die der Mensch hat
+## Die neun Slash-Befehle, die der Mensch hat
 
 `kimal3 skill install` legt sie global ab (`~/.claude/commands/`) — er kann sie also in
 **jedem** Ordner tippen. Sie sind der Weg, den er selbst auslöst; dieses Skill ist der Weg,
@@ -24,11 +24,12 @@ den du erkennst.
 | `/k3` | Wo er steht — und alle kimal3-Befehle auf einen Blick |
 | `/k3start` | Sitzung starten: wo das Projekt steht und was als Nächstes dran ist |
 | `/k3feierabend` | Sitzung sauber beenden: Stand sichern, aufräumen, zusammenfassen |
-| `/k3kurs` | Zurück in den Mini-Kurs — da weiter, wo er aufgehört hat |
+| `/k3kurs` | Zurück in den Mini-Kurs — holt den Stand mit `kimal3 kurs` und macht da weiter, wo er aufgehört hat |
 | `/k3projekt` | Ein fertiges Projekt ins Erfolgsprofil eintragen |
 | `/k3liste` | Seine eingetragenen Projekte zeigen |
 | `/k3analyse` | Firmendaten holen und seine Frage dazu beantworten |
 | `/k3kontext` | Die offenen Fragen über seine Firma im Gespräch beantworten |
+| `/k3zeigen` | Eine Aufgabe vormachen statt beschreiben — nimmt mit `kimal3 zeigen …` auf, wertet auf dem Rechner aus und schreibt den Plan; gelesen wird erst nach seinem Ja |
 
 🔴 **Nenne einen dieser Befehle nur, wenn du weißt, dass er ihn hat.** Sie kommen mit
 `kimal3 skill install`; wer das nie ausgeführt hat, sieht beim Tippen nichts, und ein Rat ins
@@ -37,7 +38,7 @@ einen Befehl zu zeigen.
 
 ⚠️ **`/k3start`, `/k3feierabend` und `/k3kurs` kamen bis 0.2.4 NUR im Kursordner mit** — Pro-
 Kunden ohne Mini-Kurs hatten sie nie, und aktualisieren ließen sie sich gar nicht. Seit 0.2.5
-liefert das Programm alle acht aus. *Triffst du jemanden mit einer älteren Fassung, ist ein
+liefert das Programm sie alle aus. *Triffst du jemanden mit einer älteren Fassung, ist ein
 fehlender Befehl dort kein Fehler, sondern der alte Stand.*
 
 ## 🔴 Mehrere Firmen: DU WÄHLST NICHT
@@ -158,8 +159,7 @@ gemeinsam ausfüllen — es sind vier verschiedene. Such nach eckigen Klammern,
 zu folgen: Eine abgetippte Liste veraltet in dem Moment, in dem die Vorlage wächst. Frag nach,
 statt zu raten.
 
-⚠️ `[FIRMA]` findest du meist schon ausgefüllt — den Namen setzt der Server beim Ausliefern ein.
-`[DATUM]` ebenso. Was übrig bleibt, sind die Angaben über den **Menschen** vor dir.
+⚠️ `[FIRMA]` findest du meist schon ausgefüllt — den Namen setzt der Server beim Ausliefern ein. Was übrig bleibt, sind die Angaben über den **Menschen** vor dir.
 
 🔴 **Nur in der Werkbank — nirgends sonst.** Die oberste `CLAUDE.md` und alles in `kontext/` (in einer englischen Firma `context/`)
 gehören der **Firma**, nicht dem Menschen vor dir. Den Firmennamen setzt der Server beim
@@ -360,6 +360,11 @@ mitbestimmungspflichtig. Das entscheidet die Firma, nicht dieses Werkzeug.
 - „Was würdest du als Geschäftsführung als Nächstes automatisieren, gemessen an dem, was bisher
   funktioniert hat — und was davon lässt sich auf andere Abteilungen übertragen?"
 
+## Kursstand lesen (`kimal3 kurs`)
+Zeigt, wo der Mensch im Mini-Kurs steht: eine Zeile je Beat, `Als Nächstes:` mit dem nächsten Schritt und dahinter, wer
+ihn abhakt — „(du hakst ab)" oder „(setzt Claude)". Rückgabewert `2` heißt nicht angemeldet, `3` nicht erreichbar —
+dann **keinen Kurs aus dem Gedächtnis erzählen**. Der Slash-Befehl `/k3kurs` führt dadurch.
+
 ## Rückgabewerte
 `0` erledigt · `1` **Wiederholen hilft nicht — LIES DIE MELDUNG** · `2` Anmeldung fehlt ·
 `3` vorübergehende Störung, einmal wiederholen · `4` angemeldet, aber kein Pro-Zugang —

package/skill/commands/k3.md

@@ -83,17 +83,18 @@ Stell die Liste in zwei Gruppen dar:
 | `/k3projekt <was du gebaut hast>` | Ein fertiges Projekt ins Erfolgsprofil eintragen |
 | `/k3liste` | Deine eingetragenen Projekte zeigen |
 | `/k3analyse <deine Frage>` | Firmendaten holen und deine Frage dazu beantworten |
+| `/k3zeigen` | Eine Aufgabe vormachen statt beschreiben — ich nehme auf und mache daraus einen Plan |
 
 Sag dazu: Die Slash-Befehle sind der **sichere** Weg — du musst dir keinen Satz merken. Ohne
 sie geht es auch: „das Projekt ist fertig" genügt, dann greife ich über den Skill.
 
-## 6. Der neunte Eintrag im Menü: `/kimal3` ist KEIN Befehl
+## 6. Der zehnte Eintrag im Menü: `/kimal3` ist KEIN Befehl
 
 In derselben `/`-Liste steht auch **`/kimal3`**. Erklär den Unterschied **ungefragt** — das Menü
 wirft zwei verschiedene Sorten in eine Liste, und genau daran hat sich der erste Mensch gestoßen,
 der die Familie gesehen hat (Dennis, 2026-08-19):
 
-- Die acht **`/k3…`** sind **Slash-Befehle** (Dateien in `~/.claude/commands/`) — **der Mensch**
+- Die neun **`/k3…`** sind **Slash-Befehle** (Dateien in `~/.claude/commands/`) — **der Mensch**
   tippt sie bewusst.
 - **`/kimal3`** ist der **Skill** (`~/.claude/skills/kimal3/SKILL.md`) — meine
   Bedienungsanleitung. Sie ist der Grund, warum „das Projekt ist fertig" genügt: Ich schlage sie
@@ -101,5 +102,5 @@ der die Familie gesehen hat (Dennis, 2026-08-19):
   sie mehrere Dinge auf einmal und liest sich nicht wie ein Menüpunkt.
 
 Sag auch, was `/kimal3` **nicht** ist: **nicht die Installation.** Die ist `kimal3 skill install`
-im Terminal — der eine Befehl, der beides ablegt, den Skill **und** die acht `/k3…`. Was im Menü
+im Terminal — der eine Befehl, der beides ablegt, den Skill **und** die neun `/k3…`. Was im Menü
 steht, ist sein Ergebnis.

package/skill/commands/k3feierabend.md

@@ -24,10 +24,9 @@ Die Status-Datei (`WEITER-HIER.md` oder `ROADMAP.md`) ist der Zettel für den n
 taugt nur, solange man sie in einem Atemzug lesen kann. **Jeder Feierabend schreibt etwas dazu —
 also muss auch jeder Feierabend etwas wegräumen**, sonst wächst sie, bis niemand sie mehr liest.
 
-**Der Statuszettel heißt `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde.** Liegt einer da, nimm ihn. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. Muss einer neu entstehen: in `werkbank-…` heißt er `WEITER-HIER.md`, in `workbench-…` `NEXT-STEPS.md`, sonst `WEITER-HIER.md`.
+**Wo der Statuszettel liegt und wie er heißt.** Die Projektregel gilt **nur innerhalb eines Arbeitsplatzes**: Liegt ein Ordner `projekte/` oder `projects/` direkt in einem Ordner `werkbank-…` oder `workbench-…` (beide Schreibweisen kommen vor, auch gemischt) und steht die Sitzung in oder unter einem Ordner darin, ist dieser **Projektordner** der Ort. Name dort: unter `projekte/` `WEITER-HIER.md`, unter `projects/` `NEXT-STEPS.md`. **Überall sonst** (Starter-Paket, eigene Repos, auch ein Ordner `~/projects/mein-repo`) bleibt es wie bisher: Der Zettel liegt im Startordner, liegt einer da, nimm ihn; muss einer neu entstehen, heißt er `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. **Welcher gilt (im Arbeitsplatz):** Hat das Projekt einen, gilt der des Projekts. Sonst gilt ein vorhandener Werkbank-Zettel (`werkbank-…/WEITER-HIER.md` oder `workbench-…/NEXT-STEPS.md` aus der alten Vorlage) — den liest und pflegst du weiter. Gibt es keinen von beiden, entsteht er **im Projekt**. **Leg nie einen neuen Zettel in der Werkbank an.**
 
-Gibt es keine Status-Datei und die Arbeit wächst über eine Sitzung hinaus: eine vorschlagen,
-dann weiter mit Schritt 3.
+**Im Arbeitsplatz** schreibst du in den Zettel des Projekts, an dem heute gearbeitet wurde — fehlt er und liegt auch kein Werkbank-Zettel, leg ihn im Projekt an. **Nach einer reinen Profil-Sitzung** („Wer hier arbeitet“ ausgefüllt, noch kein Projekt) schreibst du **keinen** Zettel, sondern sagst, dass es beim nächsten Mal mit „Erste Sitzung“ in der Werkbank-`CLAUDE.md` weitergeht — dann weiter mit Schritt 3. **Außerhalb eines Arbeitsplatzes** gilt wie bisher: Gibt es keine Status-Datei und die Arbeit wächst über eine Sitzung hinaus, schlag eine vor, dann weiter mit Schritt 3.
 
 1. **Nachziehen:** „Wo wir stehen" und „nächster Schritt" auf das setzen, was heute passiert ist.
 2. **Wegräumen, was nicht mehr gilt.** Ins Archiv wandert:

package/skill/commands/k3kurs.md

@@ -8,46 +8,34 @@ description: Zurück in den Mini-Kurs — da weiter, wo du aufgehört hast
 # Kurs
 
 > Zurück in den Mini-Kurs: „Wo war ich nochmal?" — macht da weiter, wo du aufgehört hast.
-> (Meistens brauchst du das gar nicht: Dein Coach führt dich beim `/k3start` von allein durch
-> den Kurs. Das hier ist der bewusste Wiedereinstieg, wenn du zwischendurch abgebogen bist.)
+> Den Stand holt `kimal3 kurs` frisch von kimal3 — dieselben Haken, die der Mensch im Browser unter
+> https://app.kimal3.de/kurs sieht.
 
 Führe die Schritte der Reihe nach aus. Bleib im Coaching-Ton: Deutsch, freundlich, ein Schritt
 nach dem anderen, das Warum vor dem Wie, null Vorwissen vorausgesetzt.
 
-## 1. Den Kurs nachschlagen
-- **Liegt `kurs-beats.md` (oder `course-parts.md`) neben dir? Wenn nein, hör hier auf.** Dann hat diese Person den
-  Mini-Kurs nicht — sag ihr freundlich in einem Satz, dass dieser Befehl zum Kurs gehört und
-  hier nichts zu tun hat, und frag mit einem Vorschlag, woran sie stattdessen arbeiten möchte.
-  **Fang nicht an, den Kurs aus dem Gedächtnis nachzuerzählen**, und such die Datei nicht
-  woanders. *Der Befehl kommt seit 0.2.5 mit jedem kimal3 mit, der Kurs nicht.*
-- Liegt sie da: Lies `kurs-beats.md` (oder `course-parts.md`) — dort stehen die 3 Beats des Kurses, aus dem der Nutzer
-  kommt. Das ist dein Wissen darüber; die Datei wird automatisch erzeugt, ändere sie nie von Hand.
-
-## 2. Schauen, wie weit ihr seid
-- Lies `WEITER-HIER.md` (falls vorhanden) — dort steht der Kurs-Stand, z. B. „Beat 2 läuft".
-- **Der Statuszettel heißt `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde.** Liegt einer da, nimm ihn. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. Muss einer neu entstehen: in `werkbank-…` heißt er `WEITER-HIER.md`, in `workbench-…` `NEXT-STEPS.md`, sonst `WEITER-HIER.md`.
-- Gibt es die Datei noch nicht, ist das die erste Sitzung: Beat 1 ist dann erledigt (der Nutzer
-  hat dich ja gerade gestartet), es geht bei **Beat 2** weiter. **Leg sie dann gleich an** —
-  siehe `START-HIER.md` (oder `START-HERE.md`).
-
-## 3. Stand in einem Satz sagen
-- Sag in **einem** Satz, wo ihr im Kurs steht — kein Vortrag, keine Wiederholung des ganzen Kurses.
-
-## 4. Weiterführen — bis Beat 2 durch ist
-- Führ **einen** Schritt nach dem anderen weiter: zeigen, machen lassen, verstehen. Nie die
-  ganze Liste auf einmal. Zieh `WEITER-HIER.md` (oder `NEXT-STEPS.md`) nach, sobald ein Beat fertig ist.
-- **Beat 1** (App, Konto, Plan, Start-Workspace, **Git**) passiert im Browser, **bevor** es dich
-  gibt — den kannst du nicht führen. Er ist erledigt, sobald du läufst.
-
-## 5. Nach Beat 2: den Umzug bauen & übergeben
-- Der Abschluss von Beat 2 ist der **Umzug**: Schlag Ordnername + Ort fürs erste echte
-  Projekt vor (z. B. `Documents\Claude-Projekte\mein-erstes-projekt` — der echte Ordner heißt im Dateisystem `Documents`, auch wenn der Explorer ihn als Dokumente anzeigt; lass ihn den Ordner einmal im Explorer öffnen, bevor er Claude schließt), leg den Ordner an
-  und hinterlege dort eine kurze **`WEITER-HIER.md`** (liegt dort schon ein `NEXT-STEPS.md`, nimm den) als Übergabe-Notiz — was geschafft
-  ist und was als Nächstes dran ist (kleine echte Aufgabe wählen, `git init` + erster
-  Commit, Rhythmus: durchdenken → bauen → prüfen → sichern, sichtbares Ergebnis; Schritte
-  nebenbei im Kurs im Browser abhaken). Dann bitte ihn, Claude ganz zu schließen und im
-  neuen Ordner neu zu öffnen (`/k3start`).
-- **Beat 3 führst du nicht von hier aus.** Im neuen Ordner bist du einfach sein Coach —
-  die Notiz sagt dir, wo ihr steht. Gefeiert wird im Browser.
-- Ist er schon so weit (oder gar durch), sag das kurz und freundlich — und frag mit einem
-  Vorschlag, woran er hier stattdessen arbeiten möchte. Kein Kurs-Gerede mehr.
+## 1. Den Stand holen
+- Führ `kimal3 kurs` aus (unter Windows so, wie es `SKILL.md` beschreibt).
+- Rückgabewert **2**: Der Mensch ist nicht angemeldet. Zeig ihm `kimal3 login`, lass ihn selbst im Browser bestätigen
+  und nenn **keinen** Kursstand.
+- Rückgabewert **3**: Der Stand ist gerade nicht abrufbar. Sag es in einem Satz und **erzähl den Kurs nicht aus dem
+  Gedächtnis**.
+- Kennt das Programm den Befehl nicht, ist es zu alt: Nenn `npm install -g kimal3@latest`, danach `kimal3 skill install`.
+
+## 2. Stand in einem Satz sagen
+- Sag in **einem** Satz, wo ihr im Kurs steht — aus der Ausgabe (Zeile `Kurs:`), nichts dazuerfinden. Kein Vortrag.
+
+## 3. Als Nächstes führen
+- Die Zeile `Als Nächstes:` nennt den nächsten Schritt. Führ **einen** Schritt nach dem anderen: zeigen, machen lassen,
+  verstehen. Nie die ganze Liste auf einmal.
+- Steht dahinter **„(du hakst ab)"** und hat der Mensch den Schritt offensichtlich schon getan (zum Beispiel „Claude ganz
+  beendet und neu geöffnet" — er sitzt ja gerade in Claude), führ ihn nicht noch einmal: Frag kurz nach und bitte ihn,
+  den Schritt unter https://app.kimal3.de/kurs abzuhaken.
+- Steht dahinter **„(setzt Claude)"** und ist er offen, lass die Einrichtung noch einmal laufen — über die Anleitung
+  `https://app.kimal3.de/einrichten` (lade sie wie der Kurs-Satz und folge ihr), **nicht** mit einem frei aufgerufenen
+  `kimal3 einrichten`. Bleibt der Schritt danach offen, nenn den Grund aus der Ausgabe von `einrichten` und schlag
+  keinen dritten Lauf vor.
+
+## 4. Abgeschlossen
+- Steht in der Ausgabe `Kurs: abgeschlossen`, gratuliere kurz und frag mit einem Vorschlag, woran er hier arbeiten
+  möchte. Kein Kurs-Gerede mehr.

package/skill/commands/k3start.md

@@ -23,11 +23,12 @@ nicht relevant, sag das kurz und überspring ihn — kein Leerlauf.
   dich für genau dieses Projekt und hat **Vorrang** vor allem, was hier unten steht.
 - Gibt es ein Status-Doc (`WEITER-HIER.md` oder `ROADMAP.md`) — eine kleine Datei, in der der
   letzte Stand und der nächste Schritt festgehalten sind? Dann lies es.
-- **Der Statuszettel heißt `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde.** Liegt einer da, nimm ihn. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. Muss einer neu entstehen: in `werkbank-…` heißt er `WEITER-HIER.md`, in `workbench-…` `NEXT-STEPS.md`, sonst `WEITER-HIER.md`.
-- Kein Status-Doc? **Sieh erst nach, ob ein `.git`-Ordner daneben liegt.** Wenn ja, führt dieses
+- **Wo der Statuszettel liegt und wie er heißt.** Die Projektregel gilt **nur innerhalb eines Arbeitsplatzes**: Liegt ein Ordner `projekte/` oder `projects/` direkt in einem Ordner `werkbank-…` oder `workbench-…` (beide Schreibweisen kommen vor, auch gemischt) und steht die Sitzung in oder unter einem Ordner darin, ist dieser **Projektordner** der Ort. Name dort: unter `projekte/` `WEITER-HIER.md`, unter `projects/` `NEXT-STEPS.md`. **Überall sonst** (Starter-Paket, eigene Repos, auch ein Ordner `~/projects/mein-repo`) bleibt es wie bisher: Der Zettel liegt im Startordner, liegt einer da, nimm ihn; muss einer neu entstehen, heißt er `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. **Welcher gilt (im Arbeitsplatz):** Hat das Projekt einen, gilt der des Projekts. Sonst gilt ein vorhandener Werkbank-Zettel (`werkbank-…/WEITER-HIER.md` oder `workbench-…/NEXT-STEPS.md` aus der alten Vorlage) — den liest und pflegst du weiter. Gibt es keinen von beiden, entsteht er **im Projekt**. **Leg nie einen neuen Zettel in der Werkbank an.**
+- **Stehst du in der Werkbank selbst (`werkbank-…` oder `workbench-…`), nicht in einem Projekt?** Steht in ihrer `CLAUDE.md` der Abschnitt „Erste Sitzung“ (englisch „First session“), folge **ihm** — er hat Vorrang vor allem Folgenden. Steht er nicht (mehr) da, zeig die Projekte in `projekte/` bzw. `projects/` (ohne `beispiel-rechnungen-erfassen` und `example-capture-invoices`) mit je der **ersten Stand-Zeile** ihres Zettels, oder „noch kein Zettel“, wenn keiner da ist; ein vorhandener Werkbank-Zettel (`WEITER-HIER.md` oder `NEXT-STEPS.md`) steht darüber. Empfiehl daraus **eines** und stell **eine** Frage dazu. Wählt der Mensch ein Projekt aus der Liste oder nennt eine neue Aufgabe (dann legst du erst Ordner und Statuszettel im Projekt an, nie in der Werkbank), bring die Sitzung in den Projektordner: mit `change_directory` (steht es nur als Name in deiner Werkzeugliste, lade es über die Werkzeugsuche) — und sag vorher: „Gleich fragt dich die Claude-App, ob ich den Ordner wechseln darf, und danach, ob du ihm vertraust — beides ist richtig so, klick jeweils auf Erlauben. Landest du danach in einem leeren Gespräch, tipp dort `/k3start`; dieses Gespräch findest du links in der Liste wieder.“ Ohne das Werkzeug oder wenn der Mensch ablehnt: nenne den genauen Projektordner (nicht die Werkbank darüber) — in der App „Ordner wählen“ und diesen Ordner nehmen, im Terminal `/exit`, `cd '‹Pfad›'`, `claude` — und dann `/k3start`. Bei einem neuen Projekt lies vorher `projekte/CLAUDE.md` (englisch `projects/CLAUDE.md`): ab jetzt gilt sie.
+- Kein Status-Doc? **Sieh erst nach, ob ein `.git`-Ordner im Zettel-Ort liegt** (im Arbeitsplatz der Projektordner, sonst der Startordner). Wenn ja, führt dieses
   Projekt eine Versionsgeschichte, und `git log --oneline -10` plus `git status` zeigen dir den
   letzten Stand.
-  ⚠️ **Liegt kein `.git` daneben, lass beide Befehle weg.** Sie antworten dann mit
+  ⚠️ **Liegt dort kein `.git`, lass beide Befehle weg.** Sie antworten dann mit
   `fatal: not a git repository` — und eine Fehlermeldung als Begrüßung sieht aus, als hätte die
   Person etwas falsch gemacht. Bei einem frisch begonnenen Projekt, in dem noch nichts gesichert
   wurde, scheitert `git log` allein; `git status` läuft dort und meldet „alles sauber".

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
@@ -24,11 +24,12 @@ route you recognise.
 | `/k3` | Where they stand — and all kimal3 commands at a glance |
 | `/k3start` | Start a session: where the project stands and what comes next |
 | `/k3wrapup` (German: `/k3feierabend`) | End a session cleanly: save the status, tidy up, summarise |
-| `/k3course` (German: `/k3kurs`) | Back into the Mini course — picking up where they left off |
+| `/k3course` (German: `/k3kurs`) | Back into the Mini course — fetches the status with `kimal3 course` and picks up where they left off |
 | `/k3project` (German: `/k3projekt`) | Add a finished project to the success profile |
 | `/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
@@ -157,8 +158,7 @@ same — **because it is the right one**, not because the trap is still open.
 together — there are four different ones. Search for square brackets instead of following a list:
 a typed-out list goes out of date the moment the template grows. Ask, instead of guessing.
 
-⚠️ You will usually find `[FIRMA]` already filled in — the server puts the name in when it delivers the folder.
-`[DATUM]` likewise. What is left are the details about the **person** in front of you.
+⚠️ You will usually find `[FIRMA]` already filled in — the server puts the name in when it delivers the folder. What is left are the details about the **person** in front of you.
 
 🔴 **Only in the workbench — nowhere else.** The top-level `CLAUDE.md` and everything in `context/` (`kontext/` in a German company)
 belong to the **company**, not to the person in front of you. The server puts in the company name
@@ -357,6 +357,11 @@ a legal right of co-determination over it. That is for the company to decide, no
 - “If you were running the company, what would you automate next, measured against what has
   worked so far — and which of it can be carried over to other departments?”
 
+## Reading the course status (`kimal3 course`)
+Shows where the person stands in the Mini course: one line per part, `Next:` with the next step and, behind it, who ticks
+it off — "(you tick it off)" or "(Claude sets it)". Exit code `2` means not signed in, `3` not reachable — then **do not
+retell the course from memory**. The slash command `/k3course` leads through it.
+
 ## Exit codes
 `0` done · `1` **Retrying won't help — READ THE MESSAGE** · `2` sign-in missing ·
 `3` temporary problem, retry once · `4` signed in, but no Pro access —

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.