kimal3 0.1.4 → 0.1.6

package/dist/befehle/skill-install.js

@@ -1,7 +1,9 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
+import { STEMPEL_MARKE } from "../nachricht.js";
+import { eigeneVersion } from "../version.js";
 /**
  * Namen, die frueher einmal ausgeliefert wurden und heute nicht mehr.
  *
@@ -25,6 +27,62 @@ const VERALTETE_BEFEHLE = [];
  * wird sie NICHT ueberschrieben, sondern uebersprungen und gemeldet.
  */
 const MARKE = "kimal3:erzeugt";
+/**
+ * Wohin das Skill installiert wird -- an EINER Stelle.
+ *
+ * 🔑 WARUM EXPORTIERT (Befund der vierten Review-Runde): `kimal3.ts` baute
+ * denselben Pfad ein zweites Mal zusammen, um dort den Stempel zu lesen. Zoege
+ * das Ziel je um, faende `existsSync` dort nichts, `skillZustand` antwortete
+ * "still" -- und Weg 2 waere lautlos tot. Kein Fehler, keine Meldung, nichts
+ * zum Bemerken.
+ *
+ * Dieselbe Lehre wie bei `version.ts`, nur eine Stunde spaeter: *Zwei
+ * Wahrheiten ueber denselben Ort driften, und die zweite verrottet, ohne
+ * dass jemand hinsieht.*
+ */
+export function skillOrdner() {
+    return join(homedir(), ".claude", "skills", "kimal3");
+}
+export function skillDatei() {
+    return join(skillOrdner(), "SKILL.md");
+}
+/**
+ * Haengt die eigene Versionsnummer ans ENDE des Skill-Textes.
+ *
+ * 🔴 DER STEMPEL BESCHREIBT DIE SKILL.md -- NICHT DEN GANZEN LAUF.
+ * Diese Zuordnung hat drei Review-Runden gekostet und wurde zweimal falsch
+ * entschieden; sie steht hier ausfuehrlich, damit es kein viertes Mal gibt:
+ *
+ *   Runde 2 verschob den Stempel ans Ende des Befehls, damit ein halber Lauf
+ *   nicht "alles aktuell" behauptet. Runde 3 fand eine Luecke darin, Runde 4
+ *   flickte den Rueckgabewert -- und Runde 5 zeigte, dass die ganze Richtung
+ *   falsch war: Bei JEDEM stabilen Fehlschlag danach (fremde k3*.md im
+ *   Ordner, schreibgeschuetzter Befehlsordner) ist die SKILL.md geschrieben,
+ *   aber ungestempelt. `skillZustand` antwortet dann "veraltet", die CLI
+ *   meldet TAEGLICH "deine Skilldateien sind aelter, tippe kimal3 skill
+ *   install" -- und genau dieser Befehl stellt denselben Zustand wieder her.
+ *
+ * *`skillZustand` liest die SKILL.md. Also muss der Stempel ueber die SKILL.md
+ * sprechen und ueber nichts sonst.* Ist sie geschrieben, ist sie aktuell --
+ * unabhaengig davon, was mit den Slash-Befehlen passiert ist. Deren Zustand
+ * meldet der Befehl mit Text und Rueckgabewert, sofort und einmalig; das ist
+ * der richtige Kanal dafuer, nicht ein taeglicher Hinweis, den niemand
+ * abstellen kann.
+ *
+ * 🔑 Und er entsteht in DERSELBEN Schreiboperation wie die Datei. Kein zweites
+ * Lesen, kein zweites Schreiben, kein Zustand dazwischen, in dem die Datei
+ * ohne ihren Stempel dasteht.
+ *
+ * ⚠️ Ohne eigene Nummer GAR KEIN Stempel. Ein erfundener Ersatzwert waere
+ * schlimmer als keiner: Die CLI vergliche spaeter gegen ihre eigene Erfindung.
+ * Ohne Stempel antwortet `skillZustand` "veraltet" -- die harmlose Seite.
+ */
+function mitStempel(inhalt) {
+    const eigene = eigeneVersion();
+    if (eigene === null)
+        return inhalt;
+    return `${inhalt.trimEnd()}\n\n<!-- ${STEMPEL_MARKE}${eigene} -->\n`;
+}
 /**
  * Legt das Skill UND die Slash-Befehle GLOBAL ab, damit Claude dieses Werkzeug
  * ueberall kennt -- und damit der Mensch es auch selbst ausloesen kann.
@@ -63,14 +121,46 @@ export async function skillInstall() {
     // Erfolgsprofil ein" gilt in JEDEM Ordner, nicht in einem. Wer projektlokal
     // installiert, hat das Werkzeug im naechsten Projekt nicht -- und merkt es
     // erst, wenn er dort vergeblich "fertig" sagt.
-    const zielOrdner = join(homedir(), ".claude", "skills", "kimal3");
-    const ziel = join(zielOrdner, "SKILL.md");
+    const zielOrdner = skillOrdner();
+    const ziel = skillDatei();
     // Vorher merken: "angelegt" und "aktualisiert" sind zwei verschiedene
     // Wirklichkeiten und bekommen deshalb zwei verschiedene Meldungen.
     const gabEsSchon = existsSync(ziel);
     try {
         mkdirSync(zielOrdner, { recursive: true });
-        copyFileSync(quelle, ziel);
+        /*
+          🔴 DER STEMPEL GEHOERT ANS ENDE, NIEMALS AN DEN ANFANG. SKILL.md beginnt
+          in Zeile 1 mit YAML-Frontmatter (`---`, dann `name:`). Steht davor
+          irgendetwas, ist es kein Frontmatter mehr -- der Skill wird dann gar
+          nicht geladen, und zwar OHNE Fehlermeldung. Ein Update-Hinweis, der den
+          Skill abschaltet, den er aktuell halten soll, ist der teuerste denkbare
+          Fehler in dieser Scheibe.
+    
+          Deshalb auch lesen-anhaengen-schreiben statt copyFileSync: Der Stempel
+          entsteht beim KOPIEREN, er steht nicht in der Quelle -- sonst truege das
+          Paket seine Versionsnummer an zwei Orten, und die zweite verrottet.
+    
+          🔴 OHNE eigene Versionsnummer wird GAR KEIN Stempel geschrieben, sondern
+          unveraendert kopiert. `eigeneVersion()` liefert `null`, wenn
+          `cli/package.json` fehlt oder Unsinn enthaelt. Ein Stempel mit einem
+          erfundenen Ersatzwert waere hier schlimmer als keiner: Die CLI vergliche
+          spaeter gegen ihre eigene Erfindung und meldete entweder ein Update, das
+          es nicht gibt, oder schwiege zu einem, das faellig ist. Ohne Stempel
+          antwortet `skillZustand` dagegen "veraltet" -- die harmlose Seite, denn
+          ein zweites `kimal3 skill install` kostet nichts.
+    
+          ⚠️ Die Marke `kimal3:erzeugt` (Konstante MARKE oben) steckt in
+          `STEMPEL_MARKE` und bleibt damit erhalten. Der Stempel ist eine
+          ERWEITERUNG dieser Marke, kein Ersatz -- `raeumeVeralteteAuf` und die
+          Ueberschreib-Pruefung erkennen unsere eigenen Dateien genau daran.
+    
+          📌 Er entsteht HIER, in derselben Schreiboperation wie die Datei -- und
+          zwar wieder, nachdem er drei Runden lang am Ende des Befehls stand.
+          Warum die Ruecknahme richtig ist, steht ausfuehrlich bei `mitStempel`:
+          Der Stempel spricht ueber die SKILL.md, nicht ueber den ganzen Lauf.
+        */
+        const inhalt = readFileSync(quelle, "utf8");
+        writeFileSync(ziel, mitStempel(inhalt), "utf8");
     }
     catch (fehler) {
         console.error(`Das Skill liess sich nicht schreiben: ${String(fehler)}`);
@@ -142,6 +232,22 @@ export async function skillInstall() {
         console.error("  Die oben genannten stehen; ein zweiter Lauf holt den Rest.");
         return 3;
     }
+    /*
+      🔴 Eine nicht lesbare Datei ist ein UNVOLLSTAENDIGER Lauf und bekommt
+      deshalb `3`, genau wie `gestoert` (Befund der vierten Review-Runde).
+      `3` heisst laut SKILL.md "einmal wiederholen", und das passt zur Lage:
+      Eine Datei in Benutzung ist gleich wieder frei.
+  
+      📌 Der STEMPEL haengt hier nicht mehr dran -- er entsteht beim Schreiben
+      der SKILL.md und beschreibt nur sie (ausfuehrliche Begruendung bei
+      `mitStempel` oben). Bis zur fuenften Review-Runde stand er an dieser
+      Stelle, und jeder stabile Fehlschlag danach erzeugte einen taeglichen
+      Hinweis, den kein Befolgen aufloesen konnte.
+    */
+    if (unlesbar.length > 0) {
+        console.error("  Der Lauf ist damit unvollstaendig -- ein zweiter Versuch 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

package/dist/befehle/werkbank.js

@@ -0,0 +1,389 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { dateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
+import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
+/**
+ * Legt **nur eine Werkbank** an — in einem Firmen-Ordner, der schon steht.
+ *
+ * 🔴 **Warum es diesen Befehl gibt** (gefunden von Dennis am 2026-08-20, im
+ * Rollenspiel als Angestellter einer Kundenfirma — nicht von einem Prüfer, und
+ * nicht in fünf Review-Runden). Gemessen:
+ *
+ *     Im bestehenden Firmen-Ordner nochmal `kimal3 arbeitsplatz neu`
+ *       → „Der Ordner gibt es schon und ist nicht leer. Gib einen anderen
+ *          Namen an."
+ *     Also gibt er einen an: `kimal3 arbeitsplatz neu werkbank-sabine`
+ *       → ✓ 22 Dateien, darunter `werkbank-sabine/kontext/`
+ *
+ * Er bekommt **keinen Fehler**, sondern eine ZWEITE Firma im Bauch der ersten:
+ * eigene `firma.md`, eigene `marke.md`, eigene `sicherheit.md`. Und der
+ * Fehlertext des Befehls **schlägt diesen Weg selbst vor**.
+ *
+ * 🔑 **Die Vorlage wusste längst, dass es anders sein sollte.** Die
+ * Firmen-`.gitignore` erklärt in ihrem eigenen Kommentar die Ordner
+ * `werkbank-<name>` als Geschwister neben `kontext/`. *Der Entwurf sah eine
+ * Form vor, die die CLI nicht herstellen konnte.*
+ *
+ *     arbeitsplatz neu  →  einmal pro FIRMA   (die ganze Familie)
+ *     werkbank neu      →  einmal pro MENSCH  (nur der eigene Teil)
+ *
+ * 🔴 **GRENZE, die dieser Befehl heute NICHT aufhebt** (Review-Runde 4 zu
+ * PR #25, nachgemessen an `src/lib/pro/zugang.ts`): Er holt die Vorlage über
+ * `/api/cli/arbeitsplatz`, und die Tür dort fragt `istPro(user_id)` — eine
+ * Zeile in `konto_plan`, **pro Person**. Es gibt keinen Weg über
+ * `memberships`/`organizations`.
+ *
+ * Der zweite Mensch einer Kundenfirma — also genau der, für den dieser Befehl
+ * gebaut wurde — braucht damit ein **eigenes Pro-Konto**. Hat er keins,
+ * bekommt er `402` und Rückgabewert `4`, und `SKILL.md` weist Claude dort
+ * ausdrücklich an, NICHT zu wiederholen.
+ *
+ * ⚠️ Das ist **keine Panne, sondern eine offene Produktfrage**: Erbt ein
+ * Firmenmitglied den Zugang, oder kauft jeder einzeln? Sie gehört Dennis, nicht
+ * diesem Befehl — deshalb steht sie in `WEITER-HIER.md` unter „Entscheidungen"
+ * und nicht als stille Erweiterung von `istPro` hier drin.
+ * *Eine Grenze, die man benennt, ist etwas anderes als eine, die man
+ * übersieht* — und sie reiht sich neben die schon bekannte: Der Angestellte hat
+ * ohnehin noch keinen gebauten Weg an den Firmen-Ordner (Stufe 2).
+ *
+ * 🔴 **Die wichtigste Eigenschaft: Er fasst die Firmenebene NICHT an.** Kein
+ * einziges Byte in `kontext/`, `CLAUDE.md`, `README.md`, `.gitignore` — auch
+ * nicht schreibend „identisch drüber". Das ist keine Höflichkeit, sondern
+ * Vorbereitung: Perspektivisch soll die Firma ihre `kontext/`-Ebene zentral
+ * verwalten (s. `WEITER-HIER.md`, Entscheidungen). Was dann von außen kommt,
+ * darf ein lokaler Befehl nicht überschreiben.
+ */
+const HILFE = `
+  kimal3 werkbank neu [dein-vorname]
+
+  Legt eine eigene Werkbank in einem bestehenden Firmen-Ordner an.
+  Die Firmenebene (kontext/, CLAUDE.md, README.md) wird NICHT angefasst.
+
+  dein-vorname  Optional. Der Ordner traegt deinen Namen -- aus "sabine"
+                wird "werkbank-sabine". Ohne Angabe steht dort der Name,
+                den der Server aus deiner Anmelde-Adresse gebildet hat.
+
+  🔴 Bricht ab, wenn der Zielordner schon existiert und NICHT leer ist.
+
+  Du hast noch gar keinen Firmen-Ordner?
+     kimal3 arbeitsplatz neu <dein-vorname>
+`;
+/**
+ * 🔴 **Review-Runde 2 zu PR #25 — und es ist DERSELBE Fehler wie in Runde 1,
+ * nur eine Datei weiter.** Hier stand:
+ *
+ *     Gib einen anderen Namen an:
+ *       kimal3 werkbank neu <ein-anderer-vorname>
+ *
+ * Der haeufigste Grund fuer diese Absage ist, dass der Mensch seine Werkbank
+ * **schon angelegt hat**. Befolgt er den Rat, bekommt er eine ZWEITE
+ * persoenliche Werkbank neben der ersten (`werkbank-sabine-2`) — dieselbe
+ * stille Verdopplung, die dieser PR bei `arbeitsplatz neu` gerade beseitigt
+ * hat.
+ *
+ * *Ich habe den Fehler bei einem Befehl behoben und ihn beim Zwilling stehen
+ * lassen — obwohl die Behebung des einen der Anlass fuer den anderen war.*
+ *
+ * Der Rat nennt jetzt zuerst den wahrscheinlichen Fall (du bist es selbst) und
+ * dann den seltenen (du bist es nicht).
+ *
+ * ⚠️ Und er ist eine FUNKTION, keine Konstante -- aus demselben Grund wie beim
+ * Zwilling in `arbeitsplatz.ts`: Der Befehl kennt den Ordner, in den er schickt.
+ * Ein Platzhalter wie `cd <der-ordner-oben>` waere eine Luecke, die der Mensch
+ * fuellen muss, obwohl die Antwort danebensteht. *Ein Platzhalter ist ein
+ * Eingestaendnis, dass man es nicht weiss -- hier weiss man es.*
+ */
+function hinweisFuer(ordnerName) {
+    const ziel = ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName;
+    return ("  Ist das DEINE Werkbank? Dann steht sie schon -- geh einfach hinein:\n" +
+        `    cd ${ziel}\n` +
+        "  Bist du es nicht, nimm deinen eigenen Vornamen:\n" +
+        "    kimal3 werkbank neu <dein-vorname>");
+}
+export async function werkbankNeu(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    /*
+      Dieselben drei Absagen wie bei `arbeitsplatz neu` -- bewusst wortgleich: Wer
+      den einen Befehl kennt, soll beim anderen nichts Neues lernen muessen.
+  
+      ⚠️ Sie sprechen seit dem 2026-08-20 von einem NAMEN statt von einem
+      Ordnernamen. Die alte Hilfe hier hat ausdruecklich
+      `kimal3 werkbank neu werkbank-sabine` beigebracht -- deshalb schneidet
+      `werkbankOrdnerAus` ein bereits mitgetipptes `werkbank-` wieder ab, statt
+      `werkbank-werkbank-sabine` zu bauen. *Alte Anleitungen ueberleben laenger
+      als der Code, den sie beschreiben.*
+    */
+    const nameArg = argv[0];
+    if (nameArg !== undefined && nameArg.trim() === "") {
+        console.error(`Ein leerer Name ist kein gueltiger Name.\n${HILFE}`);
+        return 1;
+    }
+    if (nameArg !== undefined && nameArg.startsWith("--")) {
+        console.error(`Die Option „${nameArg}" kenne ich nicht.\n${HILFE}`);
+        return 1;
+    }
+    if (argv.length > 1) {
+        /*
+          🔴 **Der Vorschlag darf keine Optionen einsammeln** (Review-Runde 5 zu
+          PR #25). Hier stand `argv.join("-")` -- aus `werkbank neu sabine --force`
+          wurde damit der Rat `werkbank neu sabine---force`. Die `--`-Wache ein paar
+          Zeilen hoeher sieht nur `argv[0]`.
+          *Ein Rat, der ein falsches Kommando erzeugt, ist schlimmer als keiner* --
+          dieselbe Klasse wie die Absagen aus Runde 1 und 2, nur kleiner.
+    
+          Deshalb: Sieht irgendein Wort wie eine Option aus, gibt es gar keinen
+          Vorschlag. Ein Mensch, der `--force` tippt, sucht keine Schreibhilfe fuer
+          seinen Vornamen.
+        */
+        const woerter = argv.filter((w) => !w.startsWith("-"));
+        const vorschlag = woerter.length === argv.length && woerter.length > 1
+            ? `Besteht dein Name aus mehreren Woertern? Dann schreib ihn zusammen:\n` +
+                `  kimal3 werkbank neu ${woerter.join("-")}\n`
+            : "";
+        console.error(`Mit „${argv[1]}" kann ich hier nichts anfangen -- nur EIN Name ist erlaubt.\n` +
+            `${vorschlag}${HILFE}`);
+        return 1;
+    }
+    // `null` heisst: nach dem Umschreiben blieb kein Zeichen uebrig, das in einem
+    // Ordnernamen stehen darf. Ein Mensch hat hier getippt und verdient eine
+    // Antwort -- der Server schweigt im selben Fall und bleibt beim Vordruck.
+    let gewuenschteWerkbank = null;
+    if (nameArg !== undefined) {
+        gewuenschteWerkbank = werkbankOrdnerAus(nameArg);
+        if (gewuenschteWerkbank === null) {
+            console.error(`Aus „${nameArg}" kann ich keinen Ordnernamen machen -- es bleiben nur`);
+            console.error("Zeichen uebrig, die in keinem Ordnernamen stehen duerfen.");
+            console.error("");
+            console.error("  Nimm deinen Vornamen:  kimal3 werkbank neu sabine");
+            return 1;
+        }
+    }
+    const holen = await vorlageHolen();
+    if (!holen.ok)
+        return holen.wert;
+    const daten = holen.daten;
+    const werkbank = werkbankOrdner(daten.dateien);
+    /*
+      🔴 **Review-Runde 1 zu PR #25: eine Asymmetrie zur Schwesterdatei.**
+      `arbeitsplatz.ts` prueft `daten.wurzel` ausdruecklich mit `istUnsichererPfad`
+      („kommt genauso ROH vom Server wie jeder `datei.pfad` -- dieselbe Bremse").
+      Hier wurde `werkbank` genauso roh benutzt, nur ungeprueft.
+  
+      Der Fall: Eine manipulierte Antwort (z. B. ueber ein umgebogenes
+      `KIMAL3_URL`) enthaelt den Pfad `../CLAUDE.md`. `werkbankAusDateien` zerlegt
+      ihn in zwei Teile und liefert `".."` -- und `dateienSchreiben` macht daraus
+      `resolve("..")`, also den ELTERNORDNER.
+  
+      ⚠️ Und die Firmen-Wache faengt das nicht: `firmenEbeneAus` gibt fuer so eine
+      Antwort eine leere Liste zurueck, `fehlend.length > 0` ist damit falsch, und
+      die Pruefung geht still durch.
+  
+      🔬 **Ehrlich nachgemessen: fuer `..` haette er trotzdem nichts geschrieben.**
+      Der Angriff wurde mit einem eigenen Server nachgestellt (Antwort mit
+      `../CLAUDE.md`), einmal mit und einmal ohne diese Bremse. Ohne sie faengt ihn
+      der Nicht-leer-Riegel in `dateienSchreiben`: Ein Elternordner enthaelt immer
+      mindestens den Ordner, in dem man steht, ist also nie leer.
+  
+      🔴 **Fuer `""` stimmte das NICHT -- und genau das stand hier als Begruendung**
+      (Review-Runde 2). Der Satz lautete, `""` fuehre auf das aktuelle Verzeichnis,
+      „das `kontext/` enthaelt, sonst waere die Wache oben schon rot". Ist sie
+      aber nicht: Bei einer Antwort aus `/CLAUDE.md` liefert `werkbankAusDateien`
+      den leeren Teil `""`, und `firmenEbeneAus` UEBERSPRINGT genau diese Pfade
+      (`teile[0] === werkbank`) -- die Firmen-Wache sieht `[]` und laesst durch.
+      In einem leeren Ordner waeren die Dateien dann dorthin gelandet, wo der
+      Mensch steht.
+      *Ein Kommentar, der eine Luecke mit einer anderen Wache begruendet, muss
+      diese Wache im FEHLERFALL gelesen haben, nicht im Normalfall.*
+      Deshalb prueft hier jetzt `istUnsichererOrdnername` statt
+      `istUnsichererPfad`: Ein Ordnername ist EIN Pfadteil, und der ist weder leer
+      noch `.` noch `..`.
+  
+      🔑 **Der Gewinn ist deshalb die MELDUNG, nicht die Abwehr.** Ohne diese
+      Zeile las der Mensch *„Der Ordner `..` gibt es schon und ist nicht leer. Gib
+      einen anderen Namen an"* -- und sucht den Fehler bei sich, obwohl der Server
+      luegt. Jetzt steht dort `Bitte melden`, und der Rueckgabewert ist `3` statt
+      `1`, also „Stoerung" statt „deine Eingabe passt nicht". *Kein Fehlerfall
+      traegt den Namen eines anderen* -- und dass die Abwehr schon anderswo steht,
+      ist kein Grund, sie hier falsch zu benennen.
+    */
+    if (werkbank !== null && istUnsichererOrdnername(werkbank)) {
+        console.error(`Die Antwort enthaelt einen unsicheren Ordnernamen: „${werkbank}". Bitte melden.`);
+        return 3;
+    }
+    if (werkbank === null) {
+        console.error("In der Vorlage steckt kein Werkbank-Ordner -- damit kann ich hier nichts anlegen.");
+        console.error("Bitte melden.");
+        return 3;
+    }
+    /*
+      🔑 **Die Prüfung, ob wir überhaupt in einer Firma stehen** -- und sie ist
+      keine Förmlichkeit: In `<werkbank>/.claude/settings.json` steht
+      `"additionalDirectories": ["../kontext"]`. Eine Werkbank ohne Firmenebene
+      daneben zeigt damit ins Leere, und Claude fände den Firmenkontext nie.
+      Das merkt man erst Tage später -- genau die Sorte Fehler, gegen die dieser
+      Befehl gebaut wurde.
+  
+      ⚠️ Welche Ordner das sind, wird ABGELEITET und nicht getippt (dieselbe Regel
+      wie bei `werkbankOrdner`): Firmenebene ist alles, was in der Lieferung
+      NEBEN dem Werkbank-Ordner in einem eigenen Unterordner liegt. Heute ist das
+      `kontext`. Wird die Vorlage umgebaut, wandert diese Prüfung mit -- statt
+      auf einen Ordnernamen zu zeigen, den es nicht mehr gibt.
+    */
+    const firmenOrdner = firmenEbeneAus(daten.dateien, werkbank);
+    const fehlend = firmenOrdner.filter((o) => !istOrdner(o));
+    /*
+      🔴 **Die leere Liste ist ein eigener Fall** (Review-Runde 3 zu PR #25).
+      Vorher stand hier nur `fehlend.length > 0` -- und eine LEERE Liste hat
+      nichts, was fehlen koennte. Liefert die Antwort keine Firmenebene, ging die
+      Wache still durch und legte die Werkbank in irgendein Verzeichnis, in dem
+      der Mensch gerade steht. Ihr `../kontext` zeigte dann ins Leere.
+      *Eine Wache, die aus einer leeren Liste „alles in Ordnung" liest, hat die
+      Frage nicht gestellt, fuer die sie gebaut wurde.*
+  
+      Heute nicht ausloesbar (`check:arbeitsplatz` Pruefung 2 erzwingt `kontext/*`)
+      -- erreichbar also nur ueber eine kaputte oder manipulierte Antwort.
+    */
+    /*
+      🔴 **ZWEI Wirklichkeiten, zwei Ausgaenge** (Review-Runde 4 zu PR #25, und der
+      Fehler stammt aus dem Fix von Runde 3).
+  
+      Runde 3 hat `firmenOrdner.length === 0` mit in dieselbe Bedingung gehaengt.
+      Dieser Zweig hat per Definition NICHTS in `fehlend` -- `join` lieferte `""`,
+      und der Mensch las woertlich *„Hier steht kein Firmen-Ordner -- ich sehe
+      kein ."* Beim Reparieren fiel der zweite Teil auf: Danach folgten
+      unveraendert die Raete fuer jemanden, der am FALSCHEN ORT steht („Geh
+      dorthin", „Bist du der ERSTE in deiner Firma?"). Die helfen nicht, wenn der
+      SERVER kaputt ist.
+  
+      *Ein Fehlerfall darf nie denselben Namen tragen wie ein anderer* -- und der
+      Rueckgabewert ist Teil des Namens: `3` heisst laut `cli/skill/SKILL.md`
+      „Stoerung, gleich noch einmal", `1` heisst „deine Eingabe passt nicht".
+      Eine kaputte Lieferung ist keine falsche Eingabe.
+    */
+    if (firmenOrdner.length === 0) {
+        console.error("Die Vorlage vom Server nennt gar keine Firmenebene -- damit kann ich");
+        console.error("nicht pruefen, ob du an der richtigen Stelle stehst.");
+        console.error("Das liegt nicht an dir. Bitte melden.");
+        return 3;
+    }
+    if (fehlend.length > 0) {
+        console.error("Hier steht kein Firmen-Ordner -- ich sehe kein " + fehlend.join(", ") + ".");
+        console.error("Eine Werkbank braucht die Firmenebene daneben; ohne sie findet Claude");
+        console.error("euren Firmenkontext nicht.");
+        console.error("");
+        console.error("  Steht er woanders? Geh dorthin und versuch es dort noch einmal.");
+        console.error("");
+        /*
+          🔴 **Hier stand „Du hast noch keinen? kimal3 arbeitsplatz neu"**
+          (Befund Dennis, 2026-08-20, wenige Minuten nach dem Bauen). Das ist
+          derselbe falsche Rat wie der aus `SKILL.md`, nur eine Ebene hoeher:
+    
+          Fuer den ERSTEN Menschen einer Firma stimmt er. Fuer den ZWEITEN --
+          also genau den, fuer den dieser Befehl gebaut wurde -- legt er eine
+          leere Zweitfirma an, statt ihn an die echte zu bringen. Und diese
+          zweite Firma ist schlimmer als die verschachtelte von vorhin: Sie
+          sieht voellig richtig aus.
+    
+          *Ich habe den Fehler aus SKILL.md entfernt und ihn in meiner eigenen
+          Absage wieder eingebaut. Ein Rat, der fuer die Haelfte der Leser
+          falsch ist, muss die Haelften benennen.*
+    
+          ⚠️ Der zweite Fall hat heute KEINE gute Antwort -- der Angestellte hat
+          keinen gebauten Weg an den Firmen-Ordner seiner Firma (s. WEITER-HIER,
+          "Verwaltet die Firma ihre kontext/-Ebene kuenftig in der App?"). Solange
+          das so ist, ist die ehrliche Auskunft „frag, wo er liegt" -- und nicht
+          ein Befehl, der etwas Falsches anlegt.
+        */
+        console.error("  Bist du der ERSTE in deiner Firma?");
+        console.error("    kimal3 arbeitsplatz neu <dein-vorname>");
+        console.error("");
+        console.error("  Hat deine Firma schon einen? Dann hol dir DEN -- z. B. als Kopie");
+        console.error("  oder ueber euer Repo. Leg keinen neuen an, sonst habt ihr zwei");
+        console.error("  verschiedene Firmenordner mit verschiedenen Regeln darin.");
+        return 1;
+    }
+    /*
+      🔑 Der Zielordner ist der Werkbank-Name -- entweder der, den der Server
+      schon gesetzt hat (`werkbank`, aus der Anmelde-Adresse gebildet), oder der
+      mitgegebene. Der Ordner TRAEGT damit immer einen Namen, und genau darum ging
+      es bei der Umbenennung: *Wo ein Name im Ordner steht, gehoert er einer
+      Person; wo keiner steht, gehoert er allen.*
+    */
+    const ordnerName = gewuenschteWerkbank ?? werkbank;
+    /*
+      Erst UMBENENNEN, dann ausschneiden -- und zwar auch im Inhalt.
+  
+      ⚠️ **Hier stand: „Die Dateien muessen dafuer nicht umgeschrieben werden."**
+      Der Satz war wahr, als ich ihn schrieb: Heute nennt keine Datei unterhalb der
+      Werkbank ihren eigenen Ordner (nachgemessen), und die Texte, die ihn nennen,
+      gehoeren zur Firmenebene, die dieser Befehl nicht anfasst.
+  
+      Nur HAELT das nichts. Wer morgen in die Werkbank-`CLAUDE.md` schreibt „deine
+      Projekte liegen in `werkbank-sabine/projekte/`", baut damit einen Satz ein,
+      der beim naechsten Menschen auf den falschen Ordner zeigt -- ohne dass etwas
+      fehlschlaegt. *Die Prueffrage aus CLAUDE.md: Beschreibt der Kommentar ein
+      Verhalten, das jemand WILL -- oder nur eines, das PASSIERT?* Hier passierte
+      es. Also nehmen wir die Annahme heraus, statt eine Wache um sie zu bauen.
+  
+      Die Reihenfolge ist der ganze Trick: Nach dem Umbenennen heisst der Praefix
+      schon wie das Ziel, und der Ausschnitt schneidet ihn mit derselben
+      Zeichenkette weg, die vorher eingesetzt wurde. Aus `werkbank-jonas/CLAUDE.md`
+      wird `CLAUDE.md`, das Ziel ist der neue Ordner selbst.
+  
+      🔑 Das ist die einzige Stelle, an der sich dieser Befehl vom grossen
+      unterscheidet -- alles andere (Ueberschreib-Schutz, Pfad-Pruefung, Fehler-
+      Trennung) ist dieselbe Maschinerie aus `arbeitsplatz-dateien.ts`.
+    */
+    const umbenannt = werkbankUmbenennen(daten.dateien, werkbank, ordnerName);
+    const praefix = `${ordnerName}/`;
+    const meine = umbenannt
+        .filter((d) => d.pfad.startsWith(praefix))
+        .map((d) => ({ pfad: d.pfad.slice(praefix.length), inhalt: d.inhalt }));
+    const wert = dateienSchreiben(meine, ordnerName, hinweisFuer(ordnerName));
+    if (wert !== 0)
+        return wert;
+    console.log(`✓ ${meine.length} ${meine.length === 1 ? "Datei" : "Dateien"} angelegt.`);
+    console.log(`  ${resolve(ordnerName)}`);
+    console.log("");
+    console.log("  Die Firmenebene ist unberuehrt geblieben.");
+    console.log("");
+    console.log("  Weiter geht's:");
+    console.log(`    cd ${ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName}`);
+    console.log("    claude");
+    console.log('    dann "Lass uns einrichten" tippen');
+    return 0;
+}
+/**
+ * Die Ordner der Firmenebene, aus der Lieferung abgeleitet: jeder erste
+ * Pfad-Teil, der einen Unterordner benennt und nicht die Werkbank ist.
+ *
+ * Dateien direkt an der Wurzel (`CLAUDE.md`, `README.md`, `.gitignore`) zaehlen
+ * bewusst NICHT mit: Sie sagen weniger verlaesslich, dass hier eine Firma steht
+ * -- eine `CLAUDE.md` liegt in fast jedem Projektordner.
+ */
+function firmenEbeneAus(dateien, werkbank) {
+    const ordner = new Set();
+    for (const datei of dateien) {
+        const teile = datei.pfad.split("/");
+        if (teile.length < 2)
+            continue;
+        if (teile[0] === werkbank)
+            continue;
+        ordner.add(teile[0]);
+    }
+    return [...ordner].sort();
+}
+function istOrdner(name) {
+    try {
+        return existsSync(name) && statSync(name).isDirectory();
+    }
+    catch {
+        // Nicht lesbar heisst "kann ich nicht bestaetigen" -- und was ich nicht
+        // bestaetigen kann, behandle ich als fehlend. Lieber eine Absage zu viel
+        // als eine Werkbank, die ins Leere zeigt.
+        return false;
+    }
+}

package/dist/befehle-katalog.js

@@ -47,6 +47,43 @@ export const BEFEHLE = [
             "Geklappt hat es, wenn er „Skill angelegt“ meldet und die Slash-Befehle aufzählt. Beides kennt Claude ab der NÄCHSTEN Sitzung — die laufende einmal neu starten.",
         ],
     },
+    {
+        befehl: "kimal3 arbeitsplatz neu",
+        beschreibung: "Den ganzen KI-Arbeitsplatz anlegen — Firmenebene und Werkbank",
+        wer: "du",
+        rhythmus: "einmal pro Firma",
+        tippen: "! kimal3 arbeitsplatz neu",
+        terminal: "kimal3 arbeitsplatz neu",
+        details: [
+            "Holt die Vorlage von deinem Pro-Konto und legt sie hier als echten Ordner an — CLAUDE.md, Takt-Befehle, die Werkbank für deine Projekte. Dasselbe Paket, das auch als Download auf /pro liegt.",
+            "Der Ordner heißt immer KI-Arbeitsplatz — mehrere Firmen trennst du über den Ordner darüber, z. B. Kunden/ARNO/KI-Arbeitsplatz. Gib deinen Vornamen mit, dann heißt deine Werkbank darin werkbank-sabine: kimal3 arbeitsplatz neu sabine.",
+            "Gibt es den Zielordner schon und ist er nicht leer, bricht der Befehl ab, statt etwas zu überschreiben — deine Arbeit ist sicher. Geklappt hat es, wenn er die Zahl der angelegten Dateien nennt.",
+            "⚠️ Er legt auch die Firmenebene an (kontext/ mit Marke, Systemen, Sicherheit). Steht die schon, brauchst du kimal3 werkbank neu — sonst entsteht eine zweite Firma in der ersten.",
+        ],
+    },
+    /*
+      🔴 Der Eintrag steht direkt NEBEN `arbeitsplatz neu` und nicht am Ende der
+      Liste (die Reihenfolge ist laut Kopf dieser Datei „der Weg, den ein Mensch
+      geht"). Genau hier steht der Mensch vor der Verwechslung: Beide legen
+      Ordner aus derselben Vorlage an, und die falsche Wahl merkt man erst Tage
+      spaeter. Nebeneinander sind die verschiedenen `rhythmus`-Angaben --
+      „einmal pro Firma" gegen „einmal pro Mensch" -- die kuerzeste Erklaerung
+      des Unterschieds, die es gibt.
+    */
+    {
+        befehl: "kimal3 werkbank neu",
+        beschreibung: "Nur eine eigene Werkbank in einer bestehenden Firma anlegen",
+        wer: "du",
+        rhythmus: "einmal pro Mensch",
+        tippen: "! kimal3 werkbank neu",
+        terminal: "kimal3 werkbank neu",
+        details: [
+            "Für alle außer der ersten Person: Der Firmen-Ordner steht schon (kontext/ mit Marke, Systemen, Sicherheit) — du brauchst nur deinen eigenen Arbeitsplatz darin.",
+            "🔴 Er fasst die Firmenebene nicht an. Kein Byte in kontext/, CLAUDE.md oder README.md — auch nicht schreibend „identisch drüber“.",
+            "Er läuft nur, wenn du wirklich in einem Firmen-Ordner stehst. Fehlt die Firmenebene daneben, bricht er ab und sagt es — eine Werkbank ohne sie zeigt ins Leere, weil ihre Einstellungen auf ../kontext verweisen.",
+            "Gib deinen Vornamen mit — der Ordner trägt ihn: aus sabine wird werkbank-sabine. Ohne Angabe bildet der Server ihn aus deiner Anmelde-Adresse. So sieht man später, wem welche Werkbank gehört.",
+        ],
+    },
     {
         befehl: "kimal3 projekt neu …",
         beschreibung: "Ein Projekt ins Erfolgsprofil eintragen",
@@ -118,3 +155,25 @@ ${zeilen}
   Mehr zu einem Befehl:  kimal3 projekt neu --help
 `;
 }
+/**
+ * Wie ein Befehl **getippt** wird — aus dem Katalog geholt, nicht abgeschrieben.
+ *
+ * 🔑 **Warum das eine eigene Funktion ist** (2026-08-20): Auf `/pro` stand
+ * `const ANMELDEN = "! kimal3 login"` als Zeichenkette im Seitencode — eine
+ * zweite Wahrheit ueber einen Befehl, den der Katalog schon fuehrt. Wer im
+ * Katalog umbenennt, laesst sie stehen, und die Seite zeigt weiter den alten
+ * Aufruf. Dieselbe Klasse Fehler wie der fest getippte `cd`-Pfad in Runde 3.
+ *
+ * ⚠️ Sie **wirft**, statt einen leeren Text zu liefern. Die Aufrufer sind
+ * Modul-Konstanten — ein falscher Name fliegt damit beim `npm run build` auf,
+ * nicht erst beim Kunden vor einem Kopier-Kasten, in dem nichts steht.
+ * *Ein stiller Fehler auf einer bezahlten Seite ist teurer als ein lauter im
+ * Build.*
+ */
+export function tippBefehl(befehl) {
+    const eintrag = BEFEHLE.find((b) => b.befehl === befehl);
+    if (!eintrag) {
+        throw new Error(`Kein Katalog-Eintrag fuer „${befehl}". Steht der Befehl noch in BEFEHLE?`);
+    }
+    return eintrag.tippen;
+}