kimal3 0.1.1 → 0.1.3

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

package/dist/befehle-katalog.js

@@ -0,0 +1,112 @@
+/**
+ * Alle Befehle, die `kimal3` kennt — als DATEN, nicht als Fliesstext.
+ *
+ * 🔑 Warum das eine eigene Datei ist (Spec US-5, 2026-08-18): Die Liste wird an
+ * ZWEI Orten angezeigt — in der Terminal-Hilfe und im aktiven Pro-Bereich der
+ * App. Zwei handgeschriebene Listen sind die "dieselbe Zahl an zwei Tueren"-
+ * Falle: Der naechste Befehl erschiene in einer und fehlte in der anderen.
+ * Genau so war die `check:`-Prueferliste in CLAUDE.md monatelang unvollstaendig.
+ *
+ * ⚠️ DIESE DATEI IMPORTIERT NICHTS, und das ist Absicht: Die CLI baut mit
+ * NodeNext (Import-Pfade enden auf `.js`), die App mit dem Bundler. Eine Datei
+ * ohne eigene Importe liest sich aus beiden Welten ohne Uebersetzung.
+ *
+ * ⚠️ Der Katalog beschreibt, WAS ES GIBT — nicht, wer es darf. Die Pro-Schranke
+ * sitzt in der Route und im Befehl, nicht hier.
+ */
+export const BEFEHLE = [
+    {
+        befehl: "kimal3 login",
+        beschreibung: "Diesen Rechner mit deinem Konto verbinden",
+        wer: "du",
+        rhythmus: "einmal pro Rechner",
+        beispiel: "kimal3 login",
+        details: [
+            "Der Befehl zeigt dir eine Adresse und einen kurzen Code. Die Adresse im Browser öffnen, den Code eintippen, fertig — das Terminal merkt die Bestätigung von selbst. Zehn Minuten hast du dafür Zeit.",
+            "Danach musst du dich NICHT bei jedem Start neu anmelden: Der Ausweis liegt als Datei in deinem Benutzerordner und übersteht IDE-Neustarts, Rechner-Neustarts und Updates. Bei jedem Aufruf wird er im Hintergrund aufgefrischt, ohne dass du etwas merkst.",
+            "Gelegentlich reißt diese Kette trotzdem — dann sagt ein Befehl „Bitte kimal3 login ausführen\". Das ist kein Fehler, sondern der Normalfall nach längerer Pause: einmal wiederholen und weitermachen.",
+        ],
+    },
+    {
+        befehl: "kimal3 logout",
+        beschreibung: "Verbindung wieder aufheben",
+        wer: "du",
+        rhythmus: "nur wenn nötig",
+        beispiel: "kimal3 logout",
+        details: [
+            "Hebt die Verbindung dieses einen Rechners auf. Für den Alltag brauchst du ihn nicht.",
+            "Sinnvoll ist er, wenn du auf einem fremden oder geteilten Rechner gearbeitet hast — oder wenn ein Gerät abhandenkommt. Deine anderen Rechner bleiben angemeldet.",
+        ],
+    },
+    {
+        befehl: "kimal3 projekt neu …",
+        beschreibung: "Ein Projekt ins Erfolgsprofil eintragen",
+        wer: "claude",
+        ausloeser: "trag das als Projekt ein",
+        beispiel: 'kimal3 projekt neu --titel "Angebots-Generator" --stunden 4 --ergebnis 1200',
+        details: [
+            "Wenn du in Claude etwas fertig gebaut hast und sagst „trag das als Projekt ein\", stellt Claude den Befehl selbst zusammen — mit Titel, Zeitersparnis, Ergebnis und allem, was ihr gerade besprochen habt. Das ist der bequeme Weg, weil Claude die Zahlen schon kennt.",
+            "Selbst tippen kannst du ihn genauso. Pflicht ist nur --titel; alles andere ist freiwillig. Die vollständige Liste aller Angaben zeigt: kimal3 projekt neu --help",
+            "Das Projekt landet in deinem Erfolgsprofil und ist damit Teil deines nachprüfbaren Nachweises.",
+        ],
+    },
+    {
+        befehl: "kimal3 projekt liste",
+        beschreibung: "Deine eingetragenen Projekte anzeigen",
+        wer: "claude",
+        ausloeser: "zeig meine Projekte",
+        beispiel: "kimal3 projekt liste",
+        details: [
+            "Zeigt, was schon in deinem Erfolgsprofil steht.",
+            "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.",
+        ],
+    },
+    {
+        befehl: "kimal3 firma daten",
+        beschreibung: "Die Daten deiner Firma holen, damit Claude sie auswerten kann",
+        wer: "claude",
+        ausloeser: "werte meine Firma aus",
+        beispiel: 'kimal3 firma daten --firma "Nordwind Handel GmbH"',
+        details: [
+            "Holt Kennzahlen, Menschen und Projekte deiner Firma und gibt sie an Claude weiter. Die Auswertung macht dann Claude — frag einfach los: „Welche drei Projekte bringen den meisten messbaren Ertrag?\" oder „Was sollten wir als Nächstes automatisieren?\"",
+            "Gehörst du zu mehreren Firmen, fragt der Befehl nach — er wählt nie still eine aus.",
+            "⚠️ 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 skill install",
+        beschreibung: "Claude beibringen, dieses Werkzeug zu benutzen — und dir die /k3-Befehle geben",
+        wer: "du",
+        rhythmus: "einmal — und nach jedem Update",
+        beispiel: "kimal3 skill install",
+        details: [
+            "Das ist der Befehl, der aus den anderen erst etwas macht. Er legt ZWEI Dinge in deinem Claude-Ordner ab: eine Anleitung für Claude (das „Skill\") und vier Slash-Befehle für dich.",
+            "🤖 Die Anleitung sorgt dafür, dass Claude von selbst weiß, dass es kimal3 gibt — du sagst „das Projekt ist fertig\", er trägt es ein.",
+            "🧑 Die Slash-Befehle sind dein eigener Griff: Tipp /k3 in Claude Code, und du siehst die ganze Familie — /k3 · /k3projekt · /k3liste · /k3firma. Damit musst du dir keinen Satz merken.",
+            "Er läuft NICHT automatisch. Einmal nach der Installation ausführen — und noch einmal nach jedem Update des Werkzeugs, sonst arbeitet Claude weiter mit der alten Anleitung.",
+            "Woran du merkst, dass es geklappt hat: Der Befehl meldet „Skill angelegt\" (oder „aktualisiert\") und zählt die Slash-Befehle auf. Beides kennt Claude ab der NÄCHSTEN Sitzung — die laufende muss also einmal neu gestartet werden.",
+        ],
+    },
+];
+/**
+ * Die Terminal-Hilfe, gebaut aus dem Katalog.
+ *
+ * Die Spalten richten sich an der laengsten Befehlszeile aus — von Hand
+ * gesetzte Leerzeichen waeren beim naechsten laengeren Befehl krumm.
+ *
+ * 📌 Sie nimmt bewusst NUR `befehl` und `beschreibung`: Im Terminal ist eine
+ * Uebersicht gefragt, kein Handbuch. Die langen `details` haben ihren Platz auf
+ * `/pro`, wo man sie auf- und zuklappen kann — `--help` je Befehl bleibt der
+ * Weg im Terminal.
+ */
+export function hilfeText() {
+    const breite = Math.max(...BEFEHLE.map((b) => b.befehl.length));
+    const zeilen = BEFEHLE.map((b) => `  ${b.befehl.padEnd(breite + 2)}${b.beschreibung}`).join("\n");
+    return `
+  kimal3 — trag deine KI-Projekte dort ein, wo sie entstehen.
+
+${zeilen}
+
+  Mehr zu einem Befehl:  kimal3 projekt neu --help
+`;
+}

package/dist/fehler.js

@@ -0,0 +1,66 @@
+/**
+ * Der gemeinsame Schluss aller Befehle: Was tun mit einer Absage, die kein
+ * Befehl fuer sich beantworten kann?
+ *
+ * 🔑 **Warum das hier wohnt und nicht in `api.ts`:** Es ist eine reine
+ * Rechnung -- Zahl und Text rein, Zahl und Text raus, kein Netz, keine Datei.
+ * Damit ist sie in `check:cli` messbar, ohne einen Server zu starten. `api.ts`
+ * zieht ueber `anmeldung.ts` das Dateisystem nach; wer von dort importiert,
+ * kann die Rechnung nicht mehr allein pruefen.
+ */
+/**
+ * ⚠️ **404 ist KEIN Eingabefehler** (QA-Befund B-7, 2026-08-18).
+ *
+ * Vorher endeten alle drei Befehle auf `status >= 500 ? 3 : 1`. Eine `404`
+ * fiel damit auf die `1` -- und `1` heisst laut `skill/SKILL.md` ausdruecklich
+ * *"Eingabe passt nicht"*. Antwortet die App aber mit `404`, war die Eingabe
+ * fehlerfrei: Die **App** kennt den Befehl noch nicht. Claude folgte der
+ * Betriebsanleitung und erklaerte dem Menschen, seine Eingabe stimme nicht --
+ * woraufhin der Firmenname, Schreibweise und `--firma` prueft und nichts davon
+ * hilft.
+ *
+ * 🔴 **Gemessen am 2026-08-18:** `/api/cli/firma` antwortete auf
+ * `kimal3-app.vercel.app` mit `404`, waehrend `/api/cli/projekt` mit `200`
+ * antwortete -- der Befehl war veroeffentlicht, die Route noch nicht
+ * ausgeliefert. Genau so sieht der Fall im Alltag aus: im Fenster zwischen
+ * `npm publish` und fertigem Deployment, bei einem Rueckbau, und bei jedem
+ * neuen Befehl.
+ *
+ * *Ein Fehlerfall darf nie denselben Namen tragen wie ein anderer, der
+ * Gegenteiliges verlangt.* Deshalb bekommt die `404` den `3`-Topf: dort steht
+ * bereits "nochmal versuchen kann helfen" -- und ein paar Minuten spaeter ist
+ * das Deployment durch.
+ */
+export function schlussFehler(status, meldung) {
+    if (status === 404) {
+        return {
+            text: "Diese Version der App kennt den Befehl noch nicht. " +
+                "Hast du gerade aktualisiert, versuch es in ein paar Minuten noch einmal.",
+            wert: 3,
+        };
+    }
+    /*
+      🔴 **`408` und `429` gehoeren AUCH in den 3-Topf** (Review-Runde 3,
+      2026-08-18). Vorher fiel alles unter 500 auf die `1` -- und die heisst seit
+      Runde 2 ausdruecklich "Wiederholen hilft nicht".
+  
+      Beide Zahlen sagen aber genau das Gegenteil: `429` schickt eine
+      Vercel-Firewall oder ein Supabase-Rate-Limit, `408` ist eine
+      Zeitueberschreitung. Bei beiden ist **Warten die Loesung**, und bei beiden
+      kommt der Rumpf oft als HTML -- dann steht dort nicht einmal eine Meldung,
+      sondern nur "Das hat nicht geklappt.".
+  
+      *Genau die Form von B-7, nur mit einer anderen Zahl:* Der Mensch hat nichts
+      falsch gemacht, das Werkzeug rät ihm trotzdem, es sein zu lassen.
+    */
+    if (status === 408 || status === 429) {
+        return {
+            text: "Der Server ist gerade überlastet oder hat zu lange gebraucht. " +
+                "Versuch es in einem Moment noch einmal.",
+            wert: 3,
+        };
+    }
+    // Alles Uebrige: ein Aussetzer des Servers ist wiederholbar, alles andere
+    // ist die Absage, die der Server selbst formuliert hat.
+    return { text: meldung, wert: status >= 500 ? 3 : 1 };
+}

package/dist/firmen-liste.js

@@ -0,0 +1,70 @@
+/**
+ * Die Firmen-Auswahl, die eine Absage dem Menschen anbietet.
+ *
+ * 🔑 Eine reine Rechnung, damit `check:cli` sie ohne Server pruefen kann --
+ * dieselbe Ueberlegung wie bei `fehler.ts`.
+ */
+/**
+ * Aus den Namen der eigenen Firmen die Zeilen bauen, die unter „Deine Firmen:"
+ * stehen.
+ *
+ * ⚠️ **Ein doppelter Name bekommt KEINEN Befehl** (QA-Befund B-5, 2026-08-18).
+ * Vorher wurde jeder Name stumpf zu einer kopierfertigen Zeile -- bei zwei
+ * gleichnamigen Firmen also **zweimal derselbe Befehl**. Wer ihn ausfuehrte,
+ * bekam dieselbe Absage, die erneut denselben Befehl anbot: eine Sackgasse
+ * ohne Ausweg.
+ *
+ * *Ein Vorschlag, der garantiert wieder scheitert, ist schlimmer als gar
+ * keiner -- er sieht aus wie ein Ausweg und kostet den Menschen den Versuch.*
+ *
+ * 🔑 **Nur der mehrdeutige Name verliert seinen Befehl, nicht die ganze
+ * Liste.** Wer zu „Nordwind", „Nordwind" und „Suedwind" gehoert, kann
+ * „Suedwind" weiterhin waehlen. Dieselbe Lehre steckt schon in der Route
+ * (Review-Befund Runde 2): *Eine Sperre, die mehr sperrt als das Mehrdeutige,
+ * verlangt vom Menschen etwas, das er nicht tun kann.*
+ *
+ * ⚠️ Was hier NICHT geloest wird: An die Daten einer doppelt benannten Firma
+ * kommt man ueber die CLI weiterhin nicht. Das braeuchte eine Auswahl ueber
+ * die ID statt ueber den Namen -- eine eigene Entscheidung, keine Fussnote.
+ * Diese Funktion sorgt nur dafuer, dass niemand mehr einen Ausweg vorgespielt
+ * bekommt, den es nicht gibt.
+ */
+export function firmenZeilen(namen) {
+    const anzahl = (name) => namen.filter((n) => n === name).length;
+    const gesehen = new Set();
+    const zeilen = [];
+    for (const name of namen) {
+        if (gesehen.has(name))
+            continue;
+        gesehen.add(name);
+        const wieOft = anzahl(name);
+        if (wieOft === 1) {
+            // Fertiger Befehl statt blosser Liste: Der naechste Schritt ist dann
+            // Kopieren statt Abtippen -- und ein Name mit Leerzeichen braucht
+            // Anfuehrungszeichen, an die sonst niemand denkt.
+            zeilen.push(`    kimal3 firma daten --firma "${name}"`);
+        }
+        else {
+            zeilen.push(`    „${name}" — kommt ${wieOft}× vor und ist über den Namen nicht wählbar.`);
+        }
+    }
+    return zeilen;
+}
+/**
+ * Die Zeilen für den Fall, dass zwei Firmen **gleich heissen**.
+ *
+ * 🔑 **Das ist die zweite Haelfte von B-5** (2026-08-18 spaet). Die erste
+ * Haelfte nahm dem doppelten Namen seinen Befehl, damit niemand einen Ausweg
+ * vorgespielt bekommt, den es nicht gibt. Damit war die Irrefuehrung weg --
+ * aber an die Daten kam man immer noch nicht. Die Absage sagte „benenne eine
+ * davon um", und das setzt **Admin-Rechte in einer fremden Firma** voraus.
+ *
+ * *Eine Absage ohne Ausweg ist eine Sackgasse mit Begruendung.*
+ *
+ * Jetzt liefert die Route die IDs mit, und hier entstehen daraus wieder
+ * kopierfertige Befehle. Der Name steht als Kommentar dahinter -- eine nackte
+ * UUID sagt einem Menschen nichts, und zwei davon untereinander noch weniger.
+ */
+export function firmenIdZeilen(auswahl) {
+    return auswahl.map((f, i) => `    kimal3 firma daten --firma-id "${f.id}"   # ${f.name} (${i + 1}.)`);
+}

package/dist/kimal3.js

@@ -11,24 +11,21 @@
  * `kimal3 login`, bei 4 hilft genau das nicht. Wer beide auf dieselbe Zahl
  * legt, laesst Claude den falschen Rat geben.
  */
-import { leseAnmeldung } from "./anmeldung.js";
+import { readFileSync } from "node:fs";
+import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
 import { NichtAngemeldet } from "./api.js";
+import { hilfeText } from "./befehle-katalog.js";
+import { firmaDaten } from "./befehle/firma-daten.js";
 import { login } from "./befehle/login.js";
 import { logout } from "./befehle/logout.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { skillInstall } from "./befehle/skill-install.js";
-const HILFE = `
-  kimal3 — trag deine KI-Projekte dort ein, wo sie entstehen.
-
-  kimal3 login              Diesen Rechner mit deinem Konto verbinden
-  kimal3 logout             Verbindung wieder aufheben
-  kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
-  kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
-  kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen
-
-  Mehr zu einem Befehl:  kimal3 projekt neu --help
-`;
+// 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
+// `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
+// Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten
+// Befehl, die andere nicht, und keiner der beiden Orte wuesste davon.
+const HILFE = hilfeText();
 /**
  * Hilfe plus Zustand.
  *
@@ -42,10 +39,60 @@ const HILFE = `
  * ⚠️ Und KEIN Netzaufruf: Wer nur die Hilfe sehen will, soll nicht auf einen
  * Server warten. Ob die Anmeldung noch gilt, klaert der naechste echte Befehl.
  */
+/**
+ * Welche Version bin ich — und mit wem rede ich?
+ *
+ * ⚠️ **Die Zahl wird GELESEN, nicht abgetippt** (QA-Befund B-8, 2026-08-18).
+ * Stuende sie hier als Text, sagte die CLI nach dem naechsten `npm version`
+ * die alte Nummer -- dieselbe Zahl an zwei Tueren mit zwei Werten, genau das
+ * Muster, das in diesem Projekt schon zweimal zugeschlagen hat.
+ *
+ * 🔑 **Warum die Gegenstelle mit dazugehoert:** Der Fall, fuer den man diese
+ * Auskunft braucht, ist ein **Versatz** zwischen CLI und App (B-7). Dann
+ * helfen erst beide Angaben zusammen: welche CLI laeuft -- und gegen welche
+ * App sie spricht. Eine Version allein beantwortet die Frage nur halb.
+ *
+ * 📌 `../package.json` stimmt aus `dist/` **und** aus `src/`: Beide liegen
+ * eine Ebene unter `cli/`.
+ */
+function versionsZeilen() {
+    let version = "unbekannt";
+    try {
+        const roh = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        if (roh && typeof roh === "object" && "version" in roh) {
+            const v = roh.version;
+            if (typeof v === "string")
+                version = v;
+        }
+    }
+    catch {
+        // Kein Absturz, wenn die Datei fehlt: "unbekannt" ist eine ehrliche
+        // Antwort, ein Stapelabzug waere keine.
+    }
+    return `  kimal3 ${version}\n  spricht mit ${BASIS_URL}`;
+}
+/**
+ * Was diese Zeile sagen KANN — und was nicht.
+ *
+ * 🔴 **Sie liest nur die Datei, sie fragt den Server nicht** (Befund L-9,
+ * 2026-08-18). Hier stand vorher „● Angemeldet als …" — und genau das hat am
+ * selben Abend zehn Minuten Fehlersuche gekostet: Der Ausweis war
+ * serverseitig nicht mehr gueltig, die Zeile behauptete trotzdem munter
+ * „Angemeldet", und die Suche begann an der falschen Stelle.
+ *
+ * *Eine Behauptung ist keine Messung.* Der Zustand, den die Datei kennt,
+ * heisst „hier liegt ein Ausweis" — ob der Server ihn noch annimmt, weiss
+ * allein der Server.
+ *
+ * ⚠️ Bewusst wird trotzdem NICHT nachgefragt: `--version` soll ohne Netz
+ * antworten und darf keine Sekunde haengen. Der ehrliche Weg ist deshalb
+ * nicht mehr Auskunft, sondern **weniger Behauptung**.
+ */
 function zustandsZeile() {
     const a = leseAnmeldung();
     return a
-        ? `  ● Angemeldet als ${a.email}`
+        ? `  ● Ausweis hinterlegt für ${a.email}\n` +
+            "    (ob er noch gilt, zeigt erst der nächste Befehl)"
         : "  ● Nicht angemeldet.  →  kimal3 login";
 }
 async function haupt() {
@@ -56,6 +103,11 @@ async function haupt() {
         console.log(zustandsZeile() + "\n");
         return 0;
     }
+    if (wort === "--version" || wort === "-v" || wort === "version") {
+        console.log(versionsZeilen());
+        console.log(zustandsZeile() + "\n");
+        return 0;
+    }
     if (wort === "login")
         return login();
     if (wort === "logout")
@@ -64,6 +116,11 @@ async function haupt() {
         return projektNeu(argv.slice(2));
     if (wort === "projekt liste")
         return projektListe();
+    // ⚠️ Praefix-Vergleich wie bei `projekt neu` und NICHT `wort === "firma daten"`:
+    // `wort` enthaelt die Optionen mit, `firma daten --firma X` fiele bei einem
+    // Gleichheits-Vergleich durch und meldete "Den Befehl kenne ich nicht".
+    if (argv[0] === "firma" && argv[1] === "daten")
+        return firmaDaten(argv.slice(2));
     if (wort === "skill install")
         return skillInstall();
     console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);