kimal3 0.1.5 → 0.2.0

package/dist/befehle/arbeitsplatz.js

@@ -1,7 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { feld, ruf } from "../api.js";
-import { schlussFehler } from "../fehler.js";
+import { resolve } from "node:path";
+import { dateienSchreiben, vorlageHolen, werkbankOrdner, istUnsichererOrdnername, } from "../arbeitsplatz-dateien.js";
+import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
 /**
  * Holt die KI-Arbeitsplatz-Vorlage vom Server und legt sie lokal an --
  * `CLAUDE.md`, Takt-Befehle, die Werkbank fuer eigene Projekte.
@@ -13,272 +12,249 @@ import { schlussFehler } from "../fehler.js";
  * Befehl die Struktur selbst zusammenbauen, gaebe es zwei Wahrheiten ueber
  * denselben Ordner, und sie liefen beim naechsten Aendern der Vorlage
  * auseinander.
+ *
+ * 📌 **Einmal pro FIRMA.** Er legt die ganze Ordnerfamilie an, also auch die
+ * Firmenebene (`kontext/` mit Marke, Systemen, Sicherheit). Wer nur eine
+ * weitere WERKBANK in einer bestehenden Firma braucht, nimmt
+ * `kimal3 werkbank neu` -- sonst entsteht eine zweite Firma im Bauch der
+ * ersten (gemessen am 2026-08-20, s. `befehle/werkbank.ts`).
+ *
+ * 🔁 Die Schreib-Maschinerie wohnt seit dem 2026-08-20 in
+ * `../arbeitsplatz-dateien.ts`, weil `werkbank neu` dieselbe braucht.
  */
 const HILFE = `
-  kimal3 arbeitsplatz neu [ordnername]
+  kimal3 arbeitsplatz neu [dein-vorname]
 
-  Holt deine KI-Arbeitsplatz-Vorlage und legt sie hier als Ordner an.
+  Holt deine KI-Arbeitsplatz-Vorlage und legt sie hier als Ordner an --
+  die ganze Familie: Firmenebene, Werkbank, Beispielprojekt.
 
-  ordnername   Optional. Ohne Angabe heisst der Ordner wie in der Vorlage.
+  Der Ordner heisst IMMER "KI-Arbeitsplatz". Mehrere Firmen trennst du
+  ueber den Ordner darueber, z. B. Kunden/ARNO/KI-Arbeitsplatz.
+
+  dein-vorname  Optional. Er benennt die WERKBANK darin -- 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 --
      eigene Arbeit wird dadurch nie versehentlich ueberschrieben.
+
+  Du hast schon einen Firmen-Ordner und brauchst nur eine eigene Werkbank?
+     kimal3 werkbank neu <dein-vorname>
 `;
+/*
+  🔴 **Der Rat in den Absagen hat sich am 2026-08-20 UMGEDREHT** -- und das ist
+  der Kern der Umbenennung, nicht ihr Nebeneffekt.
+
+  Vorher hiess er `kimal3 arbeitsplatz neu <anderer-name>`: "Der Ordner ist
+  belegt? Nimm einen anderen Namen." Genau diesen Rat hat Dennis am selben Tag
+  im Rollenspiel befolgt -- und bekam eine ZWEITE Firma im Bauch der ersten, mit
+  eigener `firma.md`, eigener `marke.md`, ohne jede Fehlermeldung. *Die Absage
+  schlug den Weg vor, gegen den `werkbank neu` gebaut werden musste.*
+
+  Jetzt heisst der oberste Ordner immer gleich. Damit KANN dieser Befehl keinen
+  zweiten Ordnernamen mehr vorschlagen -- und der einzige verbliebene Rat ist
+  der richtige.
+*/
+/**
+ * Was die Absage zum Weitermachen raet — **mit dem `cd`, das dazugehoert**.
+ *
+ * 🔴 **Review-Runde 1 zu PR #25, und es ist dieselbe Fehlerklasse, gegen die
+ * dieser PR gebaut wurde.** Hier stand nur der Befehl:
+ *
+ *     Steht dein Arbeitsplatz schon und dir fehlt nur die eigene Werkbank?
+ *       kimal3 werkbank neu <dein-vorname>
+ *
+ * Wer diese Absage liest, steht **ausserhalb** des Ordners — genau deshalb hat
+ * er sie ja bekommen („der Ordner gibt es schon"). Fuehrt er den Rat dort aus,
+ * findet `werkbank neu` kein `kontext/` daneben und bricht ab mit *„Hier steht
+ * kein Firmen-Ordner"*. Der Rat war richtig und der Ort falsch.
+ * *Ein Befehl ohne den Ort, an dem er laeuft, ist ein halber Rat.*
+ *
+ * ⚠️ Der Ordnername wird ABGELEITET, nicht getippt: Er kommt als `ordnerName`
+ * herein (aus `daten.wurzel`, also vom Server). Stuende hier `cd KI-Arbeitsplatz`
+ * fest im Text, waere das eine zweite Wahrheit ueber den Aufbau — dieselbe, die
+ * Runde 3 zu PR #24 auf `/pro` gefunden hat.
+ */
+function hinweisFuer(ordnerName) {
+    const ziel = ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName;
+    return ("  Steht dein Arbeitsplatz schon und dir fehlt nur die eigene Werkbank?\n" +
+        "  Dann geh HINEIN und leg sie dort an:\n" +
+        `    cd ${ziel}\n` +
+        "    kimal3 werkbank neu <dein-vorname>");
+}
 export async function arbeitsplatzNeu(argv) {
-    // ⚠️ VOR dem Lesen des Ordnernamens, wie bei `projekt neu` und
-    // `firma daten`: `--help` ist ein Schalter, kein Wert, der geprueft
-    // werden muesste.
     if (argv.includes("--help") || argv.includes("-h")) {
         console.log(HILFE);
         return 0;
     }
-    const ordnerArg = argv[0];
-    // 🔴 R2-2: Ein LEERES Argument ist kein "kein Argument" -- `?? daten.wurzel`
-    // greift nur bei `undefined`, ein leerer String bleibt stehen und `resolve("")`
-    // ist das aktuelle Verzeichnis. Wer "Ordner anlegen, hinein wechseln, Befehl
-    // tippen" macht, packt die Vorlage sonst versehentlich ins cwd.
-    if (ordnerArg !== undefined && ordnerArg.trim() === "") {
-        console.error(`Ein leerer Ordnername ist kein gueltiger Name.\n${HILFE}`);
+    /*
+      Dieselben drei Absagen wie bei `werkbank neu` -- bewusst wortgleich: Wer den
+      einen Befehl kennt, soll beim anderen nichts Neues lernen muessen.
+  
+      ⚠️ Sie sprechen jetzt von einem NAMEN, nicht von einem Ordnernamen. Das ist
+      keine Kosmetik: Wer nach der alten Hilfe `kimal3 arbeitsplatz neu ARNO-KI`
+      tippt, bekommt keinen Fehler, sondern eine Werkbank namens
+      `werkbank-arno-ki`. Diese Meldungen und die Hilfe sind die einzigen Stellen,
+      an denen er das erfaehrt, bevor es passiert.
+    */
+    const nameArg = argv[0];
+    if (nameArg !== undefined && nameArg.trim() === "") {
+        console.error(`Ein leerer Name ist kein gueltiger Name.\n${HILFE}`);
         return 1;
     }
-    if (ordnerArg !== undefined && ordnerArg.startsWith("--")) {
-        console.error(`Die Option „${ordnerArg}" kenne ich nicht.\n${HILFE}`);
+    if (nameArg !== undefined && nameArg.startsWith("--")) {
+        console.error(`Die Option „${nameArg}" kenne ich nicht.\n${HILFE}`);
         return 1;
     }
     if (argv.length > 1) {
-        console.error(`Mit „${argv[1]}" kann ich hier nichts anfangen -- nur EIN Ordnername ist erlaubt.\n${HILFE}`);
+        /*
+          🔴 **Der Vorschlag darf keine Optionen einsammeln** (Review-Runde 5 zu
+          PR #25). Hier stand `argv.join("-")` -- aus `arbeitsplatz neu sabine --force`
+          wurde damit der Rat `arbeitsplatz 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 arbeitsplatz neu ${woerter.join("-")}\n`
+            : "";
+        console.error(`Mit „${argv[1]}" kann ich hier nichts anfangen -- nur EIN Name ist erlaubt.\n` +
+            `${vorschlag}${HILFE}`);
         return 1;
     }
-    const antwort = await ruf("/api/cli/arbeitsplatz", { methode: "GET", mitAusweis: true });
-    if (antwort.status === 200) {
-        // 🔴 Ein `200` mit unlesbarem Rumpf ist KEIN Erfolg -- dieselbe Wache wie
-        // bei `firma daten`. `ruf` verschluckt Parse-Fehler zu `null`.
-        const daten = alsArbeitsplatzAntwort(antwort.koerper);
-        if (daten === null) {
-            console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
-            return 3;
+    /*
+      Der Name wird UMGESCHRIEBEN, nicht abgelehnt (s. `werkbankOrdnerAus`) --
+      "Sabine Mueller" ist ein gueltiger Name, nur kein gueltiger Ordner. `null`
+      heisst: Nach dem Umschreiben war nichts mehr uebrig (etwa bei "!!!"). Das ist
+      HIER ein Fehler, weil ein Mensch etwas getippt hat und eine Antwort verdient
+      -- 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 arbeitsplatz neu sabine");
+            return 1;
         }
-        return dateienAnlegen(daten, ordnerArg);
-    }
-    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 `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;
-    }
-    // 🔑 Den Rest entscheidet `schlussFehler` fuer alle Befehle gemeinsam --
-    // insbesondere die `404` (die App kennt die Route noch nicht) und `429`/
-    // `408` (ueberlastet, wiederholbar).
-    const schluss = schlussFehler(antwort.status, meldung);
-    console.error(schluss.text);
-    return schluss.wert;
-}
-/** Prueft die Antwort-Form, ohne `any` -- eine falsche Form ist unlesbar, keine Ausnahme. */
-function alsArbeitsplatzAntwort(koerper) {
-    if (!koerper || typeof koerper !== "object")
-        return null;
-    const wurzel = koerper.wurzel;
-    const dateienRoh = koerper.dateien;
-    if (typeof wurzel !== "string" || wurzel.trim() === "")
-        return null;
-    if (!Array.isArray(dateienRoh))
-        return null;
-    const dateien = [];
-    for (const eintrag of dateienRoh) {
-        if (!eintrag || typeof eintrag !== "object")
-            return null;
-        const pfad = eintrag.pfad;
-        const inhalt = eintrag.inhalt;
-        if (typeof pfad !== "string" || pfad.trim() === "")
-            return null;
-        if (typeof inhalt !== "string")
-            return null;
-        dateien.push({ pfad, inhalt });
-    }
-    return { wurzel, dateien };
-}
-/**
- * 🔴 **Nie ueberschreiben** -- die wichtigste Eigenschaft dieses Befehls.
- * Angelegt wird nur, wenn am Zielort NICHTS liegt oder ein LEERER Ordner.
- *
- * Genauer, weil hier zwei verschiedene Absagen stecken:
- * - Zielort ist eine **Datei** (auch eine leere): Abbruch. An einer Datei kann
- *   kein Ordner entstehen, ohne sie zu loeschen -- und geloescht wird nichts.
- * - Zielort ist ein **Ordner mit Inhalt**: Abbruch.
- * - Zielort ist ein **leerer Ordner** oder gibt es nicht: los geht's.
- *
- * ⚠️ **Hier stand "eine leere Datei ... ist kein Hindernis"** (Review-Runde 4 zu
- * PR #24) -- das war nie wahr. Wer `touch Mein-KI-Arbeitsplatz` gemacht hat oder
- * wessen Editor eine leere Datei dieses Namens liegen liess, bekam den Abbruch,
- * waehrend der Kommentar Durchlass versprach.
- * *Die Prueffrage aus CLAUDE.md: Beschreibt das ein Verhalten, das jemand WILL --
- * oder nur eines, das PASSIERT?* Hier wollte niemand das Beschriebene; der Code
- * war richtig und der Satz darueber falsch.
- */
-function dateienAnlegen(daten, ordnerArg) {
-    // 🔴 B-7: eine leere Lieferung ist ein FEHLERFALL, kein Erfolg mit null
-    // Dateien -- sonst meldet der Befehl "✓ 0 Dateien angelegt." und legt dabei
-    // nicht einmal einen Ordner an. Derselbe Rueckgabewert wie bei anderen
-    // unlesbaren Antworten (3): der Nutzer hat hier nichts falsch gemacht.
-    if (daten.dateien.length === 0) {
-        console.error("Die Antwort enthielt keine einzige Datei -- das ist kein gueltiges Ergebnis.");
-        console.error("Bitte gleich noch einmal versuchen.");
-        return 3;
-    }
-    const ordnerName = ordnerArg ?? daten.wurzel;
+    const holen = await vorlageHolen();
+    if (!holen.ok)
+        return holen.wert;
+    const daten = holen.daten;
     // 🔴 R2-1: `daten.wurzel` kommt genauso ROH vom Server wie jeder `datei.pfad`
     // -- dieselbe Gefahr (manipulierte Antwort, z. B. ueber ein umgebogenes
-    // `KIMAL3_URL`), dieselbe Bremse. Nur wenn KEIN eigener Ordnername uebergeben
-    // wurde, fliesst `daten.wurzel` ueberhaupt in den Zielpfad ein -- aber geprueft
-    // wird sie immer, damit hier nie zwischen "gerade unbenutzt" und "sicher"
-    // verwechselt wird.
-    if (istUnsichererPfad(daten.wurzel)) {
+    // `KIMAL3_URL`), dieselbe Bremse.
+    //
+    // ⚠️ **Hier stand: "Nur wenn KEIN eigener Ordnername uebergeben wurde, fliesst
+    // `daten.wurzel` ueberhaupt in den Zielpfad ein -- aber geprueft wird sie
+    // immer."** Das beschrieb die Welt vor dem 2026-08-20, in der ein Argument den
+    // Zielordner benennen konnte. Seit der Umbenennung heisst er IMMER wie
+    // `daten.wurzel`; die Pruefung ist damit nicht mehr die Vorsicht fuer einen
+    // selten benutzten Zweig, sondern der einzige Schutz, den dieser Wert hat.
+    // *Ein Kommentar, der die Wichtigkeit einer Pruefung kleinredet, ist gefaehr-
+    // licher als gar keiner -- er laedt zum Loeschen ein.*
+    // 🔴 `istUnsichererOrdnername`, nicht `istUnsichererPfad` (Review-Runde 2, als
+    // Zwilling des Befunds in `werkbank.ts` — dort gemeldet, hier selbst gesucht).
+    // `alsVorlageAntwort` faengt eine LEERE `wurzel` schon ab, aber nicht `"."`:
+    // `resolve(".")` ist das aktuelle Verzeichnis, und in einem leeren Ordner
+    // waere die ganze Familie einfach dorthin gefallen.
+    if (istUnsichererOrdnername(daten.wurzel)) {
         console.error(`Die Antwort enthaelt einen unsicheren Ordnernamen: „${daten.wurzel}". Bitte melden.`);
         return 3;
     }
-    const ziel = resolve(ordnerName);
     /*
-      🔴 Diese drei Aufrufe brauchen ein eigenes Netz (Review-Runde 3). Sie lagen
-      ausserhalb jedes `try`: Ist der Zielordner vorhanden, aber nicht lesbar
-      (fremder Besitzer, gesperrte Netzfreigabe -- EACCES), flog `readdirSync`
-      bis in den Auffang-Block von `kimal3.ts` durch. Der druckt dann
-      „kimal3 ist gerade nicht erreichbar." und gibt 3 zurueck.
+      🔑 Der Zielordner ist IMMER `daten.wurzel` ("KI-Arbeitsplatz") und kommt damit
+      vom Server statt aus der Eingabe. Die Pfad-Pruefung darueber ist deshalb
+      nicht mehr die Vorsicht fuer einen selten benutzten Zweig, sondern der
+      einzige Schutz, den dieser Wert ueberhaupt hat.
   
-      Das ist gleich doppelt falsch: Der Mensch sucht den Fehler beim Server,
-      obwohl er auf seiner eigenen Platte sitzt -- und 3 heisst fuer Claude laut
-      SKILL.md „gleich noch einmal versuchen", was hier nie helfen kann.
-      *Ein Fehlerfall darf nie denselben Namen tragen wie ein anderer.*
+      Der Name des Menschen wirkt eine Ebene tiefer, auf die Werkbank. Der Server
+      hat sie schon benannt (aus der Anmelde-Adresse); ein mitgegebener Name
+      sticht das.
     */
-    try {
-        if (existsSync(ziel)) {
-            if (!statSync(ziel).isDirectory()) {
-                console.error(`„${ordnerName}" gibt es schon -- als DATEI, nicht als Ordner.`);
-                console.error("Gib einen anderen Namen an: kimal3 arbeitsplatz neu <anderer-name>");
-                return 1;
-            }
-            /*
-              ⚠️ **Betriebssystem-Krimskrams zaehlt nicht als Inhalt** (Review-Runde 5).
-              `readdirSync` zaehlte vorher ALLES. Wer den Ordner angelegt und ihn nur
-              einmal im Finder (`.DS_Store`) oder Explorer (`desktop.ini`) geoeffnet
-              hat, bekam "gibt es schon und ist nicht leer" fuer einen Ordner, der fuer
-              ihn leer AUSSIEHT -- und keine Chance zu verstehen, warum. *Ein Grund, den
-              der Mensch nicht sehen kann, ist keine Begruendung, sondern eine Absage.*
-      
-              Bewusst eine geschlossene Liste und kein "alles, was mit Punkt anfaengt":
-              Eine `.env` oder ein `.git` IST Inhalt, und den fassen wir nicht an.
-            */
-            const OS_KRIMSKRAMS = [".DS_Store", "desktop.ini", "Thumbs.db"];
-            const echterInhalt = readdirSync(ziel).filter((n) => !OS_KRIMSKRAMS.includes(n));
-            if (echterInhalt.length > 0) {
-                console.error(`Der Ordner „${ordnerName}" gibt es schon und ist nicht leer.`);
-                console.error("Ich fasse ihn nicht an -- so geht nie versehentlich eigene Arbeit verloren.");
-                console.error("Gib einen anderen Namen an: kimal3 arbeitsplatz neu <anderer-name>");
-                return 1;
-            }
-        }
-    }
-    catch (fehler) {
-        console.error(`Ich komme an den Ordner „${ordnerName}" nicht heran.`);
-        console.error(`Grund: ${fehler instanceof Error ? fehler.message : String(fehler)}`);
-        console.error("Das liegt an diesem Rechner, nicht am Server -- Rechte pruefen oder");
-        console.error("einen anderen Namen angeben: kimal3 arbeitsplatz neu <anderer-name>");
-        return 1;
-    }
-    // 🔴 B-6: ALLE Pfade pruefen, BEVOR die erste Datei geschrieben wird. Wuerde
-    // erst waehrend des Schreibens geprueft, koennte ein unsicherer Pfad mitten
-    // in der Liste einen halb beschriebenen Ordner hinterlassen -- der naechste
-    // Versuch liefe dann in die "nicht leer"-Absage oben, ohne dass der Nutzer
-    // je erfaehrt, dass der Ordner unvollstaendig ist.
-    for (const datei of daten.dateien) {
-        if (istUnsichererPfad(datei.pfad)) {
-            console.error(`Die Antwort enthaelt einen unsicheren Pfad: „${datei.pfad}". Bitte melden.`);
-            return 3;
-        }
-    }
-    try {
-        for (const datei of daten.dateien) {
-            const ort = join(ziel, ...datei.pfad.split("/"));
-            mkdirSync(dirname(ort), { recursive: true });
-            // 🔑 B-2-Folge: Platzhalter wie [DATUM] fuellt seit PR #24 der SERVER
-            // (`src/lib/arbeitsplatz/ausliefern.ts`), fuer beide Auslieferungswege
-            // gleichzeitig -- Download auf `/pro` UND diese CLI. Wuerde die CLI
-            // zusaetzlich selbst ersetzen, gaebe es wieder zwei Wahrheiten ueber
-            // denselben Inhalt (genau das war der urspruengliche Befund). Die CLI
-            // schreibt den Inhalt deshalb hier UNVERAENDERT auf die Platte.
-            writeFileSync(ort, datei.inhalt, "utf8");
-        }
+    const werkbankVomServer = werkbankOrdner(daten.dateien);
+    /*
+      🔴 **Review-Runde 2 zu PR #25: ein getippter Name darf nicht still verfallen.**
+      Hier stand `gewuenschteWerkbank !== null && werkbankVomServer !== null ? …
+      : daten.dateien` — enthielt die Lieferung keine Werkbank, bekam der Mensch
+      den Vordruck-Namen UND eine Erfolgsmeldung, obwohl er ausdruecklich `sabine`
+      getippt hatte.
+  
+      Die Schwesterdatei behandelt dieselbe Lage laengst als Fehler („In der
+      Vorlage steckt kein Werkbank-Ordner … Bitte melden", Rueckgabewert 3).
+      *Zwei Wege, dieselbe Wirklichkeit, verschiedene Antworten* — genau die
+      Asymmetrie, die dieser PR an drei anderen Stellen schon geschlossen hat.
+    */
+    /*
+      🔴 **Beide Zweige enden gleich** (Review-Runde 5 zu PR #25). Runde 2 hat die
+      Asymmetrie zur Schwesterdatei nur fuer den Fall geschlossen, in dem ein Name
+      GETIPPT wurde; ohne Namen wurde weiter eine Warnung gedruckt und dann mit
+      `0` erfolgreich beendet.
+  
+      Warum das schlimmer ist, als es klingt: Der Weg-Hinweis am Ende faellt dann
+      auf den Wurzelordner zurueck und schickt den Menschen mit `cd
+      KI-Arbeitsplatz` genau dorthin, wo die ausgelieferte Firmen-`CLAUDE.md`
+      ausdruecklich sagt *„Du arbeitest nie hier oben"*. Eine Lieferung ohne
+      Werkbank ist kein Erfolg mit Randnotiz -- sie ist kaputt.
+  
+      ⚠️ Heute unerreichbar (`check:arbeitsplatz` Pruefung 10 erzwingt genau eine
+      Werkbank). Das ist ein Grund, ruhig zu bleiben, kein Grund, zwei Antworten
+      auf dieselbe Wirklichkeit zu geben.
+    */
+    if (werkbankVomServer === null) {
+        console.error("In der Vorlage steckt kein Werkbank-Ordner -- damit fehlt der Teil,");
+        console.error("in dem du arbeiten wuerdest. Das liegt nicht an dir. Bitte melden.");
+        return 3;
     }
-    catch (fehler) {
-        /*
-          🔴 **Hier stand `return 3` (Review-Runde 5 zu PR #24).** `3` heisst laut
-          `cli/skill/SKILL.md` "voruebergehende Stoerung -- gleich noch einmal
-          versuchen". Ein voller Datentraeger oder ein EACCES ist aber keine
-          Server-Stoerung, und der zweite Versuch kann gar nicht mehr gutgehen:
-          Der Zielordner EXISTIERT jetzt und ist nicht leer, also faellt der Lauf
-          oben in die Nicht-leer-Wache und endet mit `1` = "Eingabe passt nicht".
-          Claude sagt dem Menschen dann, sein Ordnername sei falsch -- und der
-          wahre Grund (Platte voll) kommt nie an.
-    
-          Dieselbe Begruendung steht 40 Zeilen weiter oben schon einmal, beim
-          `readdirSync`-catch. *Ein Fehler, der einmal verstanden und
-          aufgeschrieben wurde, ist im Nachbar-catch trotzdem wieder neu.*
-        */
-        console.error(`Schreiben fehlgeschlagen: ${fehler instanceof Error ? fehler.message : String(fehler)}`);
-        console.error(`Der Ordner „${ordnerName}" ist dadurch UNVOLLSTAENDIG -- er darf geloescht werden.`);
-        console.error("Das liegt an diesem Rechner, nicht am Server -- Platz und Rechte pruefen.");
-        return 1;
+    const dateien = gewuenschteWerkbank !== null
+        ? werkbankUmbenennen(daten.dateien, werkbankVomServer, gewuenschteWerkbank)
+        : daten.dateien;
+    const ordnerName = daten.wurzel;
+    const wert = dateienSchreiben(dateien, ordnerName, hinweisFuer(ordnerName));
+    if (wert !== 0)
+        return wert;
+    // ⚠️ Der ABSOLUTE Pfad, nicht der eingegebene Name. Beim Umzug der
+    // Schreib-Maschinerie (2026-08-20) war das kurz ein relativer Name -- ein
+    // Rueckschritt: Der Mensch soll sehen, WO der Ordner gelandet ist, und genau
+    // das ist der Grund, warum hier `resolve()` steht und nicht `ordnerName`.
+    console.log(`✓ ${dateien.length} ${dateien.length === 1 ? "Datei" : "Dateien"} angelegt.`);
+    console.log(`  ${resolve(ordnerName)}`);
+    /*
+      🔴 **Der Erfolgsfall muss sagen, was das Argument getan hat** (Review-Runde 5
+      zu PR #25). Das Argument hat am 2026-08-20 still seine Bedeutung geaendert:
+      In `0.1.5` -- veroeffentlicht, in Gebrauch -- war es der ORDNERNAME. Wer nach
+      der alten Hilfe `kimal3 arbeitsplatz neu ARNO-KI` tippt, bekommt heute keinen
+      Fehler, sondern einen Ordner `KI-Arbeitsplatz/` mit einer Werkbank namens
+      `werkbank-arno-ki`.
+  
+      ⚠️ Im Code stand als Trost, die Absagen und die Hilfe seien „die einzigen
+      Stellen, an denen er das erfaehrt" -- aber die Absagen feuern nur im
+      FEHLERFALL. Auf dem Erfolgsweg erfuhr er gar nichts.
+      *Eine Bedeutung, die sich still aendert, muss sich laut melden -- und zwar
+      dort, wo es geklappt hat, nicht nur dort, wo es schiefging.*
+    */
+    if (gewuenschteWerkbank !== null) {
+        console.log(`  Deine Werkbank darin heisst „${gewuenschteWerkbank}".`);
     }
-    console.log(`✓ ${daten.dateien.length} ${daten.dateien.length === 1 ? "Datei" : "Dateien"} angelegt.`);
-    console.log(`  ${ziel}`);
     console.log("");
     console.log("  Weiter geht's:");
-    const werkbank = werkbankOrdner(daten.dateien);
+    // ⚠️ NACH dem Umbenennen ableiten, nicht davor -- sonst zeigte der Weg-Hinweis
+    // in die Werkbank, die der Server geschickt hat, statt in die, die auf der
+    // Platte liegt. *Eine Ableitung, die eine Zeile zu frueh gelesen wird, fuehrt
+    // zuverlaessig ins Leere.*
+    const werkbank = werkbankOrdner(dateien);
     const cdZiel = werkbank !== null ? `${ordnerName}/${werkbank}` : ordnerName;
     console.log(`    cd ${cdZiel.includes(" ") ? `"${cdZiel}"` : cdZiel}`);
     console.log("    claude");
     console.log('    dann "Lass uns einrichten" tippen');
     return 0;
 }
-/**
- * 🔴 R2-3: Der Name der Werkbank stand hier vorher FEST getippt
- * (`meine-werkbank`) -- eine zweite Wahrheit ueber den Aufbau der Vorlage,
- * genau das, wogegen der Kopfkommentar dieser Datei argumentiert. Wird der
- * Werkbank-Ordner in `arbeitsplatz/vorlage/` umbenannt, bleibt
- * `check:arbeitsplatz` gruen -- die CLI wuerde weiter in einen Ordner
- * schicken, den es nicht mehr gibt.
- *
- * Stattdessen wird der Name aus der GELIEFERTEN Dateiliste abgeleitet: Der
- * Werkbank-Ordner ist der Unterordner mit einer EIGENEN `CLAUDE.md` direkt
- * darin (Pfad `<ordner>/CLAUDE.md`, genau zwei Teile) -- das ist die Stelle,
- * an die `README.md` und diese Meldung Menschen schicken, um dort `claude`
- * zu starten. Aendert sich der Name in der Vorlage, aendert sich diese
- * Meldung automatisch mit.
- */
-function werkbankOrdner(dateien) {
-    for (const datei of dateien) {
-        const teile = datei.pfad.split("/");
-        if (teile.length === 2 && teile[1] === "CLAUDE.md") {
-            return teile[0];
-        }
-    }
-    return null;
-}
-/**
- * Ein `..`-Segment oder ein absoluter Pfad duerften das Ziel verlassen.
- *
- * 🔴 B-8: Zerlegt an `/` UND `\` -- eine fehlerhafte oder manipulierte
- * Server-Antwort koennte sonst mit `..\..\boese.md` durchkommen. `join()`
- * trennt unter Windows auch am Backslash, dieser Schutz muss also beide
- * Trenner kennen wie `join()` selbst.
- */
-function istUnsichererPfad(pfad) {
-    if (pfad.startsWith("/") || /^[a-zA-Z]:/.test(pfad))
-        return true;
-    return pfad.split(/[\\/]/).some((teil) => teil === "..");
-}