kimal3 0.1.4 → 0.1.6

package/README.md

@@ -35,6 +35,8 @@ auf und bestätigst den Code dort in deinem eingeloggten Konto — so wie bei `g
 kimal3                    Zeigt, ob dieser Rechner angemeldet ist
 kimal3 login              Diesen Rechner mit deinem Konto verbinden
 kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen — und dir die /k3-Befehle geben
+kimal3 arbeitsplatz neu   Den ganzen KI-Arbeitsplatz anlegen — Firmenebene und Werkbank
+kimal3 werkbank neu       Nur eine eigene Werkbank in einer bestehenden Firma anlegen
 kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
 kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
 kimal3 firma daten        Die Daten deiner Firma holen, damit Claude sie auswerten kann
@@ -67,6 +69,23 @@ Für Skripte und für Claude selbst:
 Der Unterschied zwischen `3` und `4` ist Absicht: Bei `3` lohnt ein zweiter Versuch,
 bei `4` nie.
 
+## Update-Hinweise
+
+Steht eine neuere Fassung bereit, schreibt `kimal3` nach dem Befehl eine eingerückte
+Zeile — höchstens **einmal am Tag**:
+
+```
+  →  kimal3 0.2.0 ist da.  npm i -g kimal3@latest && kimal3 skill install
+```
+
+Sie geht auf **stderr**, nicht auf stdout: `kimal3 firma daten > firma.json` bleibt
+damit sauberes JSON. Sie **ändert den Rückgabewert nicht** — eine `0` bleibt eine `0`.
+Und `kimal3` **installiert nichts von selbst**; der Befehl steht in der Zeile, ausführen
+tust du ihn.
+
+Dasselbe gilt für die Skill-Dateien: Sind die in `~/.claude/skills/kimal3/` älter als
+das installierte Werkzeug, sagt `kimal3` es — dafür braucht es kein Netz.
+
 ## Voraussetzungen
 
 Node.js 20 oder neuer. Sonst nichts — das Werkzeug bringt **keine fremden Bibliotheken**

package/dist/api.js

@@ -1,4 +1,6 @@
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
+import { hinweisAusAntwort } from "./nachricht.js";
+import { eigeneVersion } from "./version.js";
 export class NichtAngemeldet extends Error {
     constructor() { super("nicht angemeldet"); }
 }
@@ -18,6 +20,26 @@ export async function ruf(pfad, optionen = {}) {
             throw new NichtAngemeldet();
         kopf.Authorization = `Bearer ${a.schluessel}`;
     }
+    /*
+      🔴 DIE CLI SAGT, WER SIE IST -- und nur daran haengt der Server den
+      Update-Hinweis an (Befund der fuenften Review-Runde).
+  
+      Ohne diesen Kopf bekaeme JEDER Client das neue Antwortfeld, auch die
+      veroeffentlichte 0.1.5. Und die gibt bei `firma daten` den GANZEN Rumpf als
+      JSON aus: Sobald jemand eine Nachricht einschaltet, stuende ein
+      `"hinweis": {…}` mitten in den Firmendaten -- bei genau den Leuten, fuer
+      die der Kanal ueberhaupt gebaut wurde, und in einer Ausgabe, die SKILL.md
+      als Firmendaten zu lesen anweist. Gemessen am 2026-08-21 mit der echten
+      0.1.5 aus npm.
+  
+      🔑 Damit ist US-7 ("die alte CLI verhaelt sich unveraendert") keine
+      Hoffnung mehr, sondern gebaut: Wer den Kopf nicht schickt, bekommt nichts.
+      Und die Nummer ist ASCII -- der ByteString-Fehler, an dem der Hinweis
+      selbst scheitern wuerde, trifft sie nicht.
+    */
+    const version = eigeneVersion();
+    if (version !== null)
+        kopf["X-Kimal3-Version"] = version;
     const methode = optionen.methode ?? "POST";
     // Content-Type nur, wenn wirklich etwas im Rumpf steht. Ein GET mit
     // "Content-Type: application/json" und ohne Rumpf ist eine Luege ueber die
@@ -29,7 +51,45 @@ export async function ruf(pfad, optionen = {}) {
         headers: kopf,
         body: methode === "POST" ? JSON.stringify(optionen.koerper ?? {}) : undefined,
     });
-    return { status: antwort.status, koerper: await antwort.json().catch(() => null) };
+    const koerper = await antwort.json().catch(() => null);
+    merkeHinweis(koerper);
+    return { status: antwort.status, koerper };
+}
+/**
+ * Der zuletzt mitgereiste Update-Hinweis.
+ *
+ * 🔑 WARUM EINE MODULVARIABLE UND KEINE AUSGABE AN DIESER STELLE: `ruf()`
+ * laeuft MITTEN in einem Befehl, teils mehrfach. Wer hier schreibt, schneidet
+ * die Projektliste entzwei -- die Spec verlangt ausdruecklich, dass die Zeile
+ * NACH der Ausgabe steht, nie mittendrin (US-1). Ausgegeben wird genau einmal,
+ * ganz am Ende, in kimal3.ts.
+ */
+let letzterHinweis = null;
+function merkeHinweis(koerper) {
+    const h = hinweisAusAntwort(koerper);
+    if (h)
+        letzterHinweis = h;
+    /*
+      🔴 UND DANN RAUS AUS DEM RUMPF. Gemessen am 2026-08-21: `firma daten` gibt
+      den GANZEN Rumpf als JSON aus (`console.log(JSON.stringify(koerper))`) --
+      der Hinweis stuende dort mitten in den Firmendaten UND darunter noch einmal
+      als →-Zeile. Zweimal dasselbe, und einmal davon an einer Stelle, an der
+      Claude Daten erwartet.
+  
+      🔑 Warum HIER und nicht in `firma-daten.ts`: Dort waere es eine Kopie, die
+      beim naechsten Befehl fehlt, der einen Rumpf durchreicht. Wer den Hinweis
+      ENTGEGENNIMMT, nimmt ihn auch heraus -- dann kann kein Befehl ihn
+      versehentlich mit ausgeben, auch keiner, den es noch nicht gibt.
+  
+      Das `delete` trifft ein frisch aus `json()` erzeugtes Objekt, das sonst
+      niemand haelt.
+    */
+    if (koerper && typeof koerper === "object") {
+        delete koerper.hinweis;
+    }
+}
+export function gemerkterHinweis() {
+    return letzterHinweis;
 }
 /** Holt ein Textfeld aus einer Antwort, ohne `any`. */
 export function feld(koerper, name) {

package/dist/arbeitsplatz-dateien.js

@@ -0,0 +1,268 @@
+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";
+/*
+  🔁 Die Ableitung „welcher Unterordner ist die Werkbank" wohnt seit dem
+  2026-08-20 in `werkbank-name.ts` -- gemeinsam mit der App, die sie fuer `/pro`
+  genauso braucht. Sie stand vorher hier UND in `src/lib/arbeitsplatz/ausliefern.ts`,
+  wortgleich. *Zwei Kopien einer Ableitung sind dieselbe zweite Wahrheit wie zwei
+  Kopien des Namens, nur besser getarnt.*
+*/
+export { werkbankAusDateien as werkbankOrdner } from "./werkbank-name.js";
+/**
+ * Holt die Vorlage von der App — **eine** Route für beide Befehle.
+ *
+ * 🔑 `werkbank neu` bekommt bewusst KEINE eigene Route: Es sind dieselben
+ * Dateien, dieselbe Pro-Prüfung, derselbe Ausweis. Eine zweite Route wäre eine
+ * zweite Tür, die man einzeln absichern und einzeln nachmessen müsste — für
+ * exakt denselben Inhalt. Der Ausschnitt entsteht hier auf dem Rechner.
+ */
+export async function vorlageHolen() {
+    const antwort = await ruf("/api/cli/arbeitsplatz", { methode: "GET", mitAusweis: true });
+    if (antwort.status === 200) {
+        const daten = alsVorlageAntwort(antwort.koerper);
+        if (daten === null) {
+            console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+            return { ok: false, wert: 3 };
+        }
+        return { ok: true, daten };
+    }
+    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 { ok: false, wert: 4 };
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
+        return { ok: false, wert: 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 { ok: false, wert: schluss.wert };
+}
+/** Prueft die Antwort-Form, ohne `any` -- eine falsche Form ist unlesbar, keine Ausnahme. */
+function alsVorlageAntwort(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 dieser Befehle.
+ * 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.
+ *
+ * 🆕 **Neu am 2026-08-20:** `hinweis` — was die Absage **im Zweig „Ordner
+ * existiert und ist nicht leer"** zum Weitermachen raet. Nur dort: Seit
+ * Review-Runde 1 traegt er ein `cd` in den Zielordner, und in eine Datei oder
+ * einen unlesbaren Ordner kann man nicht hineinwechseln (Runde 2). Die beiden
+ * anderen Zweige haben ihren eigenen Satz.
+ * Der Rat stand dreimal fest getippt als `kimal3 arbeitsplatz neu <anderer-name>`
+ * im Text. Für `werkbank neu` wäre er falsch — und ein Rat, der in den falschen
+ * Befehl schickt, ist schlimmer als keiner.
+ *
+ * 🔴 **Und er trägt den GANZEN Rat, nicht nur den Befehl** (Messung am selben
+ * Tag, auf der Kundenstrecke). In der ersten Fassung war `hinweis` ein Befehl,
+ * und der Rahmensatz `Gib einen anderen Namen an:` gehörte dieser Datei. Nach
+ * der Umbenennung las sich das so:
+ *
+ *     Gib einen anderen Namen an: kimal3 werkbank neu <dein-vorname>
+ *
+ * Einen anderen Namen kann man für den obersten Ordner seit der Umbenennung
+ * gerade **nicht** mehr geben — genau deshalb wurde der Rat ausgetauscht. *Wer
+ * nur das Ziel eines Satzes austauschbar macht, aber nicht seine Aussage, hat
+ * die halbe Wahrheit festgenagelt.*
+ */
+export function dateienSchreiben(dateien, ordnerName, hinweis) {
+    // 🔴 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 (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 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.
+  
+      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.*
+    */
+    try {
+        if (existsSync(ziel)) {
+            if (!statSync(ziel).isDirectory()) {
+                /*
+                  🔴 **Hier stand der `hinweis`** (Review-Runde 2 zu PR #25). Seit Runde 1
+                  enthaelt er ein `cd` in den Zielordner -- und in eine DATEI kann man
+                  nicht hineinwechseln. Der Rat war in diesem Zweig unausfuehrbar.
+                  *Ein Parameter, der zu einem Zweig passt, gehoert nicht in alle drei.*
+                */
+                console.error(`„${ordnerName}" gibt es schon -- als DATEI, nicht als Ordner.`);
+                console.error("Benenn die Datei um oder geh in einen anderen Ordner.");
+                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(hinweis);
+                return 1;
+            }
+        }
+    }
+    catch (fehler) {
+        console.error(`Ich komme an den Ordner „${ordnerName}" nicht heran.`);
+        console.error(`Grund: ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+        // ⚠️ Ebenfalls OHNE den `hinweis` (Runde 2): Wer den Ordner nicht lesen darf,
+        // kann auch nicht hineinwechseln. Hier hilft nur, was schon dasteht.
+        console.error("Das liegt an diesem Rechner, nicht am Server -- Rechte pruefen.");
+        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 dateien) {
+        if (istUnsichererPfad(datei.pfad)) {
+            console.error(`Die Antwort enthaelt einen unsicheren Pfad: „${datei.pfad}". Bitte melden.`);
+            return 3;
+        }
+    }
+    try {
+        for (const datei of 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");
+        }
+    }
+    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;
+    }
+    return 0;
+}
+/**
+ * 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.
+ */
+/**
+ * Taugt das als **Ordnername**? — schaerfer als `istUnsichererPfad`.
+ *
+ * 🔴 **Review-Runde 2 zu PR #25, und der Kommentar daneben war der Beweis.**
+ * `istUnsichererPfad` prueft einen PFAD: Es faengt `..` und absolute Pfade. Ein
+ * Ordner_name_ ist aber etwas Engeres — er ist **ein** Pfadteil. Und genau die
+ * beiden Werte, die als Pfadteil sinnlos sind, kommen durch:
+ *
+ *     ""   aus einer Antwort mit `/CLAUDE.md`   -> resolve("")  = das aktuelle Verzeichnis
+ *     "."  aus einer Antwort mit `./CLAUDE.md`  -> resolve(".") = das aktuelle Verzeichnis
+ *
+ * In einem LEEREN Ordner haette `werkbank neu` die Dateien damit einfach dorthin
+ * geschrieben, wo der Mensch steht — und die Firmen-Wache daneben wird dabei
+ * still gruen, weil `firmenEbeneAus` genau diese Pfade ueberspringt.
+ *
+ * ⚠️ **In der Fassung von Runde 1 stand als Begruendung, `""` sei ungefaehrlich,
+ * „weil sonst die Wache oben schon rot waere".** Diese Wache ist in genau
+ * diesem Fall gruen. *Ein Kommentar, der eine Luecke mit einer anderen Wache
+ * begruendet, muss diese Wache im FEHLERFALL gelesen haben, nicht im Normalfall.*
+ *
+ * 🔑 Positiv formuliert statt negativ: Ein Ordnername ist EIN Teil, und dieser
+ * Teil ist weder leer noch `.` noch `..`. Eine Liste dessen, was verboten ist,
+ * waere beim naechsten Sonderfall wieder unvollstaendig.
+ */
+export function istUnsichererOrdnername(name) {
+    if (istUnsichererPfad(name))
+        return true;
+    const teile = name.split(/[\\/]/);
+    if (teile.length !== 1)
+        return true;
+    return teile[0] === "" || teile[0] === ".";
+}
+export function istUnsichererPfad(pfad) {
+    if (pfad.startsWith("/") || /^[a-zA-Z]:/.test(pfad))
+        return true;
+    return pfad.split(/[\\/]/).some((teil) => teil === "..");
+}

package/dist/befehle/arbeitsplatz.js

@@ -0,0 +1,260 @@
+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.
+ *
+ * 🔑 **Warum dieser Befehl NICHTS interpretiert** (wie `firma daten`): Die
+ * Vorlage entsteht an EINER Stelle (`arbeitsplatz/vorlage/…` im Repo, gebaut
+ * zu `src/lib/arbeitsplatz/vorlage-daten.ts`) und wird von dort an ZWEI Wegen
+ * ausgeliefert -- Download auf `/pro` und hier ueber die CLI. Wuerde dieser
+ * 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 [dein-vorname]
+
+  Holt deine KI-Arbeitsplatz-Vorlage und legt sie hier als Ordner an --
+  die ganze Familie: Firmenebene, Werkbank, Beispielprojekt.
+
+  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) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    /*
+      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 (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 `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;
+    }
+    /*
+      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;
+        }
+    }
+    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.
+    //
+    // ⚠️ **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;
+    }
+    /*
+      🔑 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.
+  
+      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.
+    */
+    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;
+    }
+    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("");
+    console.log("  Weiter geht's:");
+    // ⚠️ 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;
+}