kimal3 0.1.1 → 0.1.2

package/dist/api.js

@@ -40,12 +40,9 @@ export function feld(koerper, name) {
     }
     return null;
 }
-/** Dasselbe fuer eine Liste von Texten (fuer `projekt liste`). */
-export function textListe(koerper, name) {
-    if (koerper && typeof koerper === "object" && name in koerper) {
-        const w = koerper[name];
-        if (Array.isArray(w) && w.every((x) => typeof x === "string"))
-            return w;
-    }
-    return null;
-}
+// `textListe` stand hier bis zum 2026-08-18 und zog EIN Textfeld je Eintrag --
+// genau das war die Grenze, an der `projekt liste` haengen blieb (Befund L-4).
+// Die Liste zeigt jetzt mehrere Felder je Projekt und liest ihre Antwort in
+// `projekt-zeilen.ts`, wo `check:cli` sie messen kann. Eine Funktion, die
+// niemand mehr ruft, wird nicht aufgehoben: Sie waere beim naechsten Mal die
+// naheliegende, aber zu enge Wahl.

package/dist/argumente.js

@@ -7,22 +7,50 @@
  * Titel anzulegen.
  */
 export function zerlege(argv, erlaubt) {
-    const befehl = [];
     const optionen = {};
     for (let i = 0; i < argv.length; i++) {
         const teil = argv[i];
+        // ⚠️ **Jedes Wort ohne `--` ist hier ein Fehler** (B-4). `zerlege` bekommt
+        // vom Verteiler nur den Teil NACH dem Befehlsnamen -- dort gehoert nichts
+        // hin ausser Optionen. Frueher landeten solche Woerter in `werte.befehl`
+        // und wurden nie wieder angesehen.
         if (!teil.startsWith("--")) {
-            if (Object.keys(optionen).length > 0) {
-                return { ok: false, meldung: `Nach Optionen kommt kein Befehlswort mehr: „${teil}".` };
-            }
-            befehl.push(teil);
-            continue;
+            return {
+                ok: false,
+                meldung: `Mit „${teil}" kann ich hier nichts anfangen. Erwartet werden nur Optionen wie „--name wert".`,
+            };
         }
         const gleich = teil.indexOf("=");
         const name = gleich === -1 ? teil.slice(2) : teil.slice(2, gleich);
         if (!erlaubt.includes(name)) {
             return { ok: false, meldung: `Die Option „--${name}" kenne ich nicht.` };
         }
+        // ⚠️ **Dieselbe Option zweimal ist ein FEHLER** (QA-Befund B-3, 2026-08-18).
+        //
+        // `optionen` ist ein `Record` -- die zweite Nennung ueberschrieb die erste
+        // stillschweigend. `kimal3 firma daten --firma "A" --firma "B"` lieferte
+        // die Daten von B, mit Rueckgabewert 0 und ohne jeden Hinweis. Wer die
+        // Antwort danach "fuer A" ueberschreibt, hat eine falsche Antwort auf eine
+        // richtige Frage.
+        //
+        // 🔑 Die Route ist gegen den Fall gewappnet (`getAll("firma").length > 1`,
+        // gebaut nach dem Absturz aus PR #14) -- nur bekam sie ihn ueber den
+        // CLI-Weg nie zu sehen: Hier wurde aus zwei Nennungen laengst eine.
+        // *Ein Schutz an der zweiten Tuer nuetzt nichts, wenn die erste das
+        // Problem schon weggeraeumt hat -- und man sieht ihm das beim Lesen nicht
+        // an.* Deshalb steht die Strenge HIER, wo sie alle Befehle auf einmal
+        // erreicht, und nicht in einem einzelnen Befehl.
+        //
+        // `Object.hasOwn` und nicht `name in optionen`: Letzteres findet auch
+        // geerbte Namen wie `constructor` und wuerde `--constructor` faelschlich
+        // als doppelt melden. Heute faengt `erlaubt` das ab -- aber diese Zeile
+        // soll auch dann noch stimmen, wenn jemand die Reihenfolge aendert.
+        if (Object.hasOwn(optionen, name)) {
+            return {
+                ok: false,
+                meldung: `Die Option „--${name}" steht zweimal da. Bitte nenne sie nur einmal.`,
+            };
+        }
         if (gleich !== -1) {
             optionen[name] = teil.slice(gleich + 1);
             continue;
@@ -35,5 +63,5 @@ export function zerlege(argv, erlaubt) {
         optionen[name] = wert;
         i++;
     }
-    return { ok: true, werte: { befehl, optionen } };
+    return { ok: true, werte: { optionen } };
 }

package/dist/befehle/firma-daten.js

@@ -0,0 +1,113 @@
+import { zerlege } from "../argumente.js";
+import { feld, ruf } from "../api.js";
+import { schlussFehler } from "../fehler.js";
+import { firmenZeilen } from "../firmen-liste.js";
+import { BASIS_URL } from "../anmeldung.js";
+const ERLAUBT = ["firma"];
+/**
+ * Die Firmendaten holen — als JSON, unveraendert.
+ *
+ * 🔑 **Dieser Befehl INTERPRETIERT NICHTS. Er transportiert.** Die Auswertung
+ * macht Claude, gefuehrt vom Skill — das ist die KI-native Bauform und der
+ * Grund, warum es keine `--abteilung`- oder `--zeitraum`-Optionen gibt: Filtern
+ * kann Claude aus dem JSON selbst, und jede Option waere eine zweite Stelle fuer
+ * dieselbe Regel.
+ *
+ * ⚠️ Auf stdout geht das JSON und SONST NICHTS. Wer hier eine freundliche
+ * Ueberschrift dazudruckt, macht die Ausgabe als JSON unlesbar — alles fuer
+ * Menschen gehoert nach stderr (`console.error`).
+ */
+const HILFE = `
+  kimal3 firma daten [--firma "Name"]
+
+  Holt die Daten deiner Firma als JSON: Kennzahlen, Menschen, Projekte.
+  Die Auswertung macht Claude daraus selbst.
+
+  --firma "Name"   Noetig, wenn du zu mehreren Firmen gehoerst.
+                   Die Absage nennt dir die Namen als fertige Befehle.
+`;
+export async function firmaDaten(argv) {
+    // ⚠️ VOR `zerlege`, genau wie bei `projekt neu`: Ein Schalter ist keine
+    // Option-mit-Wert, `--help` scheiterte dort sonst mit "fehlt ihr Wert".
+    // Die Terminal-Hilfe wirbt mit "Mehr zu einem Befehl: … --help" -- ein
+    // Befehl, der darauf mit einem Fehler antwortet, macht die Werbung zur Luege.
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    const zerlegt = zerlege(argv, ERLAUBT);
+    if (!zerlegt.ok) {
+        console.error(zerlegt.meldung);
+        return 1;
+    }
+    // ⚠️ `!== undefined` und NICHT auf Wahrheitswert pruefen: `zerlege`
+    // unterscheidet ausdruecklich "nicht angegeben" (`undefined`) von
+    // "ausdruecklich leer" (`--firma=` -> `""`), und `check:cli` sichert genau
+    // das ab. Wer hier auf Wahrheit prueft, wirft beides zusammen: `--firma=`
+    // lieferte dann die Daten der einzigen Firma, als haette niemand gefragt.
+    const wunsch = zerlegt.werte.optionen.firma;
+    const pfad = wunsch !== undefined
+        ? `/api/cli/firma?firma=${encodeURIComponent(wunsch)}`
+        : "/api/cli/firma";
+    const antwort = await ruf(pfad, { methode: "GET", mitAusweis: true });
+    if (antwort.status === 200) {
+        // 🔴 Ein `200` mit unlesbarem Rumpf ist KEIN Erfolg (Review-Befund Runde 1):
+        // `ruf` verschluckt Parse-Fehler zu `null`. Ein Zwischending im Netz --
+        // etwa ein WLAN-Anmeldeportal -- antwortet mit `200` und HTML. Ohne diese
+        // Wache druckte der Befehl das Wort `null` auf stdout und meldete 0.
+        // Und die 0 ist die Schnittstelle: Claude liest sie als "erledigt" und
+        // haelt `null` fuer die Daten der Firma.
+        if (antwort.koerper === null || typeof antwort.koerper !== "object") {
+            console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+            return 3;
+        }
+        console.log(JSON.stringify(antwort.koerper, null, 2));
+        return 0;
+    }
+    const meldung = feld(antwort.koerper, "meldung") ?? "Das hat nicht geklappt.";
+    // 402 VOR 401: Beide heissen "kommst hier nicht rein", verlangen aber
+    // Gegenteiliges. Wer sie zusammenwirft, raet dem Menschen `kimal3 login` --
+    // und der meldet sich dann erfolgreich an, ohne dass es etwas aendert.
+    if (antwort.status === 402) {
+        console.error(meldung);
+        return 4;
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
+        return 2;
+    }
+    if (antwort.status === 409) {
+        const grund = feld(antwort.koerper, "grund");
+        const koerper = antwort.koerper;
+        const namen = Array.isArray(koerper?.firmen)
+            ? koerper.firmen.filter((x) => typeof x === "string")
+            : [];
+        console.error(meldung);
+        // Die Namen als FERTIGE Befehle ausgeben, nicht als blosse Liste: Der
+        // naechste Schritt ist dann Kopieren statt Abtippen -- und ein Firmenname
+        // mit Leerzeichen braucht Anfuehrungszeichen, an die sonst niemand denkt.
+        //
+        // ⚠️ Welche Namen einen Befehl bekommen, entscheidet `firmenZeilen` (B-5):
+        // Ein doppelt vergebener Name bekommt KEINEN -- er waere ein Vorschlag,
+        // der garantiert wieder in derselben Absage endet.
+        const zeilen = firmenZeilen(namen);
+        if (zeilen.length > 0) {
+            console.error("\n  Deine Firmen:");
+            zeilen.forEach((z) => console.error(z));
+        }
+        if (grund === "keine-firma") {
+            console.error(`\n  Eine Firma anlegen: ${BASIS_URL}/firma/neu`);
+        }
+        return 1;
+    }
+    // ⚠️ Die 503 landet HIER und nicht oben bei der 402: Rueckgabewert 3 heisst
+    // "nochmal versuchen kann helfen", 4 heisst laut SKILL.md ausdruecklich
+    // "nicht wiederholen". Ein Aussetzer gehoert in den ersten Topf.
+    //
+    // 🔑 Den Rest entscheidet `schlussFehler` fuer alle Befehle gemeinsam --
+    // insbesondere die `404` (B-7), die hier frueher auf die `1` fiel und damit
+    // "Eingabe passt nicht" meldete, obwohl die Eingabe stimmte.
+    const schluss = schlussFehler(antwort.status, meldung);
+    console.error(schluss.text);
+    return schluss.wert;
+}

package/dist/befehle/projekt-liste.js

@@ -1,4 +1,6 @@
-import { feld, ruf, textListe } from "../api.js";
+import { feld, ruf } from "../api.js";
+import { schlussFehler } from "../fehler.js";
+import { MAX_PROJEKTE_ANZEIGE, antwortHatProjekteFeld, titelFeldLesen, projekteAusAntwort, projektZeilen, titelAusAlterAntwort, } from "../projekt-zeilen.js";
 import { BASIS_URL } from "../anmeldung.js";
 /**
  * Die eigenen Projekte anzeigen.
@@ -6,24 +8,98 @@ import { BASIS_URL } from "../anmeldung.js";
  * 🔑 Wofuer das da ist: Damit Claude VOR dem Eintragen nachsehen kann. Ohne
  * diesen Befehl steht dasselbe Projekt irgendwann zweimal auf einer
  * oeffentlichen Seite mit dem Namen eines Menschen darauf.
+ *
+ * ⚠️ Seit dem 2026-08-18 (Befund L-4) stehen auch Live-Datum und Zahlen da.
+ * Der Slash-Befehl `/k3liste` versprach das schon vorher woertlich -- und die
+ * Ausgabe gab nur Titel her. *Eine Anleitung, die mehr verspricht als das
+ * Werkzeug hergibt, laesst Claude entweder raten oder sich entschuldigen.*
  */
 export async function projektListe() {
     const antwort = await ruf("/api/cli/projekt", { methode: "GET", mitAusweis: true });
     if (antwort.status === 200) {
-        const titel = textListe(antwort.koerper, "titel");
-        if (!titel) {
-            console.error("Das hat nicht geklappt.");
+        // 🔴 Ein `200` mit unlesbarem Rumpf ist KEIN Erfolg -- dieselbe Wache wie
+        // in `firma-daten.ts`: `ruf` verschluckt Parse-Fehler zu `null`, und ein
+        // WLAN-Anmeldeportal antwortet mit `200` und HTML.
+        const projekte = projekteAusAntwort(antwort.koerper);
+        if (!projekte) {
+            /*
+              🔴 **B-7 in der GEGENRICHTUNG** (Befund L-7, 2026-08-18, im Live-Durchlauf
+              selbst hineingelaufen). Bisher wurde jede unlesbare Antwort gleich
+              behandelt: „Die Antwort war nicht lesbar. Bitte gleich noch einmal."
+      
+              Es gibt aber einen Fall, in dem Wiederholen NIE hilft: Die CLI ist neuer
+              als die App. Dann antwortet der Server ordentlich — nur eben in der
+              alten Form, mit `titel` statt `projekte`. Das passiert bei jedem
+              Deployment im Fenster zwischen npm und Vercel, und es traf hier den
+              eigenen Entwickler.
+      
+              *Ein Rat, der garantiert nicht hilft, ist schlimmer als kein Rat: Er
+              sieht aus wie ein Ausweg.* -- dieselbe Lehre wie bei B-5.
+      
+              Die alte Form ist erkennbar, also wird sie auch bedient: Der Mensch
+              bekommt seine Liste, nur ohne die neuen Angaben. Nichts kaputt, nichts
+              zu wiederholen.
+            */
+            const alt = titelAusAlterAntwort(antwort.koerper);
+            if (alt) {
+                if (alt.length === 0) {
+                    console.log("Du hast noch keine Projekte eingetragen.");
+                    console.log(`  Eintragen: kimal3 projekt neu --titel "…"`);
+                    return 0;
+                }
+                console.log(`\n  Deine Projekte (${alt.length} von ${MAX_PROJEKTE_ANZEIGE}):`);
+                alt.forEach((t, i) => console.log(`    ${i + 1}. ${t}`));
+                console.log("\n  (Diese Version der App liefert noch keine Zahlen zu den");
+                console.log("   Projekten. Du hast nichts falsch gemacht — sie kommen mit");
+                console.log("   dem nächsten Update der App von selbst dazu.)");
+                console.log(`\n  Ansehen: ${BASIS_URL}/profil\n`);
+                return 0;
+            }
+            /*
+              🔴 **Die dritte Richtung: die App ist NEUER als dieses Werkzeug**
+              (Review-Runde 4, 2026-08-18). Steht `projekte` in der Antwort und war
+              sie trotzdem nicht lesbar, hat ein Eintrag eine Form, die diese
+              Fassung nicht kennt. Das ist **stabil** -- Wiederholen aendert daran
+              nichts, bis aktualisiert wird. Vorher fiel es in denselben Topf wie
+              eine kaputte Antwort und riet "gleich noch einmal".
+            */
+            if (antwortHatProjekteFeld(antwort.koerper)) {
+                /*
+                  🔑 **Erst geben, was da ist** (Review-Runde 6, 2026-08-18). Die neue
+                  Route liefert `titel` und `projekte` IMMER gemeinsam. Aendert eine
+                  spaetere App-Fassung die Form eines Eintrags, sind die Titel trotzdem
+                  lesbar -- sie dann NICHT zu zeigen und stattdessen nur "aktualisiere"
+                  zu sagen, wirft Daten weg, die man in der Hand haelt.
+                  *Wer dem Menschen etwas geben kann, gibt es ihm -- und sagt dazu,
+                  was fehlt.*
+                */
+                const titel = titelFeldLesen(antwort.koerper);
+                if (titel && titel.length > 0) {
+                    console.log(`\n  Deine Projekte (${titel.length} von ${MAX_PROJEKTE_ANZEIGE}):`);
+                    titel.forEach((t, i) => console.log(`    ${i + 1}. ${t}`));
+                    console.log("\n  (Die Zahlen dazu kann diese Fassung von kimal3 nicht lesen —");
+                    console.log("   die App ist neuer als das Werkzeug. Du hast nichts falsch");
+                    console.log("   gemacht; `npm install -g kimal3` holt sie.)");
+                    console.log(`\n  Ansehen: ${BASIS_URL}/profil\n`);
+                    return 0;
+                }
+                console.error("Diese Fassung von kimal3 versteht die Antwort der App nicht.");
+                console.error("Du hast nichts falsch gemacht — das Werkzeug ist älter als die App.");
+                console.error("  npm install -g kimal3");
+                return 1;
+            }
+            console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
             return 3;
         }
         // Eine leere Liste ist KEIN Fehler — sie ist eine gueltige Antwort auf
         // eine gueltige Frage. Deshalb 0 und ein Satz, kein Fehlertext.
-        if (titel.length === 0) {
+        if (projekte.length === 0) {
             console.log("Du hast noch keine Projekte eingetragen.");
             console.log(`  Eintragen: kimal3 projekt neu --titel "…"`);
             return 0;
         }
-        console.log(`\n  Deine Projekte (${titel.length} von 12):`);
-        titel.forEach((t, i) => console.log(`    ${i + 1}. ${t}`));
+        console.log(`\n  Deine Projekte (${projekte.length} von ${MAX_PROJEKTE_ANZEIGE}):\n`);
+        projektZeilen(projekte).forEach((z) => console.log(z));
         console.log(`\n  Ansehen: ${BASIS_URL}/profil\n`);
         return 0;
     }
@@ -48,6 +124,11 @@ export async function projektListe() {
     // versuchen kann helfen"; 4 heisst laut SKILL.md ausdruecklich "nicht
     // wiederholen". Ein Lesefehler an der Pro-Schranke gehoert in den ersten
     // Topf. (Review-Befund 2026-08-14.)
-    console.error(meldung);
-    return antwort.status >= 500 ? 3 : 1;
+    //
+    // 🔑 Den Rest entscheidet `schlussFehler` fuer alle Befehle gemeinsam --
+    // insbesondere die `404` (B-7), die hier frueher auf die `1` fiel und damit
+    // "Eingabe passt nicht" meldete, obwohl die Eingabe stimmte.
+    const schluss = schlussFehler(antwort.status, meldung);
+    console.error(schluss.text);
+    return schluss.wert;
 }

package/dist/befehle/projekt-neu.js

@@ -1,4 +1,5 @@
 import { feld, ruf } from "../api.js";
+import { schlussFehler } from "../fehler.js";
 import { BASIS_URL } from "../anmeldung.js";
 import { zerlege } from "../argumente.js";
 const OPTIONEN = [
@@ -77,6 +78,11 @@ export async function projektNeu(argv) {
     // versuchen kann helfen"; 4 heisst laut SKILL.md ausdruecklich "nicht
     // wiederholen". Ein Lesefehler an der Pro-Schranke gehoert in den ersten
     // Topf. (Review-Befund 2026-08-14.)
-    console.error(meldung);
-    return antwort.status >= 500 ? 3 : 1;
+    //
+    // 🔑 Den Rest entscheidet `schlussFehler` fuer alle Befehle gemeinsam --
+    // insbesondere die `404` (B-7), die hier frueher auf die `1` fiel und damit
+    // "Eingabe passt nicht" meldete, obwohl die Eingabe stimmte.
+    const schluss = schlussFehler(antwort.status, meldung);
+    console.error(schluss.text);
+    return schluss.wert;
 }

package/dist/befehle/skill-install.js

@@ -1,22 +1,61 @@
-import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 /**
- * Legt das Skill GLOBAL ab, damit Claude dieses Werkzeug ueberall kennt.
+ * Namen, die frueher einmal ausgeliefert wurden und heute nicht mehr.
+ *
+ * 🔑 **Wofuer das da ist** (Review-Befund, 2026-08-18): Die Befehle landen im
+ * GEMEINSAMEN Ordner `~/.claude/commands/` und werden dort nur ueberschrieben,
+ * nie entfernt. Wird ein Befehl spaeter umbenannt oder gestrichen, ueberlebt
+ * die alte Datei jedes `skill install` und bietet weiter Anweisungen an, die
+ * auf einen nicht mehr vorhandenen Unterbefehl zeigen. `SKILL.md` kann das
+ * nicht passieren -- es ist EINE Datei, die ueberschrieben wird.
+ *
+ * ⚠️ Warum eine Liste und nicht "alles loeschen, was wir nicht ausliefern":
+ * Der Ordner gehoert dem Menschen. Ein `k3*.md`, das er selbst angelegt hat,
+ * duerfen wir nicht wegraeumen. **Wer einen Befehl umbenennt oder entfernt,
+ * traegt den alten Namen hier ein** -- sonst bleibt er beim Nutzer stehen.
+ */
+const VERALTETE_BEFEHLE = [];
+/**
+ * Woran wir unsere eigenen Befehlsdateien erkennen.
+ *
+ * Steht die Marke nicht drin, hat ein Mensch die Datei geschrieben -- dann
+ * wird sie NICHT ueberschrieben, sondern uebersprungen und gemeldet.
+ */
+const MARKE = "kimal3:erzeugt";
+/**
+ * Legt das Skill UND die Slash-Befehle GLOBAL ab, damit Claude dieses Werkzeug
+ * ueberall kennt -- und damit der Mensch es auch selbst ausloesen kann.
+ *
+ * 🔑 **Warum zwei Ziele und nicht eins** (Entscheidung Dennis, 2026-08-18):
+ * Das Skill ist der Ausloeser fuer CLAUDE ("das Projekt ist fertig" -> Claude
+ * erkennt die Absicht). Die Slash-Befehle sind der Ausloeser fuer den
+ * MENSCHEN ("/k3firma …" -> er muss sich keinen Satz merken). Das eine ist
+ * wahrscheinlich, das andere sicher. Wer nur das Skill installiert, laesst den
+ * sicheren Weg weg.
  *
  * Der Pfad zur eigenen Datei kommt ueber `import.meta.url` und NICHT ueber
  * `process.cwd()` — die Quelle liegt im installierten Paket, das Ziel im
  * Ordner des Menschen. Wer beides verwechselt, kopiert eine Datei auf sich
  * selbst.
  *
- * `dist/befehle/skill-install.js` -> zwei Ebenen hoch -> `skill/SKILL.md`.
+ * `dist/befehle/skill-install.js` -> zwei Ebenen hoch -> `skill/…`.
  */
 export async function skillInstall() {
     const quelle = fileURLToPath(new URL("../../skill/SKILL.md", import.meta.url));
     if (!existsSync(quelle)) {
-        console.error("Das Skill liegt nicht im Paket. Bitte kimal3 neu installieren.");
-        return 3;
+        /*
+          🔴 **`1`, nicht `3`** (Review-Befund, 2026-08-18). Ein unvollstaendiges
+          Paket wird durch Wiederholen nie vollstaendig. `3` heisst laut SKILL.md
+          ausdruecklich "einmal wiederholen" -- Claude liest die ZAHL, nicht den
+          Text, und wuerde einen Rat geben, der garantiert nicht hilft. Genau der
+          Fehlertyp, den dieser Zweig bei B-5, B-7 und L-7 behoben hat.
+        */
+        console.error("Das Skill liegt nicht im Paket. Bitte kimal3 neu installieren:");
+        console.error("  npm install -g kimal3");
+        return 1;
     }
     // 🔑 GLOBAL, nicht projektlokal (Fund von Dennis, 2026-08-13).
     // Gemessen: In ~/.claude/skills liegen 34 Skills, im Projekt selbst kein
@@ -39,6 +78,232 @@ export async function skillInstall() {
     }
     console.log(gabEsSchon ? "✓ Skill aktualisiert." : "✓ Skill angelegt.");
     console.log(`  ${ziel}`);
-    console.log("  Claude kennt das Werkzeug ab der nächsten Sitzung.");
+    const namen = slashBefehleInstallieren();
+    if (namen === "kaputt") {
+        /*
+          ⚠️ **Was hier zaehlt, ist die TEILWIRKUNG** (Review-Runde 2, 2026-08-18):
+          Das Skill steht oben bereits als angelegt gemeldet. Ohne diesen Satz
+          liest der Mensch ein "✓" und danach einen Fehler und weiss nicht, was
+          nun gilt. *Ein halber Erfolg ist weder ein Erfolg noch ein Totalausfall
+          -- er ist ein eigener Zustand und braucht einen eigenen Satz.*
+        */
+        console.error("  Das Skill ist installiert, die Slash-Befehle sind es NICHT.");
+        return 1;
+    }
+    const { geschrieben, uebersprungen, unlesbar, gestoert } = namen;
+    if (geschrieben.length > 0) {
+        console.log(`✓ ${geschrieben.length} Slash-Befehle: ${geschrieben.map((n) => `/${n}`).join(" · ")}`);
+        console.log(`  ${join(homedir(), ".claude", "commands")}`);
+    }
+    // ⚠️ Uebersprungene Dateien gehoeren in die AUSGABE, nicht nur in die Logik.
+    // Ein Mensch, dem stillschweigend ein Befehl fehlt, sucht den Fehler bei
+    // sich. (Review-Runde 2, 2026-08-18.)
+    if (uebersprungen.length > 0) {
+        console.log(`⚠ ${uebersprungen.length} übersprungen: ${uebersprungen.map((n) => `/${n}`).join(" · ")}`);
+        console.log("  Dort liegt bereits eine Datei, die nicht von kimal3 stammt —");
+        console.log("  sie bleibt unangetastet. Wer die kimal3-Fassung will, benennt");
+        console.log("  die eigene um und führt den Befehl erneut aus.");
+    }
+    // 🔴 Ein LESEFEHLER bekommt einen eigenen Satz (Review-Runde 6): Er sieht
+    // aus wie Fremdbesitz, ist aber keiner -- und der Rat "benenn deine Datei
+    // um" waere hier falsch.
+    if (unlesbar.length > 0) {
+        console.log(`⚠ ${unlesbar.length} nicht lesbar: ${unlesbar.map((n) => `/${n}`).join(" · ")}`);
+        console.log("  Diese Dateien liessen sich nicht öffnen — vielleicht sind sie");
+        console.log("  gerade in Benutzung. Sie wurden nicht angefasst; ein zweiter");
+        console.log("  Versuch gleich kann klappen.");
+    }
+    /*
+      🔴 **Kein Slash-Befehl installiert ist kein Erfolg** (Review-Runde 5,
+      2026-08-18). Liegen im Ordner lauter fremde `k3*.md`, landet ALLES in
+      `uebersprungen`, `geschrieben` ist leer -- und der Lauf endete trotzdem
+      auf `0`. Laut der eigenen Tabelle in `SKILL.md` heisst `0` "erledigt".
+  
+      *Ein Fehlerfall darf nie denselben Namen tragen wie ein Erfolgsfall.*
+  
+      ⚠️ Die Zahl haengt am GRUND (Review-Runde 6): War der Ordner nur belegt,
+      ist der Zustand stabil -> `1`. Ging das Schreiben schief oder war eine
+      Datei nicht lesbar, kann ein zweiter Versuch helfen -> `3`.
+    */
+    if (geschrieben.length === 0) {
+        const wiederholbar = gestoert || unlesbar.length > 0;
+        console.error("  Es wurde KEIN Slash-Befehl installiert.");
+        console.error("  Das Skill selbst ist installiert und funktioniert.");
+        return wiederholbar ? 3 : 1;
+    }
+    /*
+      ⚠️ **Eine unvollstaendige Installation als solche melden** (Review-Runde 6).
+      Scheitert `copyFileSync` bei Datei 3 von 4, sind zwei Befehle da -- der
+      Lauf ist weder gelungen noch gescheitert. Frueher warf der `catch` die
+      Teilwirkung weg und meldete alles als misslungen.
+    */
+    if (gestoert) {
+        console.error("  Nicht alle Slash-Befehle konnten geschrieben werden.");
+        console.error("  Die oben genannten stehen; ein zweiter Lauf holt den Rest.");
+        return 3;
+    }
+    /*
+      ⚠️ **Nicht auf einen Befehl verweisen, den wir gerade NICHT installiert
+      haben** (Review-Runde 3, 2026-08-18, gemessen). Mit einer fremden
+      `k3.md` im Ordner stand hier woertlich "Tipp /k3 in Claude Code" --
+      ausgerechnet der eine Befehl, den der Lauf soeben abgelehnt hatte.
+      *Ein Hinweis auf etwas, das es nicht gibt, sieht aus wie ein Fehler des
+      Menschen.*
+    */
+    if (geschrieben.includes("k3")) {
+        console.log("  Tipp /k3 in Claude Code. (Taucht nichts auf, einmal neu starten.)");
+    }
+    else {
+        console.log(`  Tipp /${geschrieben[0]} in Claude Code. (Taucht nichts auf, einmal neu starten.)`);
+    }
     return 0;
 }
+/**
+ * Kopiert die Slash-Befehle nach `~/.claude/commands/`.
+ *
+ * ⚠️ **FLACH, nicht in einen Unterordner** — und das ist keine Bequemlichkeit:
+ * Ein Unterordner `kimal3/` macht aus `/k3firma` ein `/kimal3:k3firma`. Dann
+ * findet man die Familie nicht mehr, indem man `/k3` tippt, und genau das war
+ * die Anforderung (Dennis, 2026-08-18): einmal `/k3` eingeben und alles sehen.
+ * Der gemeinsame Namensanfang ERSETZT hier den Ordner.
+ *
+ * Rueckgabe: die Namen ohne `.md` — oder `"kaputt"` (Paket unvollstaendig,
+ * Wiederholen hilft NIE) bzw. `"stoerung"` (Schreiben ging schief, Wiederholen
+ * kann helfen). *Zwei Fehlerfaelle, die Gegenteiliges verlangen, duerfen nicht
+ * denselben Namen tragen.*
+ */
+function slashBefehleInstallieren() {
+    const quellOrdner = fileURLToPath(new URL("../../skill/commands", import.meta.url));
+    if (!existsSync(quellOrdner)) {
+        console.error("Die Slash-Befehle liegen nicht im Paket. Bitte kimal3 neu installieren.");
+        return "kaputt";
+    }
+    const dateien = readdirSync(quellOrdner).filter((n) => n.endsWith(".md")).sort();
+    if (dateien.length === 0) {
+        console.error("Im Paket liegt kein einziger Slash-Befehl. Bitte kimal3 neu installieren.");
+        return "kaputt";
+    }
+    const zielOrdner = join(homedir(), ".claude", "commands");
+    const geschrieben = [];
+    const uebersprungen = [];
+    const unlesbar = [];
+    let gestoert = false;
+    try {
+        mkdirSync(zielOrdner, { recursive: true });
+        for (const datei of dateien) {
+            const ziel = join(zielOrdner, datei);
+            /*
+              🔴 **Fremde Dateien NICHT ueberschreiben** (Review-Runde 2, 2026-08-18).
+              Der Ordner gehoert dem Menschen. Der Kommentar bei VERALTETE_BEFEHLE
+              argumentiert, dass wir eine selbstgeschriebene `k3*.md` nicht loeschen
+              duerfen -- *Ueberschreiben zerstoert sie genauso gruendlich*, nur
+              unauffaelliger.
+      
+              Woran wir unsere eigenen erkennen: an der Marke `kimal3:erzeugt`. Ein
+              blosser Inhaltsvergleich taugt nicht -- eine AELTERE Fassung von uns
+              unterscheidet sich auch, und die soll ja gerade ersetzt werden.
+            */
+            if (existsSync(ziel)) {
+                const vorhanden = leseWennMoeglich(ziel);
+                /*
+                  ⚠️ **Ein LESEFEHLER ist kein Fremdbesitz** (Review-Runde 6,
+                  2026-08-18). Vorher wurde ein gescheitertes `readFileSync` zu einem
+                  leeren Text -- dann fehlt die Marke zwangslaeufig, und der Mensch las
+                  "dort liegt eine Datei, die nicht von kimal3 stammt" fuer eine Datei,
+                  die kimal3 selbst geschrieben hat. *Ein Fehlerfall unter dem Namen
+                  eines anderen, zum vierten Mal in diesem Zweig.*
+                */
+                if (vorhanden === null) {
+                    unlesbar.push(datei);
+                    continue;
+                }
+                if (!vorhanden.includes(MARKE)) {
+                    uebersprungen.push(datei);
+                    continue;
+                }
+            }
+            copyFileSync(join(quellOrdner, datei), ziel);
+            geschrieben.push(datei);
+        }
+    }
+    catch (fehler) {
+        /*
+          ⚠️ **Die Teilwirkung ueberlebt den Fehler** (Review-Runde 6, 2026-08-18).
+          Vorher warf dieser `catch` alles weg und meldete "stoerung" -- auch wenn
+          zwei von vier Befehlen bereits geschrieben waren. Der Mensch hoerte "die
+          Slash-Befehle sind NICHT installiert", waehrend die Haelfte dastand.
+          `geschrieben` und `uebersprungen` sind ausserhalb des `try` deklariert,
+          genau dafuer.
+        */
+        console.error(`Die Slash-Befehle liessen sich nicht alle schreiben: ${String(fehler)}`);
+        gestoert = true;
+    }
+    raeumeVeralteteAuf(zielOrdner, VERALTETE_BEFEHLE);
+    return {
+        geschrieben: geschrieben.map((n) => n.replace(/\.md$/, "")),
+        uebersprungen: uebersprungen.map((n) => n.replace(/\.md$/, "")),
+        unlesbar: unlesbar.map((n) => n.replace(/\.md$/, "")),
+        gestoert,
+    };
+}
+/** Liest eine Datei — `null`, wenn sie sich nicht lesen laesst. */
+function leseWennMoeglich(pfad) {
+    try {
+        return readFileSync(pfad, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Entfernt Befehlsdateien, die frueher einmal ausgeliefert wurden.
+ *
+ * 🔴 **Warum das eine eigene, exportierte Funktion ist** (Review-Runde 3,
+ * 2026-08-18): `VERALTETE_BEFEHLE` ist leer, also ist diese Schleife noch nie
+ * gelaufen -- und `check:cli` "belegte" sie nur ueber eine Textsuche. Genau
+ * die Falle aus der Projekt-Notiz *wache-am-echten-fehlerfall-pruefen*.
+ * Mit dem Zielordner als Parameter laesst sie sich gegen einen Wegwerf-Ordner
+ * mit einer echten Datei fahren.
+ *
+ * 🔴 **Und sie loescht NUR eigene Dateien** (Review-Runde 6, 2026-08-18).
+ * Vorher entfernte sie blind, was auf der Liste stand -- waehrend die
+ * Kopierschleife siebzig Zeilen hoeher genau solche Dateien verschont und dem
+ * Menschen sagt "sie bleibt unangetastet". *Zwei Haelften desselben Befehls
+ * mit gegensaetzlicher Haltung zum selben Ordner.* Wird `/k3liste` spaeter
+ * umbenannt, verloere ein Mensch mit eigener `k3liste.md` sie ohne Rueckfrage.
+ *
+ * Gibt zurueck, was wirklich entfernt wurde -- eine Behauptung waere hier
+ * genau das Falsche.
+ */
+export function raeumeVeralteteAuf(zielOrdner, veraltet) {
+    const entfernt = [];
+    for (const eintrag of veraltet) {
+        /*
+          🔴 **Beide Schreibweisen annehmen** (Review-Runde 5, 2026-08-18). Der
+          Doc-Block sagt "wer einen Befehl umbenennt, traegt den alten NAMEN hier
+          ein" -- gejoint wird aber ein DATEIname. Wer `"k3alt"` eintraegt, bekam
+          keinen Fehler: nichts wird entfernt, nichts gemeldet.
+        */
+        const alt = eintrag.endsWith(".md") ? eintrag : `${eintrag}.md`;
+        const weg = join(zielOrdner, alt);
+        try {
+            if (!existsSync(weg))
+                continue;
+            const inhalt = leseWennMoeglich(weg);
+            if (inhalt === null || !inhalt.includes(MARKE)) {
+                // Nicht von uns (oder nicht lesbar) -> nicht anfassen. Still, weil es
+                // der Normalfall ist, dass dort gar nichts liegt.
+                continue;
+            }
+            rmSync(weg);
+            entfernt.push(alt);
+            console.log(`  (veralteten Befehl /${alt.replace(/\.md$/, "")} entfernt)`);
+        }
+        catch {
+            // Bewusst still: Die Befehle sind installiert. Eine liegengebliebene
+            // alte Datei ist ein Schoenheitsfehler, kein Grund, den Erfolg zu
+            // widerrufen. (Review-Runde 2.)
+        }
+    }
+    return entfernt;
+}