kimal3 0.4.0-durchstich.3 → 0.5.0

package/dist/befehle/kurs.js

@@ -0,0 +1,77 @@
+import { feld, ruf } from "../api.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { KURS_TEXTE } from "../texte/kurs.js";
+import { schlussFehler } from "../fehler.js";
+import { BASIS_URL } from "../anmeldung.js";
+const istZahl = (w) => typeof w === "number" && Number.isFinite(w);
+function schrittAus(w) {
+    if (!w || typeof w !== "object")
+        return null;
+    const s = w;
+    if (typeof s.id !== "string" || !istZahl(s.beat) || typeof s.text !== "string" || (s.wer !== "claude" && s.wer !== "mensch"))
+        return null;
+    return { id: s.id, beat: s.beat, text: s.text, wer: s.wer };
+}
+/** Die Antwort von `GET /api/cli/kurs` -- `null`, wenn sie nicht die erwartete Form hat (z. B. ein WLAN-Anmeldeportal mit `200`). */
+function standAus(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    if (!Array.isArray(k.beats) || !Array.isArray(k.offen) || typeof k.abgeschlossen !== "boolean")
+        return null;
+    const beats = k.beats.map((b) => {
+        const r = b && typeof b === "object" ? b : {};
+        return istZahl(r.nummer) && istZahl(r.erledigt) && istZahl(r.gesamt) && typeof r.fertig === "boolean"
+            ? { nummer: r.nummer, erledigt: r.erledigt, gesamt: r.gesamt, fertig: r.fertig }
+            : null;
+    });
+    const offen = k.offen.map(schrittAus);
+    const naechster = k.naechster === null ? null : schrittAus(k.naechster);
+    if (beats.includes(null) || offen.includes(null) || (k.naechster !== null && !naechster))
+        return null;
+    return { beats: beats, offen: offen, naechster, abgeschlossen: k.abgeschlossen };
+}
+/** Reine Rechnung: die Zeilen, die der Mensch (und Claude) zu sehen bekommen. */
+export function kursZeilen(stand, s, basisUrl) {
+    const t = KURS_TEXTE[s];
+    const browser = t.imBrowser(basisUrl);
+    if (stand.abgeschlossen)
+        return [t.alleErledigt(stand.beats.reduce((n, b) => n + b.gesamt, 0)), browser];
+    const beats = stand.beats.map((b) => (b.fertig ? t.beatFertig(b.nummer) : t.beatTeil(b.nummer, b.erledigt, b.gesamt)));
+    const zeilen = [t.uebersicht(beats.join(" · "))];
+    if (stand.naechster)
+        zeilen.push(t.naechster(stand.naechster.text, stand.naechster.wer === "claude"));
+    // Alles Offene ausser dem, was schon als „Als Nächstes“ dasteht -- über die Kennung: Zwei offene Schritte
+    // eines Beats können denselben Text tragen, und nur der eine ist der nächste.
+    const rest = stand.offen.filter((o) => o.id !== stand.naechster?.id);
+    if (rest.length > 0) {
+        zeilen.push(t.nochOffen);
+        rest.forEach((o) => zeilen.push(t.offenZeile(o.beat, o.text, o.wer === "claude")));
+    }
+    zeilen.push(browser);
+    return zeilen;
+}
+/** Wo der Mensch im Mini-Kurs steht -- die Grundlage von `/k3kurs`. */
+export async function kurs() {
+    const antwort = await ruf("/api/cli/kurs", { methode: "GET", mitAusweis: true }); // kein-anzeigetext: HTTP-Methode
+    // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
+    const s = sprache();
+    if (antwort.status === 200) {
+        const stand = standAus(antwort.koerper);
+        if (!stand) {
+            console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+            return 3;
+        }
+        kursZeilen(stand, s, BASIS_URL).forEach((z) => console.log(z));
+        return 0;
+    }
+    const meldung = feld(antwort.koerper, "meldung") ?? ALLGEMEIN_TEXTE[s].genericFailure;
+    if (antwort.status === 401) {
+        console.error(`${meldung}${ALLGEMEIN_TEXTE[s].pleaseSignIn}`);
+        return 2;
+    }
+    const schluss = schlussFehler(antwort.status, meldung, s);
+    console.error(schluss.text);
+    return schluss.wert;
+}

package/dist/befehle/login.js

@@ -5,6 +5,8 @@ import { sprache } from "../sprache.js";
 import { anmeldeAdresse, oeffneImBrowser } from "../browser.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
 import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
+import { frischeCoachAuf } from "../coach-ablegen.js";
+import { frischeLogoAuf } from "../logo-ablegen.js";
 import { stelleSkillUm } from "./skill-tausch.js";
 const warte = (ms) => new Promise((f) => setTimeout(f, ms));
 // 🌐 Die Sprache wird bei JEDER Ausgabe neu gelesen: Die Abhol-Antwort nennt die Kontosprache
@@ -27,7 +29,16 @@ export async function login() {
     console.log(t().loginOpen(BASIS_URL));
     console.log(t().loginEnterCode(start.nutzerCode));
     console.log(t().loginWaiting);
-    return warteAufBestaetigung(start.geraeteCode);
+    const code = await warteAufBestaetigung(start.geraeteCode);
+    // Der Coach zieht mit der Kontosprache mit -- nur beim BEFEHL `kimal3 login`, nicht in der geteilten Warteschleife:
+    // `einrichten` meldet anschließend seinen eigenen Coach, eine zweite Zeile wäre doppelt (Gesamt-Durchsicht, Fund 4;
+    // dasselbe Muster wie `skillInstallBefehl`). Frischt nur auf, legt nie an (Spec C-13b). Das Logo genauso (Spec
+    // 2026-10-18, L-1, L-8): `einrichten` legt es nach der Anmeldung ohnehin selbst ab.
+    if (code === 0) {
+        frischeCoachAuf(sprache());
+        frischeLogoAuf(sprache());
+    }
+    return code;
 }
 /**
  * Die Anmeldung für `kimal3 einrichten` (Spec 2026-10-11, S-2): Code und Adresse auf eigenen

package/dist/befehle/skill-install.js

@@ -9,6 +9,8 @@ import { eigeneVersion } from "../version.js";
 import { sprache } from "../sprache.js";
 import { andereSpracheZuRaeumen, skillQuelle } from "../slash-befehle.js";
 import { SKILL_TEXTE } from "../texte/skill.js";
+import { frischeCoachAuf } from "../coach-ablegen.js";
+import { frischeLogoAuf } from "../logo-ablegen.js";
 export const VERALTETE_BEFEHLE = [
     /*
       🔴 **Der ERSTE Eintrag ueberhaupt** (2026-08-28). `/k3firma` heisst jetzt
@@ -320,6 +322,19 @@ export async function skillInstall() {
     }
     return 0;
 }
+/**
+ * Der Befehl `kimal3 skill install`: die Anleitung ablegen und einen VORHANDENEN Coach mitziehen (Update, Sprachwechsel;
+ * angelegt wird keiner). Bewusst hier und nicht in `skillInstall()`: `einrichten` ruft das auch, hat seinen Coach aber
+ * schon selbst abgelegt und gemeldet -- ein zweites Auffrischen druckte dessen Zeile noch einmal (bei fehlender
+ * Trenn-Marke auch die Ersatzdatei ein zweites Mal). Das Logo zieht genauso mit, nur ein vorhandenes (Spec 2026-10-18,
+ * L-3 bis L-7): `einrichten` legt es selbst ab.
+ */
+export async function skillInstallBefehl() {
+    const code = await skillInstall();
+    frischeCoachAuf(sprache());
+    frischeLogoAuf(sprache());
+    return code;
+}
 /**
  * Kopiert die Slash-Befehle nach `~/.claude/commands/`.
  *

package/dist/befehle/zeigen-einrichten.js

@@ -0,0 +1,104 @@
+import { existsSync } from "node:fs";
+import { dirname, win32 } from "node:path";
+import { zerlege } from "../argumente.js";
+import { AUFNEHMER_FASSUNG, aufnehmerArgumente, einrichtPlan, teileAus, uvEinrichtung, } from "../zeigen-rechnung.js";
+import { LESEN_MS, aufnehmerPython, findeUv, rufeWerkzeug, stillAusfuehren, uvBinOrdner } from "../zeigen-umgebung.js";
+import { vorab } from "./zeigen.js";
+/**
+ * `kimal3 zeigen einrichten` / `kimal3 show setup` (Spec 2026-10-18-k3zeigen-design.md, US-2, Szenarien S-1, S-3, S-15).
+ * Holt in dieser Reihenfolge nur, was fehlt: uv, den Aufnehmer 1.3.0, FFmpeg, das Sprachmodell. Ohne Adminrechte.
+ * 🔴 Kein fremdes Programm spricht hier mit dem Menschen: winget, uv und capture laufen mit `stdio: "ignore"`, vom
+ * Werkzeug zaehlt nur die eine JSON-Zeile. Ob ein Schritt geklappt hat, sagt nie sein Rueckgabewert allein, sondern
+ * die neue Bestandsaufnahme danach -- winget meldet z. B. auch "schon installiert" als Fehler.
+ */
+// Obergrenzen je Schritt: grosszuegig (langsame Leitung), aber nie "haengt fuer immer". Der Slash-Befehl startet
+// `einrichten` im Hintergrund, weil Claude Code einen Werkzeugaufruf nach 10 Minuten abbricht (Spec US-2).
+const MINUTE = 60_000;
+const ZEIT_UV = 15 * MINUTE;
+const ZEIT_AUFNEHMER = 45 * MINUTE;
+const ZEIT_FFMPEG = 15 * MINUTE;
+const ZEIT_MODELL = 60 * MINUTE;
+/** Was jetzt da ist: uv (Suchpfad + bekannte Orte), und vom Aufnehmer selbst, was er hat. */
+function bestand() {
+    const p = aufnehmerPython();
+    return { teile: teileAus(findeUv()?.uv ?? null, p === null ? null : rufeWerkzeug(p, ["teile"], null, LESEN_MS)), umgebungDa: p !== null };
+}
+function richteUvEin() {
+    const { befehl, argumente } = uvEinrichtung(stillAusfuehren("winget", ["--version"], LESEN_MS)); // kein-anzeigetext: Befehl
+    stillAusfuehren(befehl, argumente, ZEIT_UV);
+    // Der Suchpfad dieser Sitzung ist noch der alte: findeUv sieht auch an den bekannten Orten nach.
+    return findeUv() !== null;
+}
+function richteAufnehmerEin(umgebungDa) {
+    const uv = findeUv();
+    if (uv === null)
+        return false;
+    stillAusfuehren(uv.uv, aufnehmerArgumente(umgebungDa), ZEIT_AUFNEHMER);
+    return bestand().teile.aufnehmer === AUFNEHMER_FASSUNG;
+}
+function richteFfmpegEin() {
+    const uv = findeUv();
+    const p = aufnehmerPython();
+    if (uv === null || p === null)
+        return false;
+    const bin = uvBinOrdner(uv.uv);
+    // `capture.exe` liegt im Programmordner von uv und neben dem Python des Aufnehmers; der erste, den es gibt.
+    const capture = [bin === null ? null : win32.join(bin, "capture.exe"), win32.join(dirname(p.python), "capture.exe")] // kein-anzeigetext: Dateiname
+        .find((d) => d !== null && existsSync(d));
+    if (capture === undefined)
+        return false;
+    stillAusfuehren(capture, ["install-ffmpeg"], ZEIT_FFMPEG); // kein-anzeigetext: Befehl
+    return bestand().teile.ffmpeg;
+}
+function richteModellEin() {
+    const p = aufnehmerPython();
+    if (p === null)
+        return false;
+    const r = rufeWerkzeug(p, ["modell-laden"], null, ZEIT_MODELL); // kein-anzeigetext: Befehl
+    return r.ok && (r.daten.ergebnis === "da" || r.daten.ergebnis === "geladen");
+}
+function zeile(t, schritt) {
+    if (schritt === "uv")
+        return t.schrittUv;
+    if (schritt === "aufnehmer")
+        return t.schrittAufnehmer(AUFNEHMER_FASSUNG);
+    return schritt === "ffmpeg" ? t.schrittFfmpeg : t.schrittModell;
+}
+export async function zeigenEinrichten(rest) {
+    const lage = vorab(rest, (t) => t.helpEinrichten);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const z = zerlege(rest, [], s);
+    if (!z.ok) {
+        console.error(`${z.meldung}\n${t.helpEinrichten}`);
+        return 1;
+    }
+    const anfang = bestand();
+    const plan = einrichtPlan(anfang.teile);
+    if (plan.length === 0) {
+        console.log(t.allesDa(AUFNEHMER_FASSUNG));
+        return 0;
+    }
+    for (const schritt of plan) {
+        // FFmpeg und Modell erst nach einem neuen Blick: Ein frisch eingerichteter Aufnehmer findet z. B. ein FFmpeg im Suchpfad.
+        if ((schritt === "ffmpeg" || schritt === "modell") && bestand().teile[schritt])
+            continue;
+        console.log(zeile(t, schritt));
+        const geklappt = schritt === "uv" ? richteUvEin()
+            : schritt === "aufnehmer" ? richteAufnehmerEin(anfang.umgebungDa)
+                : schritt === "ffmpeg" ? richteFfmpegEin() : richteModellEin();
+        if (!geklappt) {
+            console.error(t.nichtGeklappt(schritt));
+            return 1;
+        }
+    }
+    // Die Schlussmeldung nur, wenn die Bestandsaufnahme danach wirklich alle vier zeigt -- nie aus dem Plan geschlossen.
+    const offen = einrichtPlan(bestand().teile);
+    if (offen.length > 0) {
+        console.error(t.nichtGeklappt(offen[0]));
+        return 1;
+    }
+    console.log(t.fertigEingerichtet(AUFNEHMER_FASSUNG));
+    return 0;
+}

package/dist/befehle/zeigen-start.js

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { trenneNamenUndOptionen, zerlege } from "../argumente.js";
+import { einrichtPlan, fehlerGrund } from "../zeigen-rechnung.js";
+import { LESEN_MS, aufnehmerPython, leseStarter, rufeWerkzeug, schreibeNotiz, starteStarter, starterFakt, uvFassung } from "../zeigen-umgebung.js";
+import { ermittleZustand, grundSatz, gueltigeFassung, ortHier, uhrzeit, vorab, zeigeOrdner } from "./zeigen.js";
+/**
+ * `kimal3 zeigen start "<Satz>" [--hoechstens N]` (Spec US-3, US-4, US-5). Reihenfolge: Ort -> laeuft schon etwas? ->
+ * eingerichtet? -> Ordner -> Starter abgehaengt -> warten, bis er "laeuft, Sitzung …" meldet.
+ * 🔴 Der Satz geht nur nach `aufgabe.txt`, nie an den Aufnehmer (dessen Befehlszeile zerlegt ihn, Spec US-4).
+ * 🔴 Scheitert der Start, zieht `start` die Bremse (`abbrechen`) und wartet, bis der Starter das Ende bestaetigt -- ein
+ * Fehlschlag darf keinen Aufnehmer zuruecklassen. Gemeldet wird nur ein fester Grund und der Pfad zum Protokoll.
+ */
+const HOECHSTENS_VORGABE = 15;
+const TAKT_MS = 500;
+const WARTEN_START_MS = 60_000; // der Aufnehmer selbst wartet bis 60 s auf seine Bereitschaft
+const WARTEN_ENDE_MS = 25_000; // R-14, Punkt 4: Wegraeumen samt Nachtoeten braucht laenger als 15 s
+const warte = (ms) => new Promise((fertig) => setTimeout(fertig, ms));
+const laeuftNoch = (zustand) => zustand === "startet" || zustand === "laeuft";
+/** Bis `fertig` den Bericht des Starters annimmt (oder die Zeit um ist); der letzte gelesene Bericht. */
+async function warteAufStarter(ordner, ms, fertig) {
+    const bis = Date.now() + ms;
+    let fakt = starterFakt(leseStarter(ordner));
+    while (!fertig(fakt) && Date.now() < bis) {
+        await warte(TAKT_MS);
+        fakt = starterFakt(leseStarter(ordner));
+    }
+    return fakt;
+}
+function legeOrdnerAn(t, aufnahmen, ordner, anzeige) {
+    try {
+        mkdirSync(aufnahmen, { recursive: true });
+        // Git UND Claudes Dateisuche fernhalten (Spec US-3); nur anlegen, was fehlt.
+        for (const name of [".gitignore", ".ignore"]) {
+            const datei = join(aufnahmen, name);
+            if (!existsSync(datei))
+                writeFileSync(datei, "*\n", "utf8");
+        }
+        mkdirSync(ordner); // ohne `recursive`: Gibt es ihn schon, war ein zweiter Start schneller (Review Focus 4)
+        return null;
+    }
+    catch (e) {
+        return e.code === "EEXIST" ? t.startetGerade(anzeige) : t.ordnerNichtAnlegbar(ordner);
+    }
+}
+export async function zeigenStart(rest) {
+    const lage = vorab(rest, (t) => t.helpStart);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const { woerter, optionen } = trenneNamenUndOptionen(rest);
+    const satz = woerter.join(" ").trim();
+    const z = zerlege(optionen, ["hoechstens"], s);
+    if (!z.ok || satz === "") {
+        console.error(`${z.ok ? t.satzFehlt : z.meldung}\n${t.helpStart}`);
+        return 1;
+    }
+    const roh = z.werte.optionen.hoechstens ?? String(HOECHSTENS_VORGABE);
+    const minuten = /^\d+$/.test(roh) ? Number(roh) : NaN;
+    if (!(minuten >= 1 && minuten <= HOECHSTENS_VORGABE)) {
+        console.error(t.hoechstensFalsch(roh));
+        return 1;
+    }
+    const jetzt = new Date();
+    const ort = ortHier(jetzt);
+    if (ort.art !== "ort") {
+        console.error(ort.art === "werkbank" ? t.ortWerkbank : t.ortZuLang(ort.laenge, ort.hoechstens));
+        return 1;
+    }
+    const p = aufnehmerPython();
+    if (p !== null) {
+        const { zustand } = ermittleZustand(p, ort, jetzt.getTime() / 1000);
+        if (zustand.art === "unbekannt") {
+            console.error(t.unbekanntKeinStart);
+            return 1;
+        }
+        if (zustand.art === "laeuft") {
+            const bekannt = !zustand.fremd && zustand.gestartet !== null && zustand.ordner !== null;
+            console.error(bekannt ? t.schonLaeuft(uhrzeit(zustand.gestartet), zeigeOrdner(zustand.ordner, ort)) : t.schonLaeuftFremd);
+            return 1;
+        }
+    }
+    const teile = p === null ? null : rufeWerkzeug(p, ["teile"], null, LESEN_MS);
+    const fehlt = !teile?.ok || einrichtPlan({
+        uv: uvFassung(),
+        aufnehmer: gueltigeFassung(teile.daten.aufnehmer),
+        ffmpeg: teile.daten.ffmpeg === true,
+        modell: teile.daten.modell === true,
+    }).length > 0;
+    if (p === null || fehlt) {
+        console.error(t.nichtEingerichtet);
+        return 1;
+    }
+    const ordner = ort.ordner;
+    const anzeige = zeigeOrdner(ordner, ort);
+    const absage = legeOrdnerAn(t, ort.aufnahmen, ordner, anzeige);
+    if (absage !== null) {
+        console.error(absage);
+        return 1;
+    }
+    const konfig = join(ordner, "konfig.json"); // kein-anzeigetext: Dateiname
+    try {
+        writeFileSync(join(ordner, "aufgabe.txt"), satz, "utf8"); // kein-anzeigetext: Dateiname
+        writeFileSync(konfig, JSON.stringify({ ordner, hoechstens_sek: minuten * 60 }), "utf8");
+    }
+    catch {
+        console.error(t.ordnerNichtAnlegbar(ordner));
+        return 1;
+    }
+    const protokoll = join(ordner, "aufnahme.log"); // kein-anzeigetext: Dateiname
+    let bericht = starteStarter(p, konfig, ordner)
+        ? await warteAufStarter(ordner, WARTEN_START_MS, (f) => (f?.zustand === "laeuft" && f.sitzung !== undefined) || (f !== null && !laeuftNoch(f.zustand)))
+        : null;
+    const lauf = leseStarter(ordner);
+    if (bericht?.zustand === "laeuft" && bericht.sitzung !== undefined && typeof lauf?.gestartet === "number" && typeof lauf.frist === "number") {
+        schreibeNotiz({ sitzung: bericht.sitzung, ordner, gestartet: lauf.gestartet, frist: lauf.frist });
+        console.log(t.laeuftJetzt(anzeige, uhrzeit(lauf.frist)));
+        return 0;
+    }
+    // Nicht gestartet: Bremse ziehen und auf die Bestaetigung warten, dass nichts weiterlaeuft.
+    try {
+        writeFileSync(join(ordner, "abbrechen"), "", "utf8"); // kein-anzeigetext: Dateiname
+    }
+    catch {
+        /* ohne Bremse meldet unten "nicht bestaetigt" */
+    }
+    bericht = await warteAufStarter(ordner, WARTEN_ENDE_MS, (f) => f !== null && !laeuftNoch(f.zustand));
+    const grund = bericht?.grund ?? fehlerGrund(liesProtokoll(protokoll));
+    console.error(t.nichtGestartet(grundSatz(t, grund), protokoll));
+    // Ohne Bericht (Starter nie angelaufen) ist das Ende genauso wenig bestaetigt wie bei "laeuft noch".
+    if (bericht === null || laeuftNoch(bericht.zustand) || bericht.grund === "nicht-beendet")
+        console.error(t.endeUnbestaetigt);
+    return 1;
+}
+/** Nur fuer `fehlerGrund` -- das Protokoll traegt Fenstertitel und wird nie gezeigt. */
+function liesProtokoll(pfad) {
+    try {
+        return readFileSync(pfad, "utf8");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/befehle/zeigen.js

@@ -0,0 +1,288 @@
+import { existsSync } from "node:fs";
+import { platform } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { schalterOhneWert, trenneNamenUndOptionen, zerlege } from "../argumente.js";
+import { sprache } from "../sprache.js";
+import { ZEIGEN_TEXTE } from "../texte/zeigen.js";
+import { AUFNEHMER_FASSUNG, aufnahmeOrt, aufnahmeZustand, bildName, dauerText, gueltigeFassung, starterLebt, stoppAusgang, zeitAusText, zustandOhneAufnehmer, } from "../zeigen-rechnung.js";
+import { LESEN_MS, STOPPEN_MS, aufnehmerPython, juengsterOrdner, leseNotiz, leseStarter, loescheNotiz, rufeWerkzeug, starterFakt, uvFassung, } from "../zeigen-umgebung.js";
+/** `--help` (auch auf dem Mac), dann die Plattform. Eine Zahl = fertig, sonst die Lage fuer den Befehl. */
+export function vorab(rest, hilfe) {
+    const s = sprache();
+    const t = ZEIGEN_TEXTE[s];
+    if (rest.includes("--help") || rest.includes("-h")) {
+        console.log(hilfe(t));
+        return 0;
+    }
+    if (platform() !== "win32") {
+        console.error(t.nurWindows);
+        return 1;
+    }
+    return { s, t };
+}
+export const sekundenJetzt = () => Date.now() / 1000;
+export const ortHier = (jetzt) => aufnahmeOrt(process.cwd(), jetzt, platform(), existsSync);
+/** Ein Aufnahmeordner zum Zeigen: im Projekt relativ mit `/` (`material/aufnahmen/…`), sonst der volle Pfad. */
+export function zeigeOrdner(ordner, ort) {
+    if (ort.art !== "ort")
+        return ordner;
+    const rel = relative(dirname(dirname(ort.aufnahmen)), ordner);
+    return rel === "" || rel.startsWith("..") || isAbsolute(rel) ? ordner : rel.split("\\").join("/");
+}
+/** Epochensekunden -> "09:12" in Ortszeit. */
+export function uhrzeit(sek) {
+    const d = new Date(sek * 1000);
+    return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+/** Ein Code vom Werkzeug -> fester Satz. Was nicht in `gruende` steht, wird nie gezeigt, sondern `unbekannt` (R-14, Punkt 9). */
+export function grundSatz(t, code) {
+    return typeof code === "string" && Object.hasOwn(t.gruende, code) ? t.gruende[code] : t.gruende.unbekannt;
+}
+/** Wohnt seit Task 5 in `zeigen-rechnung.ts` (auch `einrichten` braucht sie); hier weitergereicht fuer `start`. */
+export { gueltigeFassung };
+const istZahl = (w) => typeof w === "number" && Number.isFinite(w);
+const istZaehlung = (w) => istZahl(w) && Number.isInteger(w) && w >= 0;
+/**
+ * Welcher Ordner gehoert zur Frage? Die Notiz zuerst, sonst die juengste Aufnahme im Projekt. Eine Notiz, deren Ordner
+ * es nicht mehr gibt, zaehlt nicht (`veraltet`): Ein Aufnehmer, der noch schreibt, haelt seinen Ordner fest.
+ */
+function ordnerZurFrage(ort) {
+    const gelesen = leseNotiz();
+    const notiz = gelesen !== null && existsSync(gelesen.ordner) ? gelesen : null;
+    const kandidat = notiz?.ordner ?? (ort.art === "ort" ? juengsterOrdner(ort.aufnahmen) : null);
+    return { ordner: kandidat !== null && existsSync(kandidat) ? kandidat : null, notiz, veraltet: gelesen !== null && notiz === null };
+}
+/** Die aktiven Sitzungen aus einer `zustand`-Antwort; `null` = weiss nicht. */
+function aktiveAus(r) {
+    const liste = r.ok ? r.daten.aktive_sitzungen : null;
+    return Array.isArray(liste) && liste.every((x) => typeof x === "string") ? liste : null;
+}
+/**
+ * Laeuft eine Aufnahme? Mit dem Python des Aufnehmers fragt `zustand` ihn selbst; ohne zaehlen nur Notiz und Starter
+ * (Ruling R-13, `zustandOhneAufnehmer`).
+ */
+export function ermittleZustand(p, ort, jetzt) {
+    const { ordner, notiz } = ordnerZurFrage(ort);
+    const starterImNotizOrdner = notiz !== null && ordner === notiz.ordner;
+    if (p === null) {
+        const starter = ordner === null ? null : starterFakt(leseStarter(ordner));
+        return { zustand: zustandOhneAufnehmer({ notiz, starter, starterImNotizOrdner }, jetzt), ordner };
+    }
+    const r = rufeWerkzeug(p, ["zustand", ordner ?? "-"], ordner, LESEN_MS);
+    const starter = r.ok ? starterFakt(r.daten.starter) : null;
+    return { zustand: aufnahmeZustand({ aktiveSitzungen: aktiveAus(r), notiz, starter, starterImNotizOrdner }, jetzt), ordner };
+}
+// ── status ────────────────────────────────────────────────────────────────────────────────────────────────────────
+export async function zeigenStatus(rest) {
+    const lage = vorab(rest, (t) => t.helpStatus);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const z = zerlege(rest, [], s);
+    if (!z.ok) {
+        console.error(`${z.meldung}\n${t.helpStatus}`);
+        return 1;
+    }
+    const jetzt = new Date();
+    const ort = ortHier(jetzt);
+    const p = aufnehmerPython();
+    const uv = uvFassung();
+    const zeilen = [t.eingerichtet, uv === null ? t.uvFehlt : t.uvDa(uv)];
+    const teile = p === null ? null : rufeWerkzeug(p, ["teile"], null, LESEN_MS);
+    if (p === null)
+        zeilen.push(t.aufnehmerFehlt, t.teilUngeprueft("ffmpeg"), t.teilUngeprueft("modell"));
+    else if (!teile?.ok)
+        zeilen.push(t.teilUnbekannt("aufnehmer"), t.teilUnbekannt("ffmpeg"), t.teilUnbekannt("modell"));
+    else {
+        const roh = teile.daten.aufnehmer;
+        const f = gueltigeFassung(roh);
+        zeilen.push(roh === null ? t.aufnehmerFehlt
+            : f === null ? t.teilUnbekannt("aufnehmer")
+                : f === AUFNEHMER_FASSUNG ? t.aufnehmerDa(f) : t.aufnehmerAlt(f, AUFNEHMER_FASSUNG));
+        zeilen.push(t.ffmpeg(teile.daten.ffmpeg === true), t.modell(teile.daten.modell === true));
+    }
+    const { zustand, ordner } = ermittleZustand(p, ort, jetzt.getTime() / 1000);
+    let code = 0;
+    zeilen.push(t.aufnahme);
+    if (zustand.art === "unbekannt") {
+        zeilen.push(`  ${t.unbekannt}`);
+        code = 1;
+    }
+    else if (zustand.art === "laeuft") {
+        const { gestartet, frist } = zustand;
+        if (zustand.fremd || gestartet === null || frist === null || zustand.ordner === null)
+            zeilen.push(t.laeuftFremd);
+        else {
+            const minuten = Math.max(0, Math.floor(jetzt.getTime() / 60000 - gestartet / 60));
+            zeilen.push(t.laeuftSeit(uhrzeit(gestartet), minuten, zeigeOrdner(zustand.ordner, ort), uhrzeit(frist)));
+        }
+    }
+    else {
+        zeilen.push(t.keineLaeuft);
+        const roh = ordner === null ? null : leseStarter(ordner);
+        if (ordner !== null && zustand.letzte === "selbst-gestoppt") {
+            const min = istZahl(roh?.frist) && istZahl(roh?.gestartet) ? Math.round((roh.frist - roh.gestartet) / 60) : 15;
+            zeilen.push(t.letzteSelbst(zeigeOrdner(ordner, ort), min));
+        }
+        if (ordner !== null && zustand.letzte === "abgebrochen")
+            zeilen.push(t.letzteAbgebrochen(zeigeOrdner(ordner, ort)));
+    }
+    if (ort.art === "ort")
+        zeilen.push(t.ortHier(ort.aufnahmen));
+    else
+        zeilen.push(ort.art === "werkbank" ? t.ortWerkbank : t.ortZuLang(ort.laenge, ort.hoechstens));
+    console.log(zeilen.join("\n"));
+    return code;
+}
+// ── stopp ─────────────────────────────────────────────────────────────────────────────────────────────────────────
+export async function zeigenStopp(rest) {
+    const lage = vorab(rest, (t) => t.helpStopp);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const z = zerlege(rest, [], s);
+    if (!z.ok) {
+        console.error(`${z.meldung}\n${t.helpStopp}`);
+        return 1;
+    }
+    const ort = ortHier(new Date());
+    const { ordner, notiz, veraltet } = ordnerZurFrage(ort);
+    if (veraltet)
+        loescheNotiz(); // ihr Ordner ist weg: die Notiz zeigt ins Leere
+    const p = aufnehmerPython();
+    // Eigene Aufnahme = eine Notiz, oder ein Starter, der noch "startet"/"laeuft" sagt. Eine alte, laengst gestoppte
+    // Aufnahme ohne Notiz ist keine laufende.
+    const starter = ordner === null ? null : starterFakt(leseStarter(ordner));
+    const eigene = ordner !== null && (notiz !== null || starter?.zustand === "startet" || starter?.zustand === "laeuft");
+    if (!eigene) {
+        // R-13: ohne Aufnehmer kann nichts laufen, was kimal3 gestartet hat. Mit ihm fragen, ob eine FREMDE laeuft (Review, Punkt 2).
+        const aktive = p === null ? [] : aktiveAus(rufeWerkzeug(p, ["zustand", "-"], null, LESEN_MS));
+        if (aktive === null)
+            console.error(t.unbekannt);
+        else if (aktive.length > 0)
+            console.error(t.fremdLaeuft);
+        else
+            console.log(t.keineAufnahmeLaeuft);
+        return aktive?.length === 0 ? 0 : 1;
+    }
+    if (p === null) {
+        // Eine eigene Aufnahme ist bekannt, der Aufnehmer aber nicht zu finden: stoppen kann ich nicht, "keine" waere gelogen.
+        console.error(t.stoppUnklar);
+        return 1;
+    }
+    const r = rufeWerkzeug(p, ["stoppen", ordner], ordner, STOPPEN_MS);
+    const d = r.ok ? r.daten : {};
+    const zahlen = istZahl(d.dauer_sek) && istZaehlung(d.klicks) && istZaehlung(d.tasten) && typeof d.ton === "boolean"
+        ? t.zahlen(dauerText(d.dauer_sek), d.klicks, d.tasten, d.ton) : null;
+    const ausgang = stoppAusgang(d.ergebnis, zahlen !== null);
+    // Werkzeug stumm, unlesbar oder noch beim Abschliessen: nichts ist bestaetigt -- die Notiz bleibt, damit status und
+    // der naechste stopp die Aufnahme weiter finden (Endpruefung, Punkt 2).
+    if (ausgang.notizWeg && notiz?.ordner === ordner)
+        loescheNotiz();
+    const roh = leseStarter(ordner);
+    const min = istZahl(roh?.frist) && istZahl(roh?.gestartet) ? Math.round((roh.frist - roh.gestartet) / 60) : 15;
+    const satz = {
+        keine: t.keineAufnahmeLaeuft,
+        gestoppt: t.gestoppt(zahlen ?? ""),
+        "selbst-gestoppt": t.selbstGestoppt(min, zahlen ?? ""),
+        "nicht-sauber": t.nichtSauber(grundSatz(t, d.grund)),
+        abgebrochen: t.abgebrochen(grundSatz(t, d.grund), zahlen),
+        "wird-abgeschlossen": t.wirdAbgeschlossen,
+        unklar: t.stoppUnklar,
+    }[ausgang.satz];
+    (ausgang.code === 0 ? console.log : console.error)(satz);
+    return ausgang.code;
+}
+// ── auswerten und bild: der Aufnahmeordner ───────────────────────────────────────────────────────────────────────
+/** Der genannte oder der juengste Aufnahmeordner, der nicht mehr laeuft -- sonst ein Satz auf stderr und `null`. */
+function fertigerOrdner(t, genannt, ort) {
+    const ordner = genannt !== undefined ? resolve(genannt) : ort.art === "ort" ? juengsterOrdner(ort.aufnahmen) : null;
+    if (ordner === null)
+        console.error(t.keineAufnahmeHier);
+    else if (!existsSync(ordner))
+        console.error(t.ordnerFehlt(ordner));
+    // Nur ein LEBENDER Starter blockiert (R-3): ein toter mit stehengebliebenem "laeuft" gilt als abgebrochen (Review, Punkt 3).
+    else if (starterLebt(starterFakt(leseStarter(ordner)), sekundenJetzt()))
+        console.error(t.laeuftNoch);
+    else
+        return ordner;
+    return null;
+}
+export async function zeigenAuswerten(rest) {
+    const lage = vorab(rest, (t) => t.helpAuswerten);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const ohne = schalterOhneWert(rest, "ohne-getipptes");
+    const { woerter, optionen } = trenneNamenUndOptionen(ohne.rest);
+    const z = zerlege([...woerter.slice(1), ...optionen], ["sprache"], s);
+    if (!z.ok) {
+        console.error(`${z.meldung}\n${t.helpAuswerten}`);
+        return 1;
+    }
+    const erkennung = z.werte.optionen.sprache ?? s;
+    if (erkennung !== "de" && erkennung !== "en") {
+        console.error(t.spracheFalsch(erkennung));
+        return 1;
+    }
+    const ort = ortHier(new Date());
+    const ordner = fertigerOrdner(t, woerter[0], ort);
+    if (ordner === null)
+        return 1;
+    const p = aufnehmerPython();
+    if (p === null) {
+        console.error(t.nichtEingerichtet);
+        return 1;
+    }
+    console.log(t.werteAus);
+    const r = rufeWerkzeug(p, ["zeitleiste", ordner, erkennung, ...(ohne.gesetzt ? ["--ohne-getipptes"] : [])], ordner, null);
+    const d = r.ok ? r.daten : {};
+    const datei = join(ordner, "zeitleiste.md"); // kein-anzeigetext: Dateiname
+    if (d.ergebnis === "fertig" && istZahl(d.dauer_sek) && [d.saetze, d.klicks, d.tippstellen, d.passwortfelder].every(istZaehlung) && existsSync(datei)) {
+        const n = (w) => w;
+        console.log(t.zeitleisteFertig(dauerText(d.dauer_sek), n(d.saetze), n(d.klicks), n(d.tippstellen), n(d.passwortfelder), zeigeOrdner(datei, ort)));
+        return 0;
+    }
+    if (d.ergebnis === "keine-sprache")
+        console.error(t.keineSprache);
+    else if (d.ergebnis === "kein-ton")
+        console.error(t.keinTon);
+    else
+        console.error(t.zeitleisteFehler(grundSatz(t, d.grund)));
+    return 1;
+}
+export async function zeigenBild(rest) {
+    const lage = vorab(rest, (t) => t.helpBild);
+    if (typeof lage === "number")
+        return lage;
+    const { s, t } = lage;
+    const { woerter, optionen } = trenneNamenUndOptionen(rest);
+    const z = zerlege([...woerter.slice(2), ...optionen], [], s);
+    if (!z.ok || woerter.length === 0) {
+        console.error(`${z.ok ? "" : `${z.meldung}\n`}${t.helpBild}`);
+        return 1;
+    }
+    const sekunden = zeitAusText(woerter[0]);
+    if (sekunden === null) {
+        console.error(t.zeitFalsch(woerter[0]));
+        return 1;
+    }
+    const ort = ortHier(new Date());
+    const ordner = fertigerOrdner(t, woerter[1], ort);
+    if (ordner === null)
+        return 1;
+    const p = aufnehmerPython();
+    if (p === null) {
+        console.error(t.nichtEingerichtet);
+        return 1;
+    }
+    const r = rufeWerkzeug(p, ["bild", ordner, String(sekunden)], ordner, null);
+    // Der Pfad wird hier gebaut, nicht vom Werkzeug uebernommen -- und muss danach wirklich daliegen.
+    const datei = join(ordner, "bilder", bildName(sekunden)); // kein-anzeigetext: Ordnername
+    if (r.ok && r.daten.ergebnis === "fertig" && existsSync(datei)) {
+        console.log(t.bildFertig(datei));
+        return 0;
+    }
+    console.error(t.bildFehler(grundSatz(t, r.ok ? r.daten.grund : null)));
+    return 1;
+}