kimal3 0.4.0 → 0.6.0

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

package/dist/befehle-katalog-en.js

@@ -118,6 +118,20 @@ export const BEFEHLE_EN = {
             "What it's really for: Claude looks here BEFORE adding a project. Without that check, the same project would sooner or later appear twice on a public page that carries your name.",
         ],
     },
+    "kimal3 plan": {
+        stempel: "5a366449",
+        befehl: "kimal3 plan",
+        tippen: "/k3plan",
+        terminal: "kimal3 plan",
+        beschreibung: "Upload planning or fetch responses",
+        rhythmusOderSatz: "check my planning",
+        details: [
+            "kimal3 plan fetches what you've said in the app since the last upload: every “doesn't work” and every noted topic with its number, plus the confirmed stories. Claude sorts them and enters them in plan/stand.json.",
+            "kimal3 plan upload sends plan/stand.json to your project and then enters projekt_id and basis in the file itself. With --dry-run it only checks and saves nothing.",
+            "If the plan can't be read, a round goes down or the app already holds a newer plan, it refuses and saves nothing at all — the message says what to do. Use --overwrite only if you really mean it.",
+            "You'll know it worked when it reports with ✓ how many stories were uploaded and how many are waiting for your test, and gives the link to the planning.",
+        ],
+    },
     "kimal3 kurs": {
         stempel: "3a5c7600",
         befehl: "kimal3 course",
@@ -143,6 +157,33 @@ export const BEFEHLE_EN = {
             "⚠️ This is personal data about your colleagues. For use in a real company you need a commercial Claude account with a data processing agreement. If employees' performance is analysed, in Germany this requires the works council's agreement (co-determination).",
         ],
     },
+    "kimal3 zeigen start": {
+        stempel: "35a185f9",
+        befehl: "kimal3 show start",
+        tippen: "/k3show",
+        terminal: 'kimal3 show start "Send the open quotes to my boss every Monday"',
+        beschreibung: "Start a recording while you show a task",
+        rhythmusOderSatz: "I want to show you a task",
+        details: [
+            "You do a task once on screen and say out loud what you are doing and why. Claude guides you through it: first the briefing on what gets recorded, then the recording, then the evaluation on your computer.",
+            "All screens, sound, clicks and keys are recorded — so don't type a password. The recording lies in the project under material/aufnahmen/ and never ends up in Git; it stops by itself after 15 minutes at the latest.",
+            "Claude asks you before reading any of it: only after your yes does the timeline go to Anthropic. At the end the task is written down in the project's plan folder, and Claude suggests deleting the recording.",
+            "Windows-only for now.",
+        ],
+    },
+    "kimal3 zeigen status": {
+        stempel: "7ebd2b8f",
+        befehl: "kimal3 show status",
+        tippen: "! kimal3 show status",
+        terminal: "kimal3 show status",
+        beschreibung: "Check whether a recording is running and whether the recorder is set up",
+        rhythmusOderSatz: "when you want to know whether something is being recorded",
+        details: [
+            "Shows two blocks: what is set up (uv, recorder, FFmpeg, speech model) and whether a recording of your screen is running — with start time, folder and the time at which it stops by itself at the latest.",
+            "If it can't tell whether something is being recorded, it says exactly that, with exit code 1 — it then never claims that nothing is running.",
+            "It only reads and changes nothing. Windows-only for now.",
+        ],
+    },
     "kimal3 wache": {
         stempel: "2daae4e2",
         befehl: "kimal3 watch",

package/dist/befehle-katalog.js

@@ -167,6 +167,24 @@ export const BEFEHLE = [
             "Wofür es wirklich da ist: Claude schaut hier VOR dem Eintragen nach. Ohne diesen Blick stünde dasselbe Projekt irgendwann zweimal auf einer öffentlichen Seite, die deinen Namen trägt.",
         ],
     },
+    /*
+      `kimal3 plan` und `kimal3 plan hoch` (Spec 2026-10-21-projektseite-planung) -- EIN Eintrag fuer beide: Claude
+      ruft sie nacheinander auf, und ein Mensch sucht hier nach der Planung, nicht nach zwei Befehlen.
+    */
+    {
+        befehl: "kimal3 plan",
+        beschreibung: "Planung hochladen oder Rückmeldungen holen",
+        wer: "claude",
+        ausloeser: "prüf meine Planung",
+        tippen: "/k3plan",
+        terminal: "kimal3 plan",
+        details: [
+            "kimal3 plan holt aus der App, was du seit dem letzten Hochladen gesagt hast: jedes „passt nicht“ und jedes notierte Thema mit seiner Nummer, dazu die bestätigten Stories. Claude ordnet sie ein und trägt sie in plan/stand.json ein.",
+            "kimal3 plan hoch schickt plan/stand.json an dein Projekt und trägt danach projekt_id und basis selbst in die Datei ein. Mit --probe prüft er nur und speichert nichts.",
+            "Ist der Plan nicht lesbar, wird eine Runde kleiner oder liegt in der App schon ein neuerer Plan, lehnt er ab und speichert gar nichts — die Meldung sagt, was zu tun ist. --ueberschreiben nur, wenn du es wirklich willst.",
+            "Geklappt hat es, wenn er mit ✓ meldet, wie viele Stories hochgeladen sind und wie viele auf deinen Test warten, und den Link zur Planung nennt.",
+        ],
+    },
     {
         befehl: "kimal3 kurs",
         beschreibung: "Zeigen, wo du im Mini-Kurs stehst",
@@ -192,6 +210,33 @@ export const BEFEHLE = [
             "⚠️ Es sind personenbezogene Daten von Kolleginnen und Kollegen. Für den Einsatz in einer echten Firma braucht es ein kommerzielles Claude-Konto mit Auftragsverarbeitungsvertrag; werden Leistungen von Beschäftigten ausgewertet, ist das in Deutschland mitbestimmungspflichtig.",
         ],
     },
+    {
+        befehl: "kimal3 zeigen start",
+        beschreibung: "Eine Aufnahme starten, während du eine Aufgabe vormachst",
+        wer: "claude",
+        ausloeser: "ich will dir eine Aufgabe vormachen",
+        tippen: "/k3zeigen",
+        terminal: 'kimal3 zeigen start "Offene Angebote jeden Montag an die Chefin schicken"',
+        details: [
+            "Du machst eine Aufgabe einmal am Bildschirm vor und sagst dabei laut, was du tust und warum. Claude führt dich durch: vorher die Ansage, was aufgenommen wird, dann die Aufnahme, danach das Auswerten auf deinem Rechner.",
+            "Aufgenommen werden alle Bildschirme, Ton, Klicks und Tasten — tippe deshalb kein Passwort. Die Aufnahme liegt im Projekt unter material/aufnahmen/ und landet nie in Git; spätestens nach 15 Minuten stoppt sie von selbst.",
+            "Bevor Claude etwas davon liest, fragt er dich: Erst nach deinem Ja geht die Zeitleiste an Anthropic. Am Ende steht die Aufgabe in plan/aufgabe-vorgefuehrt.md, und Claude schlägt vor, die Aufnahme zu löschen.",
+            "Gibt es bisher nur unter Windows.",
+        ],
+    },
+    {
+        befehl: "kimal3 zeigen status",
+        beschreibung: "Nachsehen, ob gerade aufgenommen wird und ob der Aufnehmer eingerichtet ist",
+        wer: "du",
+        rhythmus: "wenn du wissen willst, ob gerade aufgenommen wird",
+        tippen: "! kimal3 zeigen status",
+        terminal: "kimal3 zeigen status",
+        details: [
+            "Zeigt zwei Blöcke: was eingerichtet ist (uv, Aufnehmer, FFmpeg, Sprachmodell) und ob gerade eine Aufnahme von deinem Bildschirm läuft — mit Startzeit, Ordner und der Uhrzeit, zu der sie spätestens von selbst stoppt.",
+            "Kann es nicht feststellen, ob aufgenommen wird, sagt es genau das, mit Rückgabewert 1 — es behauptet dann nie, dass nichts läuft.",
+            "Es liest nur und ändert nichts. Gibt es bisher nur unter Windows.",
+        ],
+    },
     /*
       🔴 Dieser Eintrag steht bewusst NICHT im "Weg, den ein Mensch geht" --
       niemand muss ihn selbst tippen. Er wird bei jedem Start von Claude Code

package/dist/befehlswoerter.js

@@ -10,11 +10,21 @@ export const BEFEHLSWOERTER = {
     "kontext fragen": { de: "kontext fragen", en: "context questions" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "projekt neu": { de: "projekt neu", en: "project new" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "projekt liste": { de: "projekt liste", en: "project list" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
+    // `kimal3 plan` (Spec 2026-10-21-projektseite-planung, US-9): `plan` heisst in beiden Sprachen gleich.
+    plan: { de: "plan", en: "plan" },
+    "plan hoch": { de: "plan hoch", en: "plan upload" }, // kein-anzeigetext: Befehlswörter (Spec projektseite-planung)
     "firma daten": { de: "firma daten", en: "company data" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     kurs: { de: "kurs", en: "course" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     wache: { de: "wache", en: "watch" },
     "wache an": { de: "wache an", en: "watch on" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "wache aus": { de: "wache aus", en: "watch off" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
+    // `kimal3 zeigen` / `show` (Spec 2026-10-18-k3zeigen-design.md, Abschnitt 1)
+    "zeigen einrichten": { de: "zeigen einrichten", en: "show setup" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen start": { de: "zeigen start", en: "show start" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen stopp": { de: "zeigen stopp", en: "show stop" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen auswerten": { de: "zeigen auswerten", en: "show evaluate" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen bild": { de: "zeigen bild", en: "show picture" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
+    "zeigen status": { de: "zeigen status", en: "show status" }, // kein-anzeigetext: Befehlswörter (Spec k3zeigen)
 };
 /**
  * Welcher Befehl steht vorne in `argv` -- und was bleibt dahinter?
@@ -60,6 +70,12 @@ export const SCHALTER_EN = {
     // `kimal3 einrichten` / `setup` (Spec 2026-10-16, Bauform 6)
     workplace: "arbeitsplatz",
     workbench: "werkbank",
+    // `kimal3 show …` (Spec 2026-10-18-k3zeigen-design.md)
+    "at-most": "hoechstens",
+    language: "sprache",
+    "without-typed": "ohne-getipptes",
+    // `kimal3 plan upload` (Spec 2026-10-21-projektseite-planung, US-11); `--overwrite` steht schon oben.
+    "dry-run": "probe",
 };
 /** `company` -> `firma`; ein deutscher (oder unbekannter) Name bleibt, wie er ist. */
 export function deutscherSchalter(getippt) {

package/dist/kimal3.js

@@ -36,8 +36,13 @@ import { logout } from "./befehle/logout.js";
 import { kurs } from "./befehle/kurs.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
+import { plan } from "./befehle/plan.js";
+import { planHoch } from "./befehle/plan-hoch.js";
 import { skillDatei, skillInstallBefehl } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
+import { zeigenAuswerten, zeigenBild, zeigenStatus, zeigenStopp } from "./befehle/zeigen.js";
+import { zeigenStart } from "./befehle/zeigen-start.js";
+import { zeigenEinrichten } from "./befehle/zeigen-einrichten.js";
 /** Eine Meldung pro Programmlauf -- s. "Einmal-Riegel" im Block darunter. */
 let schonGemeldet = false;
 /**
@@ -484,6 +489,9 @@ async function fuehreAus(name, rest) {
         case "skill install": return allein ? skillInstallBefehl() : null;
         case "projekt neu": return projektNeu(rest);
         case "projekt liste": return allein ? projektListe() : null;
+        // `plan` nimmt nur `--help`; ein Wort dahinter (`plan muell`) bleibt unbekannt wie bei `login extra`.
+        case "plan": return allein || (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h")) ? plan(rest) : null;
+        case "plan hoch": return planHoch(rest);
         case "kurs": return allein ? kurs() : null;
         // ⚠️ Rest wird durchgereicht, nicht auf Gleichheit geprueft: `firma daten --firma X` gehoert dazu.
         case "firma daten": return firmaDaten(rest);
@@ -493,6 +501,13 @@ async function fuehreAus(name, rest) {
         case "kontext runter": return kontextRunter(rest);
         case "kontext hoch": return kontextHoch(rest);
         case "kontext fragen": return kontextFragen(rest);
+        // `kimal3 zeigen` (Spec 2026-10-18-k3zeigen-design.md).
+        case "zeigen einrichten": return zeigenEinrichten(rest);
+        case "zeigen start": return zeigenStart(rest);
+        case "zeigen stopp": return zeigenStopp(rest);
+        case "zeigen auswerten": return zeigenAuswerten(rest);
+        case "zeigen bild": return zeigenBild(rest);
+        case "zeigen status": return zeigenStatus(rest);
         case "wache an": return allein ? wacheSchalten(true) : null;
         case "wache aus": return allein ? wacheSchalten(false) : null;
         case "wache":

package/dist/logo-ablegen.js

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