kimal3 0.4.0 → 0.6.0

package/README.md

@@ -42,8 +42,12 @@ kimal3 kontext fragen     Die Fragen über deine Firma beantworten — Claude f
 kimal3 kontext hoch       Deine lokalen Änderungen an den fünf Firmen-Texten hochschicken
 kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
 kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
+kimal3 plan               Planung hochladen oder Rückmeldungen holen
+kimal3 plan hoch          Die Planung aus plan/stand.json hochschicken (--probe: nur prüfen)
 kimal3 kurs               Zeigen, wo du im Mini-Kurs stehst
 kimal3 firma daten        Die Daten deiner Firma holen, damit Claude sie auswerten kann
+kimal3 zeigen start       Eine Aufnahme starten, während du eine Aufgabe vormachst
+kimal3 zeigen status      Nachsehen, ob gerade aufgenommen wird und ob der Aufnehmer eingerichtet ist
 kimal3 wache              Läuft von selbst beim Start von Claude: prüft Zugang, Nachricht, Version, Skill
 kimal3 wache aus          Die tägliche Prüfung abschalten — sie sagt dann nichts mehr
 kimal3 wache an           Sie wieder einschalten
@@ -180,8 +184,12 @@ kimal3 context questions  Answer the questions about your company — Claude tak
 kimal3 context upload     Upload your local changes to the five company texts
 kimal3 project new …      Add a project to your success profile
 kimal3 project list       Show the projects you've added
+kimal3 plan               Upload planning or fetch responses
+kimal3 plan upload        Upload the planning in plan/stand.json (--dry-run: only check)
 kimal3 course             Show where you are in the mini-course
 kimal3 company data       Fetch your company's data so Claude can analyse it
+kimal3 show start         Start a recording while you show a task
+kimal3 show status        Check whether a recording is running and whether the recorder is set up
 kimal3 watch              Runs by itself when Claude starts: checks your access, messages, version and skill
 kimal3 watch off          Switch the daily check off — it then says nothing at all
 kimal3 watch on           Switch it back on

package/coach/de/kimal3-coach.md

@@ -118,8 +118,8 @@ nutze sie, statt vorschnell loszulegen.
   Beispiel Node.js: `winget install OpenJS.NodeJS.LTS` / `brew install node`. Fehlt Homebrew, frag vorher: Es
   einzurichten braucht einmal das Administrator-Passwort.
   **Ohne Adminrechte** (oft am Firmenrechner) geht das nicht. Dann kommt das Werkzeug nur für dieses Konto in den
-  Benutzerordner, so wie `kimal3 einrichten` Node.js anlegt; sag dazu, dass es dann nicht mit `upgrade` mitkommt, und
-  biete eine Nachricht an die IT an.
+  Benutzerordner, so wie die kimal3-Einrichtungsanleitung Node.js ohne Adminrechte nach `~/.kimal3/node` legt; sag dazu, dass es
+  dann nicht mit `upgrade` mitkommt, und biete eine Nachricht an die IT an.
   **Ist ein Werkzeug schon da, aktualisiere es auf dem Weg, auf dem es gekommen ist** — sonst liegen zwei Fassungen
   nebeneinander, und es ist unklar, welche startet.
 - **Aktualisieren nach der Versionsnummer** (`16.2.10`): **letzte Zahl** = nur Fehler und Sicherheitslücken, zügig

package/coach/en/kimal3-coach.md

@@ -118,8 +118,8 @@ use them instead of starting off too quickly.
   Example Node.js: `winget install OpenJS.NodeJS.LTS` / `brew install node`. If Homebrew is missing, ask first:
   setting it up needs the administrator password once.
   **Without admin rights** (often on a company computer) this does not work. Then the tool goes into the user folder,
-  for this account only, the way `kimal3 setup` sets up Node.js; say that it will then not come along with `upgrade`,
-  and offer a message to IT.
+  for this account only, the way the kimal3 setup guide puts Node.js into `~/.kimal3/node` without admin rights; say that it
+  will then not come along with `upgrade`, and offer a message to IT.
   **If a tool is already there, update it the way it came** — otherwise two versions sit side by side, and it is
   unclear which one starts.
 - **Update by version number** (`16.2.10`): **last number** = only bugs and security holes, take it

package/dist/befehle/einrichten.js

@@ -314,7 +314,7 @@ function pluginsEinrichten(git) {
     // Ohne Logo-Ordner kommt superpowers trotzdem (Durchsicht 2, Fund 1): eine Zeile zum Logo, dann weiter.
     if (!ablage.ok)
         console.log(t.logoNotWritten(ablage.detail));
-    if (ablage.ok && ablage.alterStand)
+    if (ablage.ok && ablage.stand === "alt")
         console.log(t.logoOldVersion);
     // Schrägstriche vorwärts: So steht der Pfad in Claudes Einstellungen auf jedem System gleich (P-13).
     const eintrag = tragePluginsEin(ablage.ok ? ablage.ordner.replace(/\\/g, "/") : null, git);

package/dist/befehle/login.js

@@ -6,6 +6,7 @@ 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
@@ -31,9 +32,12 @@ export async function login() {
     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).
-    if (code === 0)
+    // 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;
 }
 /**

package/dist/befehle/plan-hoch.js

@@ -0,0 +1,114 @@
+import { feld, ruf } from "../api.js";
+import { schalterOhneWert, zerlege } from "../argumente.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { PLAN_TEXTE } from "../texte/plan.js";
+import { leseSpecTexte, schreibeNachHochladen, specKoepfeAus } from "../plan-datei.js";
+import { planAbsage, planDateiOderAbsage } from "./plan.js";
+const istZahl = (w) => typeof w === "number" && Number.isInteger(w) && w >= 0;
+function hochgeladenAus(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    if (k.probe === true)
+        return null;
+    if (typeof k.projektId !== "string" || typeof k.titel !== "string" || typeof k.adresse !== "string" || typeof k.hochgeladenAm !== "string")
+        return null;
+    if (!istZahl(k.stories) || !istZahl(k.deinTest))
+        return null;
+    return { projektId: k.projektId, titel: k.titel, stories: k.stories, deinTest: k.deinTest, adresse: k.adresse, hochgeladenAm: k.hochgeladenAm, specTexte: istZahl(k.specTexte) ? k.specTexte : null };
+}
+function probeAus(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    return k.probe === true && istZahl(k.stories) && istZahl(k.uebernommen) ? { stories: k.stories, uebernommen: k.uebernommen, specTexte: istZahl(k.specTexte) ? k.specTexte : null } : null;
+}
+/**
+ * Die Zeile aus US-16. `angekommen` kommt aus der Antwort des Servers (Eintraege mit Text), nicht aus dem, was
+ * die CLI geschickt hat: Eine alte App ohne das Feld antwortet ohne Zahl, und dann steht hier lieber keine Zeile
+ * als eine, die ein Hochladen behauptet, das nicht stattgefunden hat.
+ */
+function specTexteZeile(angekommen, gesamt, ohne, s) {
+    if (angekommen === null)
+        return null;
+    const t = PLAN_TEXTE[s];
+    return t.specTexte(angekommen, gesamt, ohne.map((o) => t.specTextOhneEintrag(o.titel, t.specTextOhneGrund(o.grund, o.pfad))));
+}
+export async function planHoch(argv) {
+    let s = sprache();
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(PLAN_TEXTE[s].uploadHelp);
+        return 0;
+    }
+    // ⚠️ `zerlege` kennt keine Schalter ohne Wert -- beide VOR der Zerlegung heraus, wie `--ueberschreiben` in kontext-hoch.ts.
+    // Was danach uebrig bleibt, ist ein Tippfehler: `zerlege` ohne erlaubte Optionen sagt dazu den passenden Satz.
+    const ueber = schalterOhneWert(argv, "ueberschreiben");
+    const probe = schalterOhneWert(ueber.rest, "probe");
+    const zerlegt = zerlege(probe.rest, [], s);
+    if (!zerlegt.ok) {
+        console.error(zerlegt.meldung);
+        return 1;
+    }
+    const datei = planDateiOderAbsage(s);
+    if (datei === null)
+        return 1;
+    const hatteNummer = typeof datei.json.projekt_id === "string";
+    // Der Text der Specs geht im selben Aufruf mit (US-16); pro Spec liegt entweder der Text oder der Grund vor.
+    const koepfe = specKoepfeAus(datei.json);
+    // Eine Funktion baut den Rumpf: an ihm misst `leseSpecTexte` die 4 MB, und genau er geht hinaus (US-16).
+    const rumpf = (specTexte) => ({ stand: datei.text, ueberschreiben: ueber.gesetzt, probe: probe.gesetzt, specTexte });
+    const texte = leseSpecTexte(process.cwd(), koepfe, rumpf);
+    const antwort = await ruf("/api/cli/projekt/plan", {
+        methode: "POST", // kein-anzeigetext: HTTP-Verb
+        mitAusweis: true,
+        koerper: rumpf(texte.eintraege),
+    });
+    // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
+    s = sprache();
+    const t = PLAN_TEXTE[s];
+    if (antwort.status !== 200) {
+        const code = planAbsage(antwort, s);
+        // Ruling 10: `503 teilweise` -- gespeichert, aber die Rueckmeldungen noch nicht markiert. `basis` muss trotzdem
+        // nachgetragen werden, sonst lehnt der zweite Lauf als „veraltet" ab; `uebernommen` bleibt fuer genau diesen Lauf stehen.
+        // Fehlen Nummer oder Zeitpunkt in der Antwort, wird nichts geschrieben (geraten wird hier nie).
+        const projektId = feld(antwort.koerper, "projektId"); // kein-anzeigetext: Feldname der Antwort
+        const hochgeladenAm = feld(antwort.koerper, "hochgeladenAm"); // kein-anzeigetext: Feldname der Antwort
+        if (antwort.status === 503 && feld(antwort.koerper, "grund") === "teilweise" && projektId !== null && hochgeladenAm !== null &&
+            !schreibeNachHochladen(process.cwd(), projektId, hochgeladenAm, false)) {
+            console.error(t.writeBackFailed(projektId, hochgeladenAm, false));
+        }
+        return code;
+    }
+    if (probe.gesetzt) {
+        const p = probeAus(antwort.koerper);
+        if (p === null) {
+            console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+            return 3;
+        }
+        console.log(t.dryRun(p.stories, p.uebernommen));
+        const zeile = specTexteZeile(p.specTexte, koepfe.length, texte.ohne, s);
+        if (zeile !== null)
+            console.log(zeile);
+        return 0;
+    }
+    const h = hochgeladenAus(antwort.koerper);
+    if (h === null) {
+        console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+        return 3;
+    }
+    // Erst sagen, was oben angekommen ist, dann, was daneben schiefging (dieselbe Reihenfolge wie in kontext-hoch.ts).
+    console.log(t.uploaded(h.titel, h.stories, h.deinTest));
+    const zeile = specTexteZeile(h.specTexte, koepfe.length, texte.ohne, s);
+    if (zeile !== null)
+        console.log(zeile);
+    console.log(t.view(h.adresse));
+    if (!schreibeNachHochladen(process.cwd(), h.projektId, h.hochgeladenAm, true)) {
+        // `1`, nicht `0`: Ohne `basis` in der Datei lehnt das naechste Hochladen als „veraltet" ab -- hier ist noch etwas zu tun.
+        console.error(t.writeBackFailed(h.projektId, h.hochgeladenAm, true));
+        return 1;
+    }
+    if (!hatteNummer)
+        console.log(t.idNowInFile);
+    return 0;
+}

package/dist/befehle/plan.js

@@ -0,0 +1,110 @@
+import { feld, ruf } from "../api.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { PLAN_TEXTE } from "../texte/plan.js";
+import { schlussFehler } from "../fehler.js";
+import { lesePlanDatei } from "../plan-datei.js";
+const istZahl = (w) => typeof w === "number" && Number.isInteger(w);
+const textOderNull = (w) => typeof w === "string" || w === null;
+function offenAus(w) {
+    if (!w || typeof w !== "object")
+        return null;
+    const r = w;
+    if (!istZahl(r.nummer) || (r.art !== "passt_nicht" && r.art !== "thema") || typeof r.notiz !== "string")
+        return null;
+    if (!textOderNull(r.spec) || !textOderNull(r.story) || !(istZahl(r.runde) || r.runde === null))
+        return null;
+    // Ein „passt nicht" ohne Story und Runde waere eine Zeile, aus der Claude nichts machen kann.
+    if (r.art === "passt_nicht" && (r.spec === null || r.story === null || r.runde === null))
+        return null;
+    return { nummer: r.nummer, art: r.art, spec: r.spec, story: r.story, runde: r.runde, notiz: r.notiz };
+}
+function bestaetigtAus(w) {
+    if (!w || typeof w !== "object")
+        return null;
+    const r = w;
+    return typeof r.spec === "string" && typeof r.story === "string" && istZahl(r.runde) ? { spec: r.spec, story: r.story, runde: r.runde } : null;
+}
+/** `null`, wenn die Antwort nicht die erwartete Form hat (z. B. ein WLAN-Anmeldeportal mit `200`). */
+export function planAntwortAus(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    if (typeof k.adresse !== "string" || !Array.isArray(k.offen) || !Array.isArray(k.bestaetigt))
+        return null;
+    const offen = k.offen.map((o) => offenAus(o));
+    const bestaetigt = k.bestaetigt.map((b) => bestaetigtAus(b));
+    if (offen.includes(null) || bestaetigt.includes(null))
+        return null;
+    return { adresse: k.adresse, offen: offen, bestaetigt: bestaetigt };
+}
+/** Reine Rechnung: die Zeilen, die Claude zu sehen bekommt. */
+export function planZeilen(a, s) {
+    const t = PLAN_TEXTE[s];
+    const zeilen = a.offen.length === 0
+        ? [t.noOpen]
+        : a.offen.map((o) => (o.art === "thema" ? t.openTopic(o.nummer, o.notiz) : t.openVerdict(o.nummer, o.spec ?? "", o.story ?? "", o.runde ?? 0, o.notiz)));
+    if (a.bestaetigt.length > 0)
+        zeilen.push(t.confirmed(a.bestaetigt.map((b) => t.confirmedItem(b.spec, b.story, b.runde)).join(", ")));
+    zeilen.push(t.view(a.adresse));
+    return zeilen;
+}
+/** Die Datei fehlt oder ist kein JSON -- Satz auf stderr, `null`. Sonst die gelesene Datei. */
+export function planDateiOderAbsage(s) {
+    const datei = lesePlanDatei(process.cwd());
+    if (datei.ok)
+        return datei;
+    console.error(datei.grund === "fehlt" ? PLAN_TEXTE[s].fileMissing : PLAN_TEXTE[s].noJson);
+    return null;
+}
+/**
+ * Was beide Befehle mit einer Absage tun. `409`/`422` tragen einen fertigen Satz in der Kontosprache
+ * (Projekt unbekannt oder mehrdeutig, Plan unlesbar, Runde kleiner, veraltet) -- woertlich ausgeben, `1`.
+ * `503 teilweise` heisst: gespeichert, aber nicht ganz -- `3`, denn ein zweiter Lauf hilft (Spec Abschnitt 5).
+ */
+export function planAbsage(antwort, s) {
+    const meldung = feld(antwort.koerper, "meldung") ?? ALLGEMEIN_TEXTE[s].genericFailure;
+    if (antwort.status === 402) {
+        console.error(meldung);
+        return 4;
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung}${ALLGEMEIN_TEXTE[s].pleaseSignIn}`);
+        return 2;
+    }
+    if (antwort.status === 409 || antwort.status === 422) {
+        console.error(meldung);
+        return 1;
+    }
+    // `503 teilweise` landet ueber `schlussFehler` auf derselben `3` wie jeder andere Aussetzer -- mit dem Satz des Servers.
+    const schluss = schlussFehler(antwort.status, meldung, s);
+    console.error(schluss.text);
+    return schluss.wert;
+}
+export async function plan(argv) {
+    let s = sprache();
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(PLAN_TEXTE[s].listHelp);
+        return 0;
+    }
+    const datei = planDateiOderAbsage(s);
+    if (datei === null)
+        return 1;
+    const suche = new URLSearchParams();
+    if (typeof datei.json.projekt_id === "string")
+        suche.set("projekt-id", datei.json.projekt_id);
+    if (typeof datei.json.projekt === "string")
+        suche.set("projekt", datei.json.projekt);
+    const antwort = await ruf(`/api/cli/projekt/plan?${suche.toString()}`, { methode: "GET", mitAusweis: true }); // kein-anzeigetext: Pfad und HTTP-Methode
+    // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
+    s = sprache();
+    if (antwort.status !== 200)
+        return planAbsage(antwort, s);
+    const a = planAntwortAus(antwort.koerper);
+    if (a === null) {
+        console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+        return 3;
+    }
+    planZeilen(a, s).forEach((z) => console.log(z));
+    return 0;
+}

package/dist/befehle/skill-install.js

@@ -10,6 +10,7 @@ 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
@@ -325,11 +326,13 @@ export async function skillInstall() {
  * 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).
+ * 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;
 }
 /**

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