kimal3 0.4.0 → 0.6.0

package/dist/plan-datei.js

@@ -0,0 +1,172 @@
+/**
+ * `plan/stand.json` lesen und nach dem Hochladen nachtragen (Spec 2026-10-21-projektseite-planung, Abschnitt 3).
+ *
+ * 🔑 Die Datei gehoert Claude und liegt unter Git -- diese Datei prueft sie NICHT. Ob ein Plan stimmt,
+ * entscheidet allein der Server (`lesePlanText`); hier geht es nur darum, ob es ueberhaupt ein JSON-Objekt
+ * ist, damit ein Tippfehler im Klammerwerk ohne Netz und ohne Anmeldung auffaellt.
+ *
+ * ⚠️ Ein BOM am Anfang (Windows-Editoren setzen eines) wird beim Lesen entfernt: `JSON.parse` lehnt es ab,
+ * und der Server meldete sonst „kein JSON" fuer eine Datei, die im Editor einwandfrei aussieht.
+ */
+import { readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+export const PLAN_PFAD = "plan/stand.json"; // kein-anzeigetext: Dateipfad
+const ohneBom = (text) => (text.startsWith("\uFEFF") ? text.slice(1) : text);
+function alsObjekt(text) {
+    try {
+        const json = JSON.parse(text);
+        return json !== null && typeof json === "object" && !Array.isArray(json) ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function lesePlanDatei(ordner) {
+    let text;
+    try {
+        text = ohneBom(readFileSync(join(ordner, PLAN_PFAD), "utf8"));
+    }
+    catch {
+        return { ok: false, grund: "fehlt" };
+    }
+    const json = alsObjekt(text);
+    return json === null ? { ok: false, grund: "kein-json" } : { ok: true, text, json };
+}
+/**
+ * Traegt `projekt_id` und `basis` ein und leert `uebernommen` -- alles andere bleibt, wie es ist.
+ * 🔑 `uebernommenLeeren` ist PFLICHT, nicht optional: Nach `503 teilweise` ist der Plan gespeichert, die
+ * Rueckmeldungen aber noch nicht markiert (Ruling 10). Dann muss `basis` neu, `uebernommen` aber stehen
+ * bleiben -- sonst gingen sie beim zweiten Lauf verloren, und mit altem `basis` lehnte er als „veraltet" ab.
+ * Fehlen die beiden Felder, kommen sie hinter `projekt` (dort stehen sie im Beispiel der Spec), nicht ans Ende.
+ * Eingerueckt mit 2 Leerzeichen; Windows-Zeilenenden bleiben Windows-Zeilenenden.
+ * `false` heisst: nicht geschrieben (Datei weg, kein JSON mehr, Schreibschutz).
+ */
+export function schreibeNachHochladen(ordner, projektId, hochgeladenAm, uebernommenLeeren) {
+    const pfad = join(ordner, PLAN_PFAD);
+    try {
+        const roh = readFileSync(pfad, "utf8");
+        const alt = alsObjekt(ohneBom(roh));
+        if (alt === null)
+            return false;
+        const neu = {};
+        for (const [schluessel, wert] of Object.entries(alt)) {
+            neu[schluessel] = wert;
+            if (schluessel === "projekt") {
+                neu.projekt_id = projektId;
+                neu.basis = hochgeladenAm;
+            }
+        }
+        neu.projekt_id = projektId;
+        neu.basis = hochgeladenAm;
+        if (uebernommenLeeren)
+            neu.uebernommen = [];
+        const text = `${JSON.stringify(neu, null, 2)}\n`;
+        writeFileSync(pfad, roh.includes("\r\n") ? text.replace(/\n/g, "\r\n") : text, "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const SPEC_TEXT_GRENZE_JE = 300 * 1024; // kein-anzeigetext: Bytes
+export const SPEC_TEXT_GRENZE_ZUSAMMEN = 4 * 1024 * 1024; // kein-anzeigetext: Bytes
+/**
+ * Darf diese Datei gelesen werden? Nur ein relativer Pfad, der nach dem Aufloesen (auch einer Verknuepfung) im
+ * Projektordner bleibt und auf `.md` endet. 🔴 Positivliste: erst alles ausser dem Erlaubten abweisen -- die
+ * Schreibweisen fuer „woanders" (Laufwerk, Netzwerkpfad, Wurzel, `..`) sind nicht zu Ende aufzaehlbar.
+ * `wirklich` ist `realpathSync` (im Test ersetzt) und liefert `null`, wo es die Datei nicht gibt.
+ */
+export function specPfadPruefen(ordner, datei, wirklich) {
+    if (datei === null || datei.trim() === "")
+        return { ok: false, grund: "keine_datei" };
+    if (!/\.md$/i.test(datei))
+        return { ok: false, grund: "ausserhalb" };
+    // Laufwerk, Wurzel und Netzwerkpfad gelten auf JEDEM System als „woanders", auch wo `isAbsolute` sie nicht kennt.
+    if (isAbsolute(datei) || /^[A-Za-z]:/.test(datei) || /^[\\/]/.test(datei))
+        return { ok: false, grund: "ausserhalb" };
+    const innen = (wurzel, ziel) => {
+        const r = relative(wurzel, ziel);
+        return r !== "" && r.split(/[\\/]/)[0] !== ".." && !isAbsolute(r);
+    };
+    const ziel = resolve(ordner, datei);
+    if (!innen(resolve(ordner), ziel))
+        return { ok: false, grund: "ausserhalb" };
+    const echt = wirklich(ziel);
+    if (echt !== null && !innen(wirklich(resolve(ordner)) ?? resolve(ordner), echt))
+        return { ok: false, grund: "ausserhalb" };
+    return { ok: true, pfad: echt ?? ziel };
+}
+const wirklichOderNull = (p) => {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+};
+/** `stand.json` -> die Koepfe der Specs; Unlesbares wird uebersprungen (ob der Plan stimmt, sagt allein der Server). */
+export function specKoepfeAus(json) {
+    if (!Array.isArray(json.specs))
+        return [];
+    return json.specs.flatMap((s) => {
+        if (!s || typeof s !== "object")
+            return [];
+        const r = s;
+        if (typeof r.schluessel !== "string")
+            return [];
+        return [{ schluessel: r.schluessel, titel: typeof r.titel === "string" ? r.titel : r.schluessel, datei: typeof r.datei === "string" ? r.datei : null }];
+    });
+}
+/** Wie gross der Text im JSON-Rumpf wird (mit Maskierung) -- danach wird der groesste gewaehlt, der herausfaellt. */
+const rumpfBytes = (text) => Buffer.byteLength(JSON.stringify(text), "utf8");
+/**
+ * Liest den Text jeder Spec. Jede Spec bekommt GENAU einen Eintrag: den Text oder den Grund, warum keiner da ist.
+ * Passt der fertige Anfrage-Rumpf nicht in 4 MB, werden die groessten Texte zu `zu_gross`, bis er passt (US-16:
+ * „am fertigen Anfrage-Rumpf"). `rumpf` baut genau den Rumpf, den `plan hoch` schickt (Stand, Schalter, Texte) --
+ * dieselbe Funktion baut ihn dort auch, damit gemessen wird, was hinausgeht (Befund M-3).
+ */
+export function leseSpecTexte(ordner, specs, rumpf) {
+    const keineTextdatei = new Set();
+    const eintraege = specs.map((s, i) => {
+        const ohne = (grund) => ({ schluessel: s.schluessel, grund, pfad: s.datei });
+        const pruefung = specPfadPruefen(ordner, s.datei, wirklichOderNull);
+        if (!pruefung.ok)
+            return ohne(pruefung.grund);
+        try {
+            const status = statSync(pruefung.pfad);
+            if (!status.isFile())
+                return ohne("fehlt");
+            if (status.size > SPEC_TEXT_GRENZE_JE)
+                return ohne("zu_gross");
+            const text = readFileSync(pruefung.pfad, "utf8");
+            if (Buffer.byteLength(text, "utf8") > SPEC_TEXT_GRENZE_JE)
+                return ohne("zu_gross");
+            // Ein Nullzeichen nimmt Postgres in `text` nicht an -- der Server lehnte den ganzen Aufruf ab (Befund M-1).
+            if (text.includes("\u0000")) {
+                keineTextdatei.add(i);
+                return ohne("fehlt");
+            }
+            return { schluessel: s.schluessel, text: ohneBom(text) };
+        }
+        catch {
+            return ohne("fehlt");
+        }
+    });
+    const groesse = () => Buffer.byteLength(JSON.stringify(rumpf(eintraege)), "utf8");
+    while (groesse() > SPEC_TEXT_GRENZE_ZUSAMMEN) {
+        let groesster = -1;
+        let groessterBytes = -1;
+        eintraege.forEach((e, i) => {
+            const b = "text" in e ? rumpfBytes(e.text) : -1;
+            if (b > groessterBytes) {
+                groesster = i;
+                groessterBytes = b;
+            }
+        });
+        if (groesster < 0)
+            break;
+        eintraege[groesster] = { schluessel: specs[groesster].schluessel, grund: "zu_gross", pfad: specs[groesster].datei };
+    }
+    const ohne = eintraege.flatMap((e, i) => "grund" in e ? [{ titel: specs[i].titel, grund: keineTextdatei.has(i) ? "keine_textdatei" : e.grund, pfad: e.pfad }] : []);
+    return { eintraege, ohne };
+}

package/dist/slash-befehle.js

@@ -1,9 +1,11 @@
 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
+    { de: "k3plan", en: "k3plan" }, // kein-anzeigetext: Befehlsname, in beiden Sprachen gleich (Spec 2026-10-21-projektseite-planung, C-7)
     { de: "k3liste", en: "k3list" }, // kein-anzeigetext: Befehlsname
     { de: "k3analyse", en: "k3analyse" }, // britisch, in beiden Sprachen gleich
     { de: "k3kurs", en: "k3course" }, // 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/plan.js

@@ -0,0 +1,93 @@
+const de = {
+    // ── plan.ts ──
+    listHelp: `
+  kimal3 plan
+
+  Holt die offenen Rückmeldungen zu deiner Planung aus der App: jedes
+  „passt nicht“ und jedes notierte Thema mit seiner Nummer, dazu die
+  bestätigten Stories der aktuellen Runden.
+
+  Liest plan/stand.json im Ordner, um das Projekt zu finden. Ändert nichts.
+`,
+    fileMissing: "Im Ordner liegt keine plan/stand.json. `/k3plan` legt sie an.",
+    noJson: "Der Plan ist nicht lesbar: plan/stand.json enthält kein gültiges JSON-Objekt.",
+    openVerdict: (nummer, spec, story, runde, notiz) => `#${nummer} · passt nicht · ${spec} / ${story} (Runde ${runde}): ${notiz}`,
+    openTopic: (nummer, notiz) => `#${nummer} · Thema: ${notiz}`,
+    noOpen: "Keine offenen Rückmeldungen.",
+    confirmed: (liste) => `Bestätigt: ${liste}`,
+    confirmedItem: (spec, story, runde) => `${spec} / ${story} (Runde ${runde})`,
+    view: (adresse) => `Ansehen: ${adresse}`,
+    // ── plan-hoch.ts ──
+    uploadHelp: `
+  kimal3 plan hoch [--ueberschreiben] [--probe]
+
+  Schickt plan/stand.json an dein Projekt in der App. Danach trägt es
+  projekt_id und basis in die Datei ein und leert uebernommen.
+
+  --probe            Prüft alles wie beim Hochladen und speichert nichts.
+
+  --ueberschreiben   Speichert auch dann, wenn in der App inzwischen ein
+                     neuerer Plan liegt (zwei Arbeitskopien).
+`,
+    uploaded: (titel, stories, deinTest) => `✓ Planung für „${titel}“ hochgeladen: ${stories === 1 ? "1 Story" : `${stories} Stories`}, ` +
+        `${deinTest === 1 ? "1 wartet" : `${deinTest} warten`} auf deinen Test.`,
+    dryRun: (stories, uebernommen) => `Probelauf: würde ${stories === 1 ? "1 Story" : `${stories} Stories`} hochladen, ` +
+        `${uebernommen === 1 ? "1 Rückmeldung" : `${uebernommen} Rückmeldungen`} als übernommen melden. Gespeichert wurde nichts.`,
+    // US-16: Eine Spec ohne Text ist ein Hinweis, kein Fehlschlag -- darum steht der Grund in Klammern hinter ihrem Namen.
+    specTextOhneGrund: (grund, pfad) => grund === "fehlt" ? `${pfad ?? ""} nicht gefunden`
+        : grund === "keine_datei" ? "keine Datei angegeben"
+            : grund === "ausserhalb" ? "Pfad außerhalb des Projekts"
+                : grund === "keine_textdatei" ? "keine Textdatei"
+                    : "größer als 300 KB",
+    specTexte: (angekommen, gesamt, ohne) => `Spec-Texte hochgeladen: ${angekommen} von ${gesamt}.${ohne.length === 0 ? "" : ` Ohne Text: ${ohne.join(", ")}.`}`,
+    specTextOhneEintrag: (titel, grundText) => `„${titel}“ (${grundText})`,
+    idNowInFile: "projekt_id und basis stehen jetzt in plan/stand.json.",
+    writeBackFailed: (projektId, hochgeladenAm, leeren) => "⚠ Die Planung ist gespeichert, aber plan/stand.json ließ sich nicht nachtragen. Trag selbst ein: " +
+        `"projekt_id": "${projektId}", "basis": "${hochgeladenAm}"${leeren ? ', "uebernommen": []' : ""}`,
+};
+const en = {
+    listHelp: `
+  kimal3 plan
+
+  Fetches the open responses to your planning from the app: every
+  “doesn't work” and every noted topic with its number, plus the
+  confirmed stories of the current rounds.
+
+  Reads plan/stand.json in this folder to find the project. Changes nothing.
+`,
+    fileMissing: "There's no plan/stand.json in this folder. `/k3plan` creates it.",
+    noJson: "The plan can't be read: plan/stand.json doesn't contain a valid JSON object.",
+    openVerdict: (nummer, spec, story, runde, notiz) => `#${nummer} · doesn't work · ${spec} / ${story} (round ${runde}): ${notiz}`,
+    openTopic: (nummer, notiz) => `#${nummer} · Topic: ${notiz}`,
+    noOpen: "No open responses.",
+    confirmed: (liste) => `Confirmed: ${liste}`,
+    confirmedItem: (spec, story, runde) => `${spec} / ${story} (round ${runde})`,
+    view: (adresse) => `View: ${adresse}`,
+    uploadHelp: `
+  kimal3 plan upload [--overwrite] [--dry-run]
+
+  Sends plan/stand.json to your project in the app. After that it enters
+  projekt_id and basis in the file and empties uebernommen.
+
+  --dry-run          Checks everything like an upload and saves nothing.
+
+  --overwrite        Saves even if the app already holds a newer plan
+                     (two working copies).
+
+  The German option names (--ueberschreiben, --probe) work too.
+`,
+    uploaded: (titel, stories, deinTest) => `✓ Planning for "${titel}" uploaded: ${stories === 1 ? "1 story" : `${stories} stories`}, ${deinTest} waiting for your test.`,
+    dryRun: (stories, uebernommen) => `Dry run: would upload ${stories === 1 ? "1 story" : `${stories} stories`} and mark ` +
+        `${uebernommen === 1 ? "1 response" : `${uebernommen} responses`} as handled. Nothing was saved.`,
+    specTextOhneGrund: (grund, pfad) => grund === "fehlt" ? `${pfad ?? ""} not found`
+        : grund === "keine_datei" ? "no file given"
+            : grund === "ausserhalb" ? "path outside the project"
+                : grund === "keine_textdatei" ? "not a text file"
+                    : "larger than 300 KB",
+    specTexte: (angekommen, gesamt, ohne) => `Spec texts uploaded: ${angekommen} of ${gesamt}.${ohne.length === 0 ? "" : ` Without text: ${ohne.join(", ")}.`}`,
+    specTextOhneEintrag: (titel, grundText) => `"${titel}" (${grundText})`,
+    idNowInFile: "projekt_id and basis are now in plan/stand.json.",
+    writeBackFailed: (projektId, hochgeladenAm, leeren) => "⚠ The planning is saved, but plan/stand.json couldn't be updated. Enter it yourself: " +
+        `"projekt_id": "${projektId}", "basis": "${hochgeladenAm}"${leeren ? ', "uebernommen": []' : ""}`,
+};
+export const PLAN_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 };