kimal3 0.4.0-durchstich.3 → 0.5.0

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 };

package/dist/zeigen-rechnung.js

@@ -0,0 +1,226 @@
+// Reine Rechnungen hinter `kimal3 zeigen` (Aufnahme von Bildschirm und Ton fuer Claude).
+// Kein Dateisystem, kein Prozess, keine Anzeige-Texte: Die Befehle holen die Fakten und fragen hier.
+// Gedeckt von `npm run check:zeigen` (Spec 2026-10-18-k3zeigen-design.md).
+import { win32 } from "node:path";
+const MAX_PFAD_WINDOWS = 170;
+/** "2026-10-19-0912" in Ortszeit. */
+export function ordnerName(jetzt) {
+    const z = (n) => String(n).padStart(2, "0");
+    return `${jetzt.getFullYear()}-${z(jetzt.getMonth() + 1)}-${z(jetzt.getDate())}-${z(jetzt.getHours())}${z(jetzt.getMinutes())}`;
+}
+/** Index des Projektordners im Segment-Array, -1 wenn keiner, -2 wenn der Pfad bei der Werkbank endet. */
+function projektEnde(segmente) {
+    const i = segmente.findIndex((s) => /^(werkbank|workbench)-/i.test(s));
+    if (i < 0)
+        return -1;
+    const projekte = /^werkbank-/i.test(segmente[i]) ? /^projekte$/i : /^projects$/i;
+    if (i === segmente.length - 1)
+        return -2;
+    if (!projekte.test(segmente[i + 1]))
+        return -1;
+    return i + 2 < segmente.length ? i + 2 : -2;
+}
+/** Wohin die Aufnahme faellt: ins Projekt, in dem man steht -- nie in die Werkbank selbst. */
+export function aufnahmeOrt(start, jetzt, plattform, gibtEs) {
+    const trenner = start.includes("\\") ? "\\" : "/";
+    const segmente = start.split(/[\\/]/);
+    while (segmente.length > 1 && segmente[segmente.length - 1] === "")
+        segmente.pop();
+    const ende = projektEnde(segmente);
+    if (ende === -2)
+        return { art: "werkbank" };
+    const projekt = (ende >= 0 ? segmente.slice(0, ende + 1) : segmente).join(trenner);
+    const aufnahmen = `${projekt}${trenner}material${trenner}aufnahmen`; // kein-anzeigetext: Ordnerpfad
+    const basis = `${aufnahmen}${trenner}${ordnerName(jetzt)}`;
+    let ordner = basis;
+    for (let n = 2; gibtEs(ordner); n++)
+        ordner = `${basis}-${n}`;
+    if (plattform === "win32" && ordner.length > MAX_PFAD_WINDOWS) {
+        return { art: "zu-lang", laenge: ordner.length, hoechstens: MAX_PFAD_WINDOWS };
+    }
+    return { art: "ort", ordner, aufnahmen };
+}
+/** 93 -> "1:33", 3725 -> "1:02:05". */
+export function dauerText(sekunden) {
+    const s = Math.floor(sekunden);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const rest = String(s % 60).padStart(2, "0");
+    return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${rest}` : `${m}:${rest}`;
+}
+/** "0:26" -> 26, "1:02:05" -> 3725, "26" -> 26; alles andere null. */
+export function zeitAusText(text) {
+    const teile = text.trim().split(":");
+    if (teile.length > 3 || !teile.every((t) => /^\d+$/.test(t)))
+        return null;
+    const zahlen = teile.map(Number);
+    if (zahlen.slice(1).some((n) => n >= 60))
+        return null;
+    return zahlen.reduce((summe, n) => summe * 60 + n, 0);
+}
+/** 26 -> "0-26.png", 3725 -> "1-02-05.png" (Doppelpunkte duerfen nicht in Dateinamen). */
+export function bildName(sekunden) {
+    return `${dauerText(sekunden).replaceAll(":", "-")}.png`; // kein-anzeigetext: Dateiname
+}
+// Reihenfolge zaehlt: das erste Muster, das trifft, gewinnt. Das Protokoll enthaelt Fenstertitel -- es wird nie
+// zurueckgegeben oder angezeigt, nur nach diesen festen Mustern durchsucht.
+const GRUENDE = [
+    [/FFmpegUnavailableError|ffmpeg.*not found/i, "ffmpeg-fehlt"],
+    [/returned success without a non-empty output/, "pfad-zu-lang"],
+    [/PortAudio|No Default Input Device|sounddevice/, "kein-mikrofon"],
+    [/DesktopCaptureError|screen layout/, "bildschirm-gesperrt"],
+    [/did not become ready|did not start/, "startet-nicht"],
+];
+export function fehlerGrund(protokoll) {
+    return GRUENDE.find(([muster]) => muster.test(protokoll))?.[1] ?? "unbekannt";
+}
+/** Der Aufnehmer antwortet mit einer JSON-Zeile ganz am Ende; alles andere (auch ein Traceback) ist ein Fehlschlag. */
+export function liesWerkzeugAntwort(rueckgabe, stdout) {
+    if (rueckgabe !== 0)
+        return { ok: false };
+    const zeilen = stdout.split(/\r?\n/).filter((z) => z.trim() !== "");
+    const letzte = zeilen[zeilen.length - 1];
+    if (letzte === undefined)
+        return { ok: false };
+    try {
+        const daten = JSON.parse(letzte);
+        if (typeof daten !== "object" || daten === null || Array.isArray(daten))
+            return { ok: false };
+        return { ok: true, daten: daten };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+/** So alt darf das Lebenszeichen des Starters hoechstens sein, damit er als lebend gilt (er schreibt alle 2 s). */
+const LEBENSZEICHEN_SEK = 10;
+/** Lebt der Starter nachweislich -- meldet `startet`/`laeuft` UND sein Lebenszeichen ist hoechstens 10 s alt? (R-3) */
+export function starterLebt(s, jetzt) {
+    if (s === null || (s.zustand !== "startet" && s.zustand !== "laeuft"))
+        return false;
+    return s.zuletzt !== undefined && jetzt - s.zuletzt <= LEBENSZEICHEN_SEK;
+}
+/**
+ * Die Wahrheit ueber "laeuft" kommt vom Aufnehmer; Notiz und Starter erzaehlen nur dazu.
+ * `jetzt` in Epochensekunden. Ausnahme Uebergangsfenster (R-3): Der Aufnehmer meldet noch/schon keine Sitzung, der
+ * Starter lebt aber nachweislich (frisches Lebenszeichen) -- dann laeuft etwas, sonst waere "abgebrochen" falsch.
+ */
+export function aufnahmeZustand(f, jetzt) {
+    if (f.aktiveSitzungen === null)
+        return { art: "unbekannt" };
+    // Der Starter konnte den Aufnehmer nicht beenden: Solange er noch lebt (und es weiter versucht) oder der Aufnehmer
+    // eine Sitzung meldet, weiss niemand, ob aufgenommen wird. Ein laengst stiller Starter ohne aktive Sitzung blockiert
+    // dagegen nicht jeden weiteren Start im Projekt -- er zaehlt unten als abgebrochen (Endpruefung, Punkt 3).
+    const frisch = f.starter?.zuletzt !== undefined && jetzt - f.starter.zuletzt <= LEBENSZEICHEN_SEK;
+    if (f.starter?.grund === "nicht-beendet" && (frisch || f.aktiveSitzungen.length > 0))
+        return { art: "unbekannt" };
+    const n = f.notiz;
+    const ausNotiz = (sitzung, eigenerOrdner) => n !== null && ((sitzung !== null && n.sitzung === sitzung) || eigenerOrdner)
+        ? { art: "laeuft", sitzung, ordner: n.ordner, gestartet: n.gestartet, frist: n.frist, fremd: false }
+        : { art: "laeuft", sitzung, ordner: null, gestartet: null, frist: null, fremd: true };
+    if (f.aktiveSitzungen.length > 0) {
+        const eigene = n !== null && f.aktiveSitzungen.includes(n.sitzung) ? n.sitzung : null;
+        return ausNotiz(eigene ?? f.aktiveSitzungen[0], false);
+    }
+    const s = f.starter;
+    if (s === null)
+        return { art: "keine", letzte: null };
+    if (starterLebt(s, jetzt))
+        return ausNotiz(s.sitzung ?? null, f.starterImNotizOrdner);
+    if (s.zustand === "selbst-gestoppt" || s.zustand === "gestoppt")
+        return { art: "keine", letzte: s.zustand };
+    return { art: "keine", letzte: "abgebrochen" };
+}
+/**
+ * Das Python des Aufnehmers ist nicht zu finden (Ruling R-13). Ohne Notiz und ohne offenen Starter kann nichts laufen,
+ * was kimal3 gestartet hat -> wie "keine aktive Sitzung". Gibt es aber eine Notiz oder einen Starter in
+ * `startet`/`laeuft`, entscheidet allein sein Lebenszeichen: frisch -> laeuft, sonst weiss es niemand.
+ * Steht der Starter in einem ENDZUSTAND, ist die Aufnahme zu, auch mit Notiz (Ruling R-17): Er schreibt ihn erst, wenn
+ * sein Kind weg ist. Ausnahme `grund: nicht-beendet` mit frischem Lebenszeichen -- die faengt `aufnahmeZustand` als
+ * "weiss nicht" ab.
+ */
+export function zustandOhneAufnehmer(f, jetzt) {
+    const mitListe = { ...f, aktiveSitzungen: [] };
+    const offen = f.starter?.zustand === "startet" || f.starter?.zustand === "laeuft";
+    const zu = f.starter !== null && !offen;
+    if (zu || f.notiz === null && !offen)
+        return aufnahmeZustand(mitListe, jetzt);
+    return starterLebt(f.starter, jetzt) ? aufnahmeZustand(mitListe, jetzt) : { art: "unbekannt" };
+}
+export const AUFNEHMER_FASSUNG = "1.3.0";
+/** Die Fassung des Aufnehmers, wie `teile` sie meldet -- nur in der Form `1.3.0…`, alles andere ist keine Angabe (R-14, Punkt 5). */
+export const gueltigeFassung = (w) => (typeof w === "string" && /^\d+\.\d+\.\d+\S*$/.test(w) ? w : null);
+/**
+ * Die Antwort von `werkzeug.py teile` -> `Teile`. Ohne Antwort (kein Aufnehmer-Python) oder mit einer unlesbaren gilt
+ * alles ausser uv als fehlend: Einrichten holt es dann (wieder), statt einem stummen Aufnehmer zu glauben.
+ */
+export function teileAus(uv, antwort) {
+    if (antwort === null || !antwort.ok)
+        return { uv, aufnehmer: null, ffmpeg: false, modell: false };
+    const d = antwort.daten;
+    return { uv, aufnehmer: gueltigeFassung(d.aufnehmer), ffmpeg: d.ffmpeg === true, modell: d.modell === true };
+}
+export const AUFNEHMER_PAKET = `openadapt-capture[transcribe-fast]==${AUFNEHMER_FASSUNG}`; // kein-anzeigetext: Paketname
+/** `uv tool install …` -- `ersetzen`, sobald schon eine Umgebung des Aufnehmers liegt (andere Fassung, kaputt). */
+export function aufnehmerArgumente(ersetzen) {
+    // kein-anzeigetext: Befehlszeile
+    return ["tool", "install", "--python", "3.12", ...(ersetzen ? ["--force"] : []), AUFNEHMER_PAKET];
+}
+/**
+ * Wie uv auf den Rechner kommt: winget zuerst (Coach-Regel: Paketmanager), sonst der offizielle Installer pro Benutzer.
+ * Ohne die beiden Zustimmungsschalter haengt winget auf einem frischen Rechner an einer Frage (Spec US-2).
+ */
+export function uvEinrichtung(winget) {
+    // kein-anzeigetext: Befehlszeile
+    if (winget)
+        return { befehl: "winget", argumente: ["install", "--id", "astral-sh.uv", "-e", "--scope", "user", "--accept-source-agreements", "--accept-package-agreements"] };
+    // kein-anzeigetext: Befehlszeile
+    return { befehl: "powershell", argumente: ["-ExecutionPolicy", "ByPass", "-c", "irm https://astral.sh/uv/install.ps1 | iex"] };
+}
+/** Was beim Einrichten noch fehlt, in der Reihenfolge, in der es gebraucht wird. */
+export function einrichtPlan(t) {
+    const fehlt = [
+        [t.uv === null, "uv"],
+        [t.aufnehmer !== AUFNEHMER_FASSUNG, "aufnehmer"],
+        [!t.ffmpeg, "ffmpeg"],
+        [!t.modell, "modell"],
+    ];
+    return fehlt.filter(([f]) => f).map(([, schritt]) => schritt);
+}
+/** Wo uv unter Windows liegen kann, wenn es nicht im PATH steht (frisch installiert, Terminal noch alt). */
+export function uvKandidaten(env, home) {
+    const lokal = env.LOCALAPPDATA ?? win32.join(home, "AppData", "Local"); // kein-anzeigetext: Ordnerpfad
+    return [
+        // kein-anzeigetext: Ordnerpfad
+        win32.join(lokal, "Microsoft", "WinGet", "Packages", "astral-sh.uv_Microsoft.Winget.Source_8wekyb3d8bbwe", "uv.exe"),
+        win32.join(home, ".local", "bin", "uv.exe"),
+        win32.join(home, ".cargo", "bin", "uv.exe"),
+    ];
+}
+/**
+ * Welcher Ordner in `material/aufnahmen/` ist die juengste Aufnahme? Nur Namen von `ordnerName` (mit Endung `-2` …)
+ * zaehlen; `-10` kommt nach `-9` (als Text stuende es davor). `istAufnahme` sortiert Ordner aus, in denen keine
+ * Aufnahme liegt (ein gescheiterter Start hinterlaesst nur Protokoll und Starter-Bericht) -- sonst verdeckte er die
+ * letzte echte fuer auswerten und stopp (Endpruefung, Punkt 4). `null`, wenn keiner passt.
+ */
+export function juengsteAufnahme(namen, istAufnahme) {
+    const schluessel = (n) => {
+        const m = /^(\d{4}-\d{2}-\d{2}-\d{4})(?:-(\d+))?$/.exec(n);
+        return m ? { name: n, basis: m[1], nr: m[2] === undefined ? 1 : Number(m[2]) } : null;
+    };
+    const passend = namen.map(schluessel).filter((k) => k !== null);
+    passend.sort((a, b) => (a.basis === b.basis ? b.nr - a.nr : a.basis < b.basis ? 1 : -1));
+    return passend.find((k) => istAufnahme(k.name))?.name ?? null;
+}
+/** `zahlenDa`: Dauer, Klicks, Tasten und Ton kamen in der erwarteten Form. Ohne sie ist auch "gestoppt" nicht bestaetigt. */
+export function stoppAusgang(ergebnis, zahlenDa) {
+    if (ergebnis === "keine")
+        return { satz: "keine", code: 0, notizWeg: true };
+    if ((ergebnis === "gestoppt" || ergebnis === "selbst-gestoppt") && zahlenDa)
+        return { satz: ergebnis, code: 0, notizWeg: true };
+    if (ergebnis === "nicht-sauber" || ergebnis === "abgebrochen")
+        return { satz: ergebnis, code: 1, notizWeg: true };
+    if (ergebnis === "wird-abgeschlossen")
+        return { satz: ergebnis, code: 1, notizWeg: false };
+    return { satz: "unklar", code: 1, notizWeg: false };
+}

package/dist/zeigen-umgebung.js

@@ -0,0 +1,190 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { juengsteAufnahme, liesWerkzeugAntwort, starterLebt, uvKandidaten } from "./zeigen-rechnung.js";
+/**
+ * Die Umgebung hinter `kimal3 zeigen`: wo der Aufnehmer und sein Python liegen, wie das Werkzeug gerufen wird, und
+ * die Notiz `~/.kimal3/zeigen.json` (welcher Ordner zu welcher Sitzung gehoert). Entscheidungen trifft
+ * `zeigen-rechnung.ts`; hier wird nur gesucht, gestartet, gelesen und geschrieben.
+ * 🔴 Ausgaben fremder Programme werden nie weitergereicht: vom Werkzeug zaehlt nur die eine JSON-Zeile (gelesen von
+ * `liesWerkzeugAntwort`), stderr wird verworfen.
+ */
+/** `cli/dist/zeigen-umgebung.js` -> `cli/zeigen/werkzeug.py` (im Paket unter `files`, Task 7). */
+const WERKZEUG = fileURLToPath(new URL("../zeigen/werkzeug.py", import.meta.url)); // kein-anzeigetext: Paketpfad
+function laeuft(befehl, argumente) {
+    try {
+        const r = spawnSync(befehl, argumente, { encoding: "utf8", windowsHide: true, timeout: 20_000 });
+        return r.status === 0 ? r.stdout : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Das erste uv, das antwortet: Suchpfad, dann die bekannten Orte (frisch installiert, Terminal noch alt). */
+export function findeUv() {
+    for (const uv of ["uv", ...uvKandidaten(process.env, homedir())]) {
+        const version = laeuft(uv, ["--version"]);
+        if (version !== null)
+            return { uv, version };
+    }
+    return null;
+}
+/** "uv 0.12.10 (…)" -> "0.12.10"; `null`, wenn es kein uv gibt. */
+export function uvFassung() {
+    return /^uv (\d+\.\d+\.\d+\S*)/.exec(findeUv()?.version ?? "")?.[1] ?? null;
+}
+/** Python und pythonw des Aufnehmers: `<uv tool dir>/openadapt-capture/Scripts/`, sonst `%APPDATA%\uv\tools\…`. */
+export function aufnehmerPython() {
+    const uv = findeUv();
+    const toolDir = uv === null ? null : laeuft(uv.uv, ["tool", "dir"])?.trim() || null;
+    const appdata = process.env.APPDATA ?? win32.join(homedir(), "AppData", "Roaming"); // kein-anzeigetext: Ordnerpfad
+    // Antwortet uv, gilt sein Ordner allein (so greift `UV_TOOL_DIR`); der Standardort nur, wenn uv selbst fehlt (Task 5:
+    // sonst faende ein nachgestellter frischer Rechner den echten Aufnehmer unter %APPDATA% doch).
+    const orte = toolDir !== null ? [toolDir] : [win32.join(appdata, "uv", "tools")]; // kein-anzeigetext: Ordnerpfad
+    for (const ort of orte) {
+        const scripts = win32.join(ort, "openadapt-capture", "Scripts"); // kein-anzeigetext: Ordnerpfad
+        const python = win32.join(scripts, "python.exe");
+        const pythonw = win32.join(scripts, "pythonw.exe");
+        if (existsSync(python) && existsSync(pythonw))
+            return { python, pythonw };
+    }
+    return null;
+}
+/** Wohin uv die Programme seiner Werkzeuge legt (`uv tool dir --bin`, beachtet `UV_TOOL_BIN_DIR`). */
+export function uvBinOrdner(uv) {
+    return laeuft(uv, ["tool", "dir", "--bin"])?.trim() || null;
+}
+/**
+ * Ein fremdes Programm (winget, uv, capture) ohne Fenster und ohne dass eine Zeile davon irgendwo erscheint -- nicht
+ * einmal eingesammelt. `true` nur bei Rueckgabewert 0; ob die Sache danach WIRKLICH da ist, prueft der Aufrufer neu.
+ * Arbeitsordner ist der Temp-Ordner: nie das Projekt (eine `uv.toml`/`.env` dort gehoert nicht zum Einrichten).
+ */
+export function stillAusfuehren(befehl, argumente, zeitgrenze) {
+    try {
+        const r = spawnSync(befehl, argumente, { stdio: "ignore", windowsHide: true, cwd: tmpdir(), env: UMGEBUNG(), timeout: zeitgrenze });
+        return r.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Umgebung jedes Werkzeug-Aufrufs, auch des Starters (R-14, Punkt 6); den Rest setzt das Werkzeug selbst. */
+const UMGEBUNG = () => ({ ...process.env, PYTHONUTF8: "1", PYTHONUNBUFFERED: "1" });
+/** Lesende Aufrufe (`teile`, `zustand`) duerfen nicht haengen: nach 20 s gilt die Antwort als "weiss nicht" (R-14, Punkt 7). */
+export const LESEN_MS = 20_000;
+/**
+ * `stoppen` antwortet nach spaetestens 495 s selbst (werkzeug.py, STOPP_SEK + WARTEN_SEK). Diese Grenze ist nur das
+ * Netz, falls es haengt: Claude Code bricht einen Werkzeugaufruf nach 10 Minuten ab, und dann kaeme gar kein Satz.
+ */
+export const STOPPEN_MS = 540_000;
+/**
+ * Ein Unterbefehl des Werkzeugs, synchron. Arbeitsordner = Aufnahmeordner (nie das Projekt: `.env`-Falle).
+ * `zeitgrenze` in ms oder `null` (stoppen und auswerten duerfen dauern). Abgebrochen = `status` null = `{ ok: false }`.
+ */
+export function rufeWerkzeug(p, argumente, arbeitsordner, zeitgrenze) {
+    try {
+        // stderr wird gar nicht erst eingesammelt: Er wird nie gelesen, und ein Fortschrittsbalken (Modell laden, 1,6 GB)
+        // koennte sonst `maxBuffer` sprengen -- dann bricht Node den Aufruf ab (Task 5).
+        const r = spawnSync(p.python, [WERKZEUG, ...argumente], {
+            encoding: "utf8", windowsHide: true, cwd: arbeitsordner ?? tmpdir(), maxBuffer: 1024 * 1024, env: UMGEBUNG(),
+            stdio: ["ignore", "pipe", "ignore"],
+            ...(zeitgrenze === null ? {} : { timeout: zeitgrenze }),
+        });
+        return liesWerkzeugAntwort(r.status, r.stdout ?? "");
+    }
+    catch {
+        return { ok: false };
+    }
+}
+/** Startet den Starter abgehaengt mit pythonw (kein Fenster, keine Ausgabe). `false`, wenn schon das Starten scheitert. */
+export function starteStarter(p, konfig, ordner) {
+    try {
+        const kind = spawn(p.pythonw, [WERKZEUG, "starten", konfig], { cwd: ordner, detached: true, stdio: "ignore", windowsHide: true, env: UMGEBUNG() });
+        kind.on("error", () => { });
+        kind.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Die Notiz ─────────────────────────────────────────────────────────────────────────────────────────────────────
+const ORDNER = join(homedir(), ".kimal3");
+const NOTIZ = join(ORDNER, "zeigen.json"); // kein-anzeigetext: Dateiname
+export function leseNotiz() {
+    try {
+        const n = JSON.parse(readFileSync(NOTIZ, "utf8"));
+        const zahl = (w) => typeof w === "number" && Number.isFinite(w);
+        if (typeof n.sitzung !== "string" || typeof n.ordner !== "string" || !zahl(n.gestartet) || !zahl(n.frist))
+            return null;
+        return { sitzung: n.sitzung, ordner: n.ordner, gestartet: n.gestartet, frist: n.frist };
+    }
+    catch {
+        return null;
+    }
+}
+/** `false`, wenn die Notiz nicht geschrieben werden konnte -- die Aufnahme laeuft trotzdem (status findet sie ueber den Ordner). */
+export function schreibeNotiz(n) {
+    try {
+        mkdirSync(ORDNER, { recursive: true, mode: 0o700 }); // wie wache-schalter.ts: wer den Ordner anlegt, legt die Rechte fest
+        writeFileSync(NOTIZ, JSON.stringify(n, null, 2), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function loescheNotiz() {
+    try {
+        rmSync(NOTIZ, { force: true });
+    }
+    catch {
+        /* bleibt liegen -- status vergleicht sie ohnehin mit den Sitzungen des Aufnehmers */
+    }
+}
+// ── Ordner und Bericht des Starters ───────────────────────────────────────────────────────────────────────────────
+/**
+ * Der juengste Aufnahmeordner unter `aufnahmen`, oder `null`. Zaehlt nur, wo eine Aufnahme liegt (`roh/recording.db`)
+ * oder ein Starter noch lebt (er startet gerade, die Datei kommt erst noch). `roh/` gehoert allein dem Aufnehmer
+ * (gemeinsam.py, ROH: sein Siegel bricht an jeder Datei, die wir dort schreiben).
+ */
+export function juengsterOrdner(aufnahmen) {
+    try {
+        const namen = readdirSync(aufnahmen, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+        const istAufnahme = (name) => existsSync(join(aufnahmen, name, "roh", "recording.db")) || // kein-anzeigetext: Dateiname
+            starterLebt(starterFakt(leseStarter(join(aufnahmen, name))), Date.now() / 1000);
+        const name = juengsteAufnahme(namen, istAufnahme);
+        return name === null ? null : join(aufnahmen, name);
+    }
+    catch {
+        return null;
+    }
+}
+/** Der Bericht des Starters (`starter.json`), roh; `null`, wenn er fehlt oder kaputt ist. */
+export function leseStarter(ordner) {
+    try {
+        const d = JSON.parse(readFileSync(join(ordner, "starter.json"), "utf8")); // kein-anzeigetext: Dateiname
+        return d && typeof d === "object" && !Array.isArray(d) ? d : null;
+    }
+    catch {
+        return null;
+    }
+}
+const STARTER_ZUSTAENDE = ["startet", "laeuft", "gestoppt", "selbst-gestoppt", "abgebrochen", "fehlgeschlagen"];
+/** Bericht des Starters -> `Fakten.starter`; alles, was nicht die erwartete Form hat, faellt weg. */
+export function starterFakt(roh) {
+    if (!roh || typeof roh !== "object")
+        return null;
+    const r = roh;
+    const zustand = STARTER_ZUSTAENDE.find((z) => z === r.zustand);
+    if (zustand === undefined)
+        return null;
+    return {
+        zustand,
+        ...(typeof r.sitzung === "string" ? { sitzung: r.sitzung } : {}),
+        ...(typeof r.zuletzt === "number" && Number.isFinite(r.zuletzt) ? { zuletzt: r.zuletzt } : {}),
+        ...(typeof r.grund === "string" ? { grund: r.grund } : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.4.0-durchstich.3",
+  "version": "0.5.0",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
   "type": "module",
   "bin": {
@@ -10,6 +10,8 @@
     "dist",
     "skill",
     "claude-plugins",
+    "coach",
+    "zeigen",
     "README.md"
   ],
   "engines": {