kimal3 0.4.0 → 0.5.0

package/dist/befehle-katalog-en.js

@@ -143,6 +143,33 @@ export const BEFEHLE_EN = {
             "⚠️ This is personal data about your colleagues. For use in a real company you need a commercial Claude account with a data processing agreement. If employees' performance is analysed, in Germany this requires the works council's agreement (co-determination).",
         ],
     },
+    "kimal3 zeigen start": {
+        stempel: "35a185f9",
+        befehl: "kimal3 show start",
+        tippen: "/k3show",
+        terminal: 'kimal3 show start "Send the open quotes to my boss every Monday"',
+        beschreibung: "Start a recording while you show a task",
+        rhythmusOderSatz: "I want to show you a task",
+        details: [
+            "You do a task once on screen and say out loud what you are doing and why. Claude guides you through it: first the briefing on what gets recorded, then the recording, then the evaluation on your computer.",
+            "All screens, sound, clicks and keys are recorded — so don't type a password. The recording lies in the project under material/aufnahmen/ and never ends up in Git; it stops by itself after 15 minutes at the latest.",
+            "Claude asks you before reading any of it: only after your yes does the timeline go to Anthropic. At the end the task is written down in the project's plan folder, and Claude suggests deleting the recording.",
+            "Windows-only for now.",
+        ],
+    },
+    "kimal3 zeigen status": {
+        stempel: "7ebd2b8f",
+        befehl: "kimal3 show status",
+        tippen: "! kimal3 show status",
+        terminal: "kimal3 show status",
+        beschreibung: "Check whether a recording is running and whether the recorder is set up",
+        rhythmusOderSatz: "when you want to know whether something is being recorded",
+        details: [
+            "Shows two blocks: what is set up (uv, recorder, FFmpeg, speech model) and whether a recording of your screen is running — with start time, folder and the time at which it stops by itself at the latest.",
+            "If it can't tell whether something is being recorded, it says exactly that, with exit code 1 — it then never claims that nothing is running.",
+            "It only reads and changes nothing. Windows-only for now.",
+        ],
+    },
     "kimal3 wache": {
         stempel: "2daae4e2",
         befehl: "kimal3 watch",

package/dist/befehle-katalog.js

@@ -192,6 +192,33 @@ export const BEFEHLE = [
             "⚠️ Es sind personenbezogene Daten von Kolleginnen und Kollegen. Für den Einsatz in einer echten Firma braucht es ein kommerzielles Claude-Konto mit Auftragsverarbeitungsvertrag; werden Leistungen von Beschäftigten ausgewertet, ist das in Deutschland mitbestimmungspflichtig.",
         ],
     },
+    {
+        befehl: "kimal3 zeigen start",
+        beschreibung: "Eine Aufnahme starten, während du eine Aufgabe vormachst",
+        wer: "claude",
+        ausloeser: "ich will dir eine Aufgabe vormachen",
+        tippen: "/k3zeigen",
+        terminal: 'kimal3 zeigen start "Offene Angebote jeden Montag an die Chefin schicken"',
+        details: [
+            "Du machst eine Aufgabe einmal am Bildschirm vor und sagst dabei laut, was du tust und warum. Claude führt dich durch: vorher die Ansage, was aufgenommen wird, dann die Aufnahme, danach das Auswerten auf deinem Rechner.",
+            "Aufgenommen werden alle Bildschirme, Ton, Klicks und Tasten — tippe deshalb kein Passwort. Die Aufnahme liegt im Projekt unter material/aufnahmen/ und landet nie in Git; spätestens nach 15 Minuten stoppt sie von selbst.",
+            "Bevor Claude etwas davon liest, fragt er dich: Erst nach deinem Ja geht die Zeitleiste an Anthropic. Am Ende steht die Aufgabe in plan/aufgabe-vorgefuehrt.md, und Claude schlägt vor, die Aufnahme zu löschen.",
+            "Gibt es bisher nur unter Windows.",
+        ],
+    },
+    {
+        befehl: "kimal3 zeigen status",
+        beschreibung: "Nachsehen, ob gerade aufgenommen wird und ob der Aufnehmer eingerichtet ist",
+        wer: "du",
+        rhythmus: "wenn du wissen willst, ob gerade aufgenommen wird",
+        tippen: "! kimal3 zeigen status",
+        terminal: "kimal3 zeigen status",
+        details: [
+            "Zeigt zwei Blöcke: was eingerichtet ist (uv, Aufnehmer, FFmpeg, Sprachmodell) und ob gerade eine Aufnahme von deinem Bildschirm läuft — mit Startzeit, Ordner und der Uhrzeit, zu der sie spätestens von selbst stoppt.",
+            "Kann es nicht feststellen, ob aufgenommen wird, sagt es genau das, mit Rückgabewert 1 — es behauptet dann nie, dass nichts läuft.",
+            "Es liest nur und ändert nichts. Gibt es bisher nur unter Windows.",
+        ],
+    },
     /*
       🔴 Dieser Eintrag steht bewusst NICHT im "Weg, den ein Mensch geht" --
       niemand muss ihn selbst tippen. Er wird bei jedem Start von Claude Code

package/dist/befehlswoerter.js

@@ -15,6 +15,13 @@ export const BEFEHLSWOERTER = {
     wache: { de: "wache", en: "watch" },
     "wache an": { de: "wache an", en: "watch on" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "wache aus": { de: "wache aus", en: "watch off" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
+    // `kimal3 zeigen` / `show` (Spec 2026-10-18-k3zeigen-design.md, Abschnitt 1)
+    "zeigen einrichten": { de: "zeigen einrichten", en: "show setup" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen start": { de: "zeigen start", en: "show start" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen stopp": { de: "zeigen stopp", en: "show stop" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen auswerten": { de: "zeigen auswerten", en: "show evaluate" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen bild": { de: "zeigen bild", en: "show picture" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen status": { de: "zeigen status", en: "show status" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
 };
 /**
  * Welcher Befehl steht vorne in `argv` -- und was bleibt dahinter?
@@ -60,6 +67,10 @@ export const SCHALTER_EN = {
     // `kimal3 einrichten` / `setup` (Spec 2026-10-16, Bauform 6)
     workplace: "arbeitsplatz",
     workbench: "werkbank",
+    // `kimal3 show …` (Spec 2026-10-18-k3zeigen-design.md)
+    "at-most": "hoechstens",
+    language: "sprache",
+    "without-typed": "ohne-getipptes",
 };
 /** `company` -> `firma`; ein deutscher (oder unbekannter) Name bleibt, wie er ist. */
 export function deutscherSchalter(getippt) {

package/dist/kimal3.js

@@ -38,6 +38,9 @@ import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { skillDatei, skillInstallBefehl } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
+import { zeigenAuswerten, zeigenBild, zeigenStatus, zeigenStopp } from "./befehle/zeigen.js";
+import { zeigenStart } from "./befehle/zeigen-start.js";
+import { zeigenEinrichten } from "./befehle/zeigen-einrichten.js";
 /** Eine Meldung pro Programmlauf -- s. "Einmal-Riegel" im Block darunter. */
 let schonGemeldet = false;
 /**
@@ -493,6 +496,13 @@ async function fuehreAus(name, rest) {
         case "kontext runter": return kontextRunter(rest);
         case "kontext hoch": return kontextHoch(rest);
         case "kontext fragen": return kontextFragen(rest);
+        // `kimal3 zeigen` (Spec 2026-10-18-k3zeigen-design.md).
+        case "zeigen einrichten": return zeigenEinrichten(rest);
+        case "zeigen start": return zeigenStart(rest);
+        case "zeigen stopp": return zeigenStopp(rest);
+        case "zeigen auswerten": return zeigenAuswerten(rest);
+        case "zeigen bild": return zeigenBild(rest);
+        case "zeigen status": return zeigenStatus(rest);
         case "wache an": return allein ? wacheSchalten(true) : null;
         case "wache aus": return allein ? wacheSchalten(false) : null;
         case "wache":

package/dist/logo-ablegen.js

@@ -2,6 +2,7 @@ import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, writ
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { EINRICHTEN_TEXTE } from "./texte/einrichten.js";
 /**
  * Legt den Plugin-Katalog mit dem Logo-Mod in `~/.kimal3/claude-plugins` ab und setzt dort die
  * Sprache des Kontos. Claude Code liest den Mod aus genau diesem Ordner (Katalog `kimal3`,
@@ -34,8 +35,9 @@ export function mitSprache(quelltext, sprache) {
  * 🔑 Der weggeschobene Ordner bekommt bei JEDEM Lauf einen frischen Namen (Durchsicht 2, Funde 2 und 4):
  * Ein Rest, den Windows festhält, blockiert so keinen späteren Lauf, und zurückgeholt wird nur, was
  * DIESER Lauf weggeschoben hat -- nie ein veralteter Rest von früher.
- * Lässt sich der alte nicht wegschieben (Claude hält ihn manchmal fest), bleibt er unversehrt stehen und
- * gilt weiter: ein Erfolg mit `alterStand`, den `kimal3 einrichten` in einer Zeile nennt.
+ * Lässt sich der alte nicht wegschieben, bleibt er unversehrt stehen und gilt weiter: ein Erfolg mit `stand: "alt"`,
+ * den der Aufrufer in einer Zeile nennt. Unter Windows hält ihn ein Programm fest, dessen Arbeitsordner darin liegt;
+ * Claude selbst tut es nicht (gemessen 18.10. bei acht laufenden Claude-Prozessen, Spec 2026-10-18, Abschnitt 1.2).
  */
 export function logoAblegen(sprache) {
     // `dist/logo-ablegen.js` -> `../claude-plugins` im installierten Paket (`files` in package.json).
@@ -51,14 +53,14 @@ export function logoAblegen(sprache) {
             // Auch im Normalfall aufräumen, samt einem halb gebauten `….neu`: sonst blieben Reste für immer (Durchsicht 3/4).
             rmSync(neu, { recursive: true, force: true });
             resteWegraeumen(ziel);
-            return { ok: true, ordner: ziel };
+            return { ok: true, ordner: ziel, stand: "gleich" };
         }
         rmSync(neu, { recursive: true, force: true });
         cpSync(quelle, neu, { recursive: true });
         writeFileSync(modDatei(neu), text, "utf8");
         if (!existsSync(ziel)) {
             renameSync(neu, ziel);
-            return { ok: true, ordner: ziel };
+            return { ok: true, ordner: ziel, stand: "neu" };
         }
         const alt = `${ziel}.alt-${Date.now()}`; // kein-anzeigetext: Ordnername
         try {
@@ -66,7 +68,7 @@ export function logoAblegen(sprache) {
         }
         catch {
             rmSync(neu, { recursive: true, force: true });
-            return { ok: true, ordner: ziel, alterStand: true };
+            return { ok: true, ordner: ziel, stand: "alt" };
         }
         try {
             renameSync(neu, ziel);
@@ -76,12 +78,30 @@ export function logoAblegen(sprache) {
             return { ok: false, detail: e.message };
         }
         resteWegraeumen(ziel);
-        return { ok: true, ordner: ziel };
+        return { ok: true, ordner: ziel, stand: "neu" };
     }
     catch (e) {
         return { ok: false, detail: e.message };
     }
 }
+/**
+ * Für `login` und `skill install` (Spec 2026-10-18, Abschnitt 1.2): ein VORHANDENES Logo auffrischen (Update,
+ * Sprachwechsel), nie eines anlegen -- das darf nur `einrichten`, wie beim Coach (`frischeCoachAuf`). Wer das Logo nie
+ * eingerichtet hat, hört nichts und bekommt keinen Ordner (L-2). Eine Zeile nur, wenn getauscht wurde, das alte bleiben
+ * musste oder etwas scheiterte; sonst Stille. Wirft nie und ändert den Rückgabewert des Befehls nicht (L-6).
+ */
+export function frischeLogoAuf(s) {
+    if (!existsSync(katalogOrdner()))
+        return;
+    const ablage = logoAblegen(s);
+    const t = EINRICHTEN_TEXTE[s];
+    if (!ablage.ok)
+        console.log(t.logoNotWritten(ablage.detail));
+    else if (ablage.stand === "neu")
+        console.log(t.logoRefreshed);
+    else if (ablage.stand === "alt")
+        console.log(t.logoNotRefreshed);
+}
 /** Gleiche Dateien, gleicher Inhalt -- der Mod mit der Sprache des Kontos, alles andere wie im Paket. */
 function stehtSchonDa(quelle, ziel, modText) {
     if (!existsSync(ziel))

package/dist/slash-befehle.js

@@ -1,6 +1,7 @@
 export const SLASH_PAARE = [
     { de: "k3", en: "k3" },
     { de: "k3start", en: "k3start" },
+    { de: "k3zeigen", en: "k3show" }, // kein-anzeigetext: Befehlsname (Spec 2026-10-18-k3zeigen-design.md)
     { de: "k3feierabend", en: "k3wrapup" }, // kein-anzeigetext: Befehlsname (Spec Teil 4, Abschnitt 6)
     { de: "k3kontext", en: "k3context" }, // kein-anzeigetext: Befehlsname
     { de: "k3projekt", en: "k3project" }, // kein-anzeigetext: Befehlsname

package/dist/texte/einrichten.js

@@ -50,11 +50,16 @@ const de = {
     settingsInvalid: "deine Claude-Einstellungen (~/.claude/settings.json) sind kein gültiges JSON. Ich habe sie nicht angefasst.",
     settingsForeign: "in deinen Claude-Einstellungen (~/.claude/settings.json) steht etwas in einer Form, die ich nicht kenne. Ich habe sie nicht angefasst.",
     settingsFailed: (ursache) => `deine Claude-Einstellungen (~/.claude/settings.json): ${ursache}.`,
-    // Logo (Durchsicht 2, Funde 1 und 3): Scheitert der Ordner, kommt superpowers trotzdem; hält Claude ihn fest, gilt die alte Fassung.
+    // Logo (Durchsicht 2, Funde 1 und 3): Scheitert der Ordner, kommt superpowers trotzdem; hält ein anderes Programm ihn fest, bleibt die alte Fassung (`logoOldVersion`).
     logoNotWritten: (detail) => `  Den Ordner für das KImal3-Logo konnte ich nicht anlegen oder erneuern (${detail}).`,
     // Ohne Git kein superpowers (Durchsicht 3, Fund 5); die Anleitung zitiert den Anfang dieser Zeile.
     superpowersNeedsGit: "  superpowers braucht Git — es kommt mit dem nächsten `kimal3 einrichten`, sobald Git da ist.",
-    logoOldVersion: "  Das KImal3-Logo bleibt vorerst in der bisherigen Fassung, weil Claude den Ordner gerade benutzt. Beende Claude ganz und starte danach `kimal3 einrichten` noch einmal.",
+    // Die Sperre setzt ein anderes Programm mit Arbeitsordner im Logo-Ordner, nicht Claude -- deshalb kein Rat, Claude zu
+    // beenden (für App-Nutzer ein Kreis; Spec 2026-10-18, Abschnitt 1.2).
+    logoOldVersion: "  Das Logo konnte gerade nicht aufgefrischt werden, weil ein anderes Programm seinen Ordner benutzt. Es kommt beim nächsten `kimal3 einrichten`.",
+    // Auffrischen bei `login` und `skill install` (`frischeLogoAuf`); scheitert es, sagt es `logoNotWritten`.
+    logoRefreshed: "  Das Logo über dem Eingabefeld ist aufgefrischt. Ist es eingeschaltet, siehst du es nach dem nächsten Neustart von Claude.",
+    logoNotRefreshed: "  Das Logo konnte gerade nicht aufgefrischt werden, weil ein anderes Programm seinen Ordner benutzt. Es kommt beim nächsten `kimal3 skill install`.",
 };
 const en = {
     codeLine: (code) => `\n  ${M.en.code} ${code}`,
@@ -101,6 +106,8 @@ const en = {
     settingsFailed: (ursache) => `your Claude settings (~/.claude/settings.json): ${ursache}.`,
     logoNotWritten: (detail) => `  I couldn't create or renew the folder for the KImal3 logo (${detail}).`,
     superpowersNeedsGit: "  superpowers needs Git — it comes with the next `kimal3 setup` once Git is there.",
-    logoOldVersion: "  The KImal3 logo stays on its previous version for now, because Claude is using the folder. Quit Claude completely, then run `kimal3 setup` again.",
+    logoOldVersion: "  The logo couldn't be refreshed just now, because another program is using its folder. It comes with the next `kimal3 setup`.",
+    logoRefreshed: "  The logo above the prompt is refreshed. If it is switched on, you'll see it after the next restart of Claude.",
+    logoNotRefreshed: "  The logo couldn't be refreshed just now, because another program is using its folder. It comes with the next `kimal3 skill install`.",
 };
 export const EINRICHTEN_TEXTE = { de, en };

package/dist/texte/zeigen.js

@@ -0,0 +1,189 @@
+const TEIL_DE = { aufnehmer: "Aufnehmer", ffmpeg: "FFmpeg", modell: "Sprachmodell" };
+const TEIL_EN = { aufnehmer: "Recorder", ffmpeg: "FFmpeg", modell: "Speech model" };
+const SCHRITT_DE = { uv: "uv", ...TEIL_DE };
+const SCHRITT_EN = { uv: "uv", aufnehmer: "recorder", ffmpeg: "FFmpeg", modell: "speech model" };
+const mehrzahl = (n, eins, viele) => `${n} ${n === 1 ? eins : viele}`;
+const de = {
+    nurWindows: "`kimal3 zeigen` gibt es bisher nur unter Windows; der Mac folgt.",
+    helpStatus: "\n  kimal3 zeigen status\n\n  Zeigt, ob der Aufnehmer eingerichtet ist und ob gerade aufgenommen wird.\n  Liest nur, ändert nichts.\n",
+    helpStart: "\n  kimal3 zeigen start \"<deine Aufgabe in einem Satz>\" [--hoechstens <minuten>]\n\n  Startet eine Aufnahme von Bildschirm, Ton, Klicks und Tasten im Ordner\n  material/aufnahmen/ deines Projekts. Sie stoppt spätestens nach 15 Minuten\n  von selbst (--hoechstens: weniger, 1 bis 15).\n",
+    helpStopp: "\n  kimal3 zeigen stopp\n\n  Stoppt die laufende Aufnahme und nennt nur Zahlen: Dauer, Klicks, Tasten, Ton.\n",
+    helpAuswerten: "\n  kimal3 zeigen auswerten [<ordner>] [--sprache de|en] [--ohne-getipptes]\n\n  Macht aus der Aufnahme auf diesem Rechner eine Zeitleiste (zeitleiste.md):\n  was gesagt, geklickt und getippt wurde. Ohne Ordner: die jüngste Aufnahme\n  des Projekts. --ohne-getipptes lässt alles Getippte aus.\n",
+    helpBild: "\n  kimal3 zeigen bild <m:ss> [<ordner>]\n\n  Legt ein Bildschirmfoto der Aufnahme zu diesem Zeitpunkt in bilder/ ab\n  (höchstens 1600 Pixel breit). Ohne Ordner: die jüngste Aufnahme des Projekts.\n",
+    helpEinrichten: "\n  kimal3 zeigen einrichten\n\n  Richtet einmal ein, was für Aufnahmen fehlt: uv, den Aufnehmer, FFmpeg und das\n  Sprachmodell (zusammen etwa 2,1 GB). Nur in deinem Benutzerordner, ohne\n  Adminrechte. Was schon da ist, wird nicht noch einmal geladen.\n",
+    schrittUv: "uv wird eingerichtet …",
+    schrittAufnehmer: (fassung) => `Aufnehmer ${fassung} wird eingerichtet …`,
+    schrittFfmpeg: "FFmpeg wird eingerichtet …",
+    schrittModell: "Sprachmodell (1,6 GB) wird geladen — das dauert einige Minuten …",
+    nichtGeklappt: (schritt) => `Schritt ${SCHRITT_DE[schritt]} hat nicht geklappt.`,
+    allesDa: (fassung) => `Alles schon da: uv, Aufnehmer ${fassung}, FFmpeg, Sprachmodell.`,
+    fertigEingerichtet: (fassung) => `Eingerichtet — jetzt ist alles da: uv, Aufnehmer ${fassung}, FFmpeg, Sprachmodell.`,
+    eingerichtet: "Eingerichtet:",
+    uvDa: (fassung) => `  uv ${fassung}`,
+    uvFehlt: "  uv fehlt",
+    aufnehmerDa: (fassung) => `  Aufnehmer ${fassung}`,
+    aufnehmerAlt: (fassung, soll) => `  Aufnehmer ${fassung} (gebraucht wird ${soll})`,
+    aufnehmerFehlt: "  Aufnehmer fehlt",
+    ffmpeg: (da) => `  FFmpeg ${da ? "da" : "fehlt"}`,
+    modell: (da) => `  Sprachmodell ${da ? "da" : "fehlt"}`,
+    teilUngeprueft: (teil) => `  ${TEIL_DE[teil]}: ohne Aufnehmer nicht prüfbar`,
+    teilUnbekannt: (teil) => `  ${TEIL_DE[teil]}: kann ich nicht feststellen`,
+    aufnahme: "Aufnahme:",
+    laeuftSeit: (uhr, minuten, ordner, ende) => `  Läuft seit ${uhr} (${mehrzahl(minuten, "Minute", "Minuten")}), Ordner \`${ordner}\`, stoppt spätestens ${ende}.`,
+    laeuftFremd: "  Läuft (in einer anderen Sitzung gestartet).",
+    keineLaeuft: "  Keine Aufnahme läuft.",
+    letzteSelbst: (ordner, minuten) => `  Die letzte (\`${ordner}\`) hat nach ${mehrzahl(minuten, "Minute", "Minuten")} von selbst gestoppt.`,
+    letzteAbgebrochen: (ordner) => `  Die letzte (\`${ordner}\`) ist abgebrochen.`,
+    unbekannt: "Ob gerade aufgenommen wird, kann ich nicht feststellen.",
+    ortHier: (aufnahmen) => `Aufnahmen landen hier in: ${aufnahmen}`,
+    ortWerkbank: "Wechsle zuerst in ein Projekt (`projekte/<name>`) — Claude kann eins anlegen.",
+    ortZuLang: (laenge, hoechstens) => `Der Projektordner liegt zu tief für den Aufnehmer (${laenge} Zeichen, höchstens ${hoechstens}). Ein Projekt näher am Laufwerk hilft.`,
+    satzFehlt: "Sag in einem Satz, welche Aufgabe du vormachst:",
+    hoechstensFalsch: (wert) => `„--hoechstens ${wert}" verstehe ich nicht — bitte eine ganze Zahl von 1 bis 15 (Minuten).`,
+    schonLaeuft: (uhr, ordner) => `Es läuft schon eine Aufnahme (seit ${uhr}, Ordner \`${ordner}\`).`,
+    schonLaeuftFremd: "Es läuft schon eine Aufnahme (in einer anderen Sitzung gestartet).",
+    startetGerade: (ordner) => `Gerade startet schon eine Aufnahme (Ordner \`${ordner}\`).`,
+    unbekanntKeinStart: "Ob gerade aufgenommen wird, kann ich nicht feststellen — deshalb starte ich keine zweite.",
+    nichtEingerichtet: "Der Aufnehmer ist noch nicht eingerichtet: `kimal3 zeigen einrichten`.",
+    ordnerNichtAnlegbar: (ordner) => `Den Aufnahmeordner kann ich nicht anlegen: ${ordner}`,
+    laeuftJetzt: (ordner, ende) => `Die Aufnahme läuft (Ordner \`${ordner}\`), stoppt spätestens um ${ende}.`,
+    nichtGestartet: (grund, protokoll) => `Die Aufnahme ist nicht gestartet: ${grund}. Protokoll: ${protokoll}`,
+    endeUnbestaetigt: "Ob der Aufnehmer noch läuft, sagt `kimal3 zeigen status`.",
+    keineAufnahmeLaeuft: "Es läuft keine Aufnahme.",
+    zahlen: (dauer, klicks, tasten, ton) => `${dauer} Minuten, ${mehrzahl(klicks, "Klick", "Klicks")}, ${mehrzahl(tasten, "Taste", "Tasten")}, ${ton ? "Ton ist da" : "kein Ton"}.`,
+    gestoppt: (zahlen) => `Aufnahme gestoppt: ${zahlen}`,
+    selbstGestoppt: (minuten, zahlen) => `Die Aufnahme hat nach ${mehrzahl(minuten, "Minute", "Minuten")} von selbst gestoppt: ${zahlen}`,
+    nichtSauber: (grund) => `Die Aufnahme ist nicht sauber abgeschlossen: ${grund}.`,
+    // Ob der Ton da ist, sagen die Zahlen; bis 21.10. stand hier fest „der Ton ist verloren“ — auch wenn er da war.
+    abgebrochen: (grund, zahlen) => `Die Aufnahme ist abgebrochen: ${grund}.${zahlen === null ? "" : ` ${zahlen}`}`,
+    stoppUnklar: "Die Aufnahme ließ sich nicht stoppen — ob sie noch läuft, sagt `kimal3 zeigen status`.",
+    wirdAbgeschlossen: "Die Aufnahme wird noch abgeschlossen — gleich noch einmal `kimal3 zeigen stopp`.",
+    fremdLaeuft: "Es läuft eine Aufnahme, die ich hier nicht zuordnen kann. Sieh mit `kimal3 zeigen status` nach.",
+    keineAufnahmeHier: "In diesem Projekt finde ich keine Aufnahme (`material/aufnahmen/`).",
+    ordnerFehlt: (ordner) => `Den Aufnahmeordner gibt es nicht: ${ordner}`,
+    laeuftNoch: "Die Aufnahme läuft noch — erst `kimal3 zeigen stopp`.",
+    spracheFalsch: (wert) => `„--sprache ${wert}" kenne ich nicht — de oder en.`,
+    werteAus: "Werte aus (das dauert etwa so lange wie die Aufnahme) …",
+    zeitleisteFertig: (dauer, saetze, klicks, tippstellen, passwortfelder, datei) => `Zeitleiste fertig: ${dauer} Minuten, ${mehrzahl(saetze, "Satz", "Sätze")}, ${mehrzahl(klicks, "Klick", "Klicks")}, ` +
+        `${mehrzahl(tippstellen, "Stelle", "Stellen")} mit getipptem Text` +
+        (passwortfelder > 0 ? `, ${mehrzahl(passwortfelder, "Passwortfeld", "Passwortfelder")} ausgeblendet` : "") +
+        `. Datei: \`${datei}\`.`,
+    keineSprache: "Ich habe keine Sprache erkannt — war das Mikrofon stumm oder das falsche gewählt?",
+    keinTon: "Die Aufnahme hat keine Tonspur — ohne Ton entsteht keine Zeitleiste. Eine neue Aufnahme hilft.",
+    zeitleisteFehler: (grund) => `Die Zeitleiste ist nicht entstanden: ${grund}.`,
+    zeitFalsch: (wert) => `„${wert}" verstehe ich nicht als Zeitpunkt — bitte so: 0:26 oder 1:02:05.`,
+    bildFertig: (datei) => `Bild: ${datei}`,
+    bildFehler: (grund) => `Das Bild ist nicht entstanden: ${grund}.`,
+    gruende: {
+        "ffmpeg-fehlt": "FFmpeg fehlt — `kimal3 zeigen einrichten` holt es",
+        "kein-mikrofon": "ich finde kein Mikrofon",
+        "bildschirm-gesperrt": "der Bildschirm ist gesperrt oder nicht lesbar",
+        "pfad-zu-lang": "der Ordnerpfad ist zu lang für den Aufnehmer",
+        "startet-nicht": "der Aufnehmer ist nicht angelaufen",
+        "modell-fehlt": "das Sprachmodell fehlt — `kimal3 zeigen einrichten` holt es",
+        "nicht-beendet": "der Aufnehmer ließ sich nicht beenden",
+        "keine-aufnahme": "in dem Ordner liegt keine Aufnahme",
+        "aufnahme-unlesbar": "die Aufnahme ist nicht lesbar",
+        erkennung: "die Spracherkennung ist gescheitert",
+        "zeit-ungueltig": "der Zeitpunkt ist ungültig",
+        "kein-video": "die Aufnahme hat kein Video",
+        "kein-bild": "an dieser Stelle gibt es kein Bild — vielleicht liegt der Zeitpunkt nach dem Ende der Aufnahme",
+        "laden-gescheitert": "das Herunterladen ist gescheitert",
+        unvollstaendig: "das Sprachmodell ist nicht vollständig angekommen",
+        "ordner-fehlt": "der Aufnahmeordner fehlt",
+        "schreiben-gescheitert": "die Zeitleiste ließ sich nicht schreiben",
+        unbekannt: "den Grund kenne ich nicht",
+    },
+};
+const en = {
+    nurWindows: "`kimal3 show` is Windows-only for now; the Mac follows.",
+    helpStatus: "\n  kimal3 show status\n\n  Shows whether the recorder is set up and whether a recording is running.\n  Only reads, changes nothing.\n",
+    helpStart: "\n  kimal3 show start \"<your task in one sentence>\" [--at-most <minutes>]\n\n  Starts a recording of screen, sound, clicks and keys in your project's\n  material/aufnahmen/ folder. It stops by itself after 15 minutes at the latest\n  (--at-most: less, 1 to 15).\n",
+    helpStopp: "\n  kimal3 show stop\n\n  Stops the running recording and reports numbers only: length, clicks, keys, sound.\n",
+    helpAuswerten: "\n  kimal3 show evaluate [<folder>] [--language de|en] [--without-typed]\n\n  Turns the recording into a timeline on this computer (zeitleiste.md):\n  what was said, clicked and typed. Without a folder: the project's latest\n  recording. --without-typed leaves out everything typed.\n",
+    helpBild: "\n  kimal3 show picture <m:ss> [<folder>]\n\n  Saves a screenshot of the recording at that moment in bilder/\n  (at most 1600 pixels wide). Without a folder: the project's latest recording.\n",
+    helpEinrichten: "\n  kimal3 show setup\n\n  Sets up once what recordings still need: uv, the recorder, FFmpeg and the\n  speech model (about 2.1 GB together). Only in your user folder, no admin\n  rights. Whatever is already there isn't downloaded again.\n",
+    schrittUv: "Setting up uv …",
+    schrittAufnehmer: (fassung) => `Setting up recorder ${fassung} …`,
+    schrittFfmpeg: "Setting up FFmpeg …",
+    schrittModell: "Loading the speech model (1.6 GB) — this takes a few minutes …",
+    nichtGeklappt: (schritt) => `Step ${SCHRITT_EN[schritt]} didn't work.`,
+    allesDa: (fassung) => `Everything is already there: uv, recorder ${fassung}, FFmpeg, speech model.`,
+    fertigEingerichtet: (fassung) => `Set up — now everything is there: uv, recorder ${fassung}, FFmpeg, speech model.`,
+    eingerichtet: "Set up:",
+    uvDa: (fassung) => `  uv ${fassung}`,
+    uvFehlt: "  uv missing",
+    aufnehmerDa: (fassung) => `  Recorder ${fassung}`,
+    aufnehmerAlt: (fassung, soll) => `  Recorder ${fassung} (${soll} is needed)`,
+    aufnehmerFehlt: "  Recorder missing",
+    ffmpeg: (da) => `  FFmpeg ${da ? "present" : "missing"}`,
+    modell: (da) => `  Speech model ${da ? "present" : "missing"}`,
+    teilUngeprueft: (teil) => `  ${TEIL_EN[teil]}: can't be checked without the recorder`,
+    teilUnbekannt: (teil) => `  ${TEIL_EN[teil]}: I can't tell`,
+    aufnahme: "Recording:",
+    laeuftSeit: (uhr, minuten, ordner, ende) => `  Running since ${uhr} (${minuten} ${minuten === 1 ? "minute" : "minutes"}), folder \`${ordner}\`, stops at ${ende} at the latest.`,
+    laeuftFremd: "  Running (started in another session).",
+    keineLaeuft: "  No recording is running.",
+    letzteSelbst: (ordner, minuten) => `  The last one (\`${ordner}\`) stopped by itself after ${minuten} ${minuten === 1 ? "minute" : "minutes"}.`,
+    letzteAbgebrochen: (ordner) => `  The last one (\`${ordner}\`) broke off.`,
+    unbekannt: "I can't tell whether a recording is running.",
+    ortHier: (aufnahmen) => `Recordings go here: ${aufnahmen}`,
+    ortWerkbank: "Switch into a project first (`projects/<name>`) — Claude can create one.",
+    ortZuLang: (laenge, hoechstens) => `The project folder is nested too deeply for the recorder (${laenge} characters, at most ${hoechstens}). A project closer to the drive helps.`,
+    satzFehlt: "Say in one sentence which task you're showing:",
+    hoechstensFalsch: (wert) => `I don't understand “--at-most ${wert}” — please a whole number from 1 to 15 (minutes).`,
+    schonLaeuft: (uhr, ordner) => `A recording is already running (since ${uhr}, folder \`${ordner}\`).`,
+    schonLaeuftFremd: "A recording is already running (started in another session).",
+    startetGerade: (ordner) => `A recording is already starting (folder \`${ordner}\`).`,
+    unbekanntKeinStart: "I can't tell whether a recording is running — so I won't start a second one.",
+    nichtEingerichtet: "The recorder isn't set up yet: `kimal3 show setup`.",
+    ordnerNichtAnlegbar: (ordner) => `I can't create the recording folder: ${ordner}`,
+    laeuftJetzt: (ordner, ende) => `The recording is running (folder \`${ordner}\`), stops at ${ende} at the latest.`,
+    nichtGestartet: (grund, protokoll) => `The recording didn't start: ${grund}. Log: ${protokoll}`,
+    endeUnbestaetigt: "Whether the recorder is still running: `kimal3 show status`.",
+    keineAufnahmeLaeuft: "No recording is running.",
+    zahlen: (dauer, klicks, tasten, ton) => `${dauer} minutes, ${klicks} ${klicks === 1 ? "click" : "clicks"}, ${tasten} ${tasten === 1 ? "key" : "keys"}, ${ton ? "audio present" : "no audio"}.`,
+    gestoppt: (zahlen) => `Recording stopped: ${zahlen}`,
+    selbstGestoppt: (minuten, zahlen) => `The recording stopped by itself after ${minuten} ${minuten === 1 ? "minute" : "minutes"}: ${zahlen}`,
+    nichtSauber: (grund) => `The recording wasn't closed cleanly: ${grund}.`,
+    abgebrochen: (grund, zahlen) => `The recording broke off: ${grund}.${zahlen === null ? "" : ` ${zahlen}`}`,
+    stoppUnklar: "The recording couldn't be stopped — whether it's still running: `kimal3 show status`.",
+    wirdAbgeschlossen: "The recording is still being finished — run `kimal3 show stop` again in a moment.",
+    fremdLaeuft: "A recording is running that I can't match here. Check with `kimal3 show status`.",
+    keineAufnahmeHier: "I can't find a recording in this project (`material/aufnahmen/`).",
+    ordnerFehlt: (ordner) => `The recording folder doesn't exist: ${ordner}`,
+    laeuftNoch: "The recording is still running — first `kimal3 show stop`.",
+    spracheFalsch: (wert) => `I don't know “--language ${wert}” — de or en.`,
+    werteAus: "Evaluating (this takes about as long as the recording) …",
+    zeitleisteFertig: (dauer, saetze, klicks, tippstellen, passwortfelder, datei) => `Timeline ready: ${dauer} minutes, ${saetze} ${saetze === 1 ? "sentence" : "sentences"}, ${klicks} ${klicks === 1 ? "click" : "clicks"}, ` +
+        `${tippstellen} ${tippstellen === 1 ? "place" : "places"} with typed text` +
+        (passwortfelder > 0 ? `, ${passwortfelder} ${passwortfelder === 1 ? "password field" : "password fields"} hidden` : "") +
+        `. File: \`${datei}\`.`,
+    keineSprache: "I didn't recognise any speech — was the microphone muted or the wrong one selected?",
+    keinTon: "The recording has no audio track — without sound there's no timeline. A new recording helps.",
+    zeitleisteFehler: (grund) => `The timeline wasn't created: ${grund}.`,
+    zeitFalsch: (wert) => `I don't understand “${wert}” as a point in time — please like this: 0:26 or 1:02:05.`,
+    bildFertig: (datei) => `Picture: ${datei}`,
+    bildFehler: (grund) => `The picture wasn't created: ${grund}.`,
+    gruende: {
+        "ffmpeg-fehlt": "FFmpeg is missing — `kimal3 show setup` gets it",
+        "kein-mikrofon": "I can't find a microphone",
+        "bildschirm-gesperrt": "the screen is locked or can't be read",
+        "pfad-zu-lang": "the folder path is too long for the recorder",
+        "startet-nicht": "the recorder didn't get going",
+        "modell-fehlt": "the speech model is missing — `kimal3 show setup` gets it",
+        "nicht-beendet": "the recorder couldn't be stopped",
+        "keine-aufnahme": "there's no recording in that folder",
+        "aufnahme-unlesbar": "the recording can't be read",
+        erkennung: "speech recognition failed",
+        "zeit-ungueltig": "the point in time isn't valid",
+        "kein-video": "the recording has no video",
+        "kein-bild": "there's no picture at that point — perhaps the moment is after the end of the recording",
+        "laden-gescheitert": "the download failed",
+        unvollstaendig: "the speech model didn't arrive completely",
+        "ordner-fehlt": "the recording folder is missing",
+        "schreiben-gescheitert": "the timeline could not be written",
+        unbekannt: "I don't know the reason",
+    },
+};
+export const ZEIGEN_TEXTE = { de, en };