kimal3 0.1.5 → 0.2.0

package/dist/nachricht.js

@@ -0,0 +1,249 @@
+/**
+ * Die reinen Rechnungen des Update-Kanals -- und sonst nichts.
+ *
+ * 🔑 WARUM DIESE DATEI NICHTS ANFASST: Kein fetch, kein readFileSync, kein
+ * `new Date()` ohne Uebergabe. Genau deshalb kann `npm run check:nachrichten`
+ * Faelle pruefen, die es in der Wirklichkeit nur durch Warten gaebe --
+ * "gestern gesehen", "0.10.0 gegen 0.9.0", "Stempel aus der Zukunft".
+ * Die Raender (Datei, Netz, Uhr) wohnen in gesehen.ts, api.ts und kimal3.ts.
+ */
+/** Der Stempel, den `kimal3 skill install` ans Ende der SKILL.md schreibt. */
+export const STEMPEL_MARKE = "kimal3:erzeugt version=";
+/**
+ * Zieht den Hinweis aus einer Server-Antwort -- oder gibt `null` zurueck.
+ *
+ * ⚠️ Jedes Feld einzeln pruefen, obwohl der Server unserer ist. Diese Zeilen
+ * laufen auf dem Rechner des Kunden und muessen auch dann halten, wenn dort
+ * eine ALTE CLI auf eine NEUE Antwort trifft oder umgekehrt. Genau dieser
+ * Versatz ist bei einem Werkzeug, das man selbst aktualisieren muss, der
+ * Normalfall -- kein Sonderfall.
+ */
+export function hinweisAusAntwort(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const roh = koerper.hinweis;
+    if (!roh || typeof roh !== "object")
+        return null;
+    const h = roh;
+    if (typeof h.id !== "string" || typeof h.text !== "string")
+        return null;
+    return {
+        id: h.id,
+        text: h.text,
+        gilt_unter_version: typeof h.gilt_unter_version === "string" ? h.gilt_unter_version : null,
+    };
+}
+function teile(v) {
+    /*
+      ⚠️ Ein Anhaengsel wie `-rc.1` oder `+build3` faellt vorher weg (Befund der
+      ersten Review-Runde). Ohne diese Zeile legt ein einziges `npm version
+      prerelease` den GANZEN Kanal still: `eigeneVersion()` gaebe "0.2.0-rc.1"
+      zurueck -- nicht `null`, also faehrt `hinweisText` weiter --, aber jeder
+      Vergleich antwortete `false`. Kein Netz-Hinweis, kein Skill-Hinweis, keine
+      Fehlermeldung. *Ein Merkmal, das sich lautlos abschaltet, faellt niemandem
+      auf.*
+  
+      🔑 Bewusst NICHT nach Semver sortiert (dort gilt `0.2.0-rc.1` < `0.2.0`):
+      Diese Rechnung beantwortet "soll ich jemandem ein Update anbieten", und da
+      ist eine Vorabversion nah genug an ihrer Fassung. Die Genauigkeit waere
+      Aufwand fuer einen Fall, den es hier noch nie gab -- YAGNI.
+    */
+    const stuecke = v.trim().split(/[-+]/)[0].split(".");
+    if (stuecke.length === 0)
+        return null;
+    const zahlen = [];
+    for (const s of stuecke) {
+        // ⚠️ Absichtlich streng: `Number("1a")` ist NaN, aber `parseInt("1a")` ist 1.
+        // Wer hier `parseInt` nimmt, macht aus dem Muellwert "bald" eine 0 und
+        // vergleicht dann munter weiter.
+        if (!/^\d+$/.test(s))
+            return null;
+        zahlen.push(Number(s));
+    }
+    return zahlen;
+}
+/**
+ * Ist `a` aelter als `b`? Zahl fuer Zahl, nicht als Text.
+ *
+ * 🔴 DER FALL, DER DIESE FUNKTION RECHTFERTIGT: `"0.10.0" < "0.9.0"` ist als
+ * Textvergleich WAHR. Wer so vergleicht, haelt die neueste Fassung fuer die
+ * aeltere und drangsaliert genau die Kunden, die aktuell sind.
+ *
+ * Ist einer der beiden Werte kein Versionsstand, lautet die Antwort `false` --
+ * "im Zweifel schweigen" ist bei einem Nebenschauplatz die richtige Vorgabe.
+ */
+export function istAelter(a, b) {
+    const x = teile(a);
+    const y = teile(b);
+    if (!x || !y)
+        return false;
+    const laenge = Math.max(x.length, y.length);
+    for (let i = 0; i < laenge; i++) {
+        const links = x[i] ?? 0;
+        const rechts = y[i] ?? 0;
+        if (links !== rechts)
+            return links < rechts;
+    }
+    return false;
+}
+/**
+ * Welcher Tag ist in Deutschland gerade?
+ *
+ * ⚠️ NICHT `toISOString().slice(0,10)` -- das ist UTC. Um 00:30 deutscher Zeit
+ * waere "heute" der Vortag, und die Nachricht erschiene an einem Abend zweimal.
+ * `sv-SE` liefert von sich aus `JJJJ-MM-TT`; dieselbe Technik wie
+ * `heuteInDeutschland` in der App. Importieren laesst sie sich nicht --
+ * `cli/tsconfig.json` steht auf `rootDir: src` (Begruendung steht schon in
+ * projekt-zeilen.ts).
+ */
+export function heuteAus(d) {
+    return new Intl.DateTimeFormat("sv-SE", { timeZone: "Europe/Berlin" }).format(d);
+}
+/**
+ * Die ganze Entscheidung, als Funktion von vier Werten.
+ */
+export function sollZeigen(h, eigeneVersion, gesehen, heute) {
+    if (!h.id)
+        return false;
+    if (!h.text || h.text.trim() === "")
+        return false;
+    // Leeres Feld = alle sehen es. Sonst nur, wer aelter ist als die Grenze.
+    if (h.gilt_unter_version && !istAelter(eigeneVersion, h.gilt_unter_version))
+        return false;
+    // Hoechstens einmal am Tag -- auch bei zwanzig Befehlen.
+    if (gesehen[h.id] === heute)
+        return false;
+    return true;
+}
+/**
+ * Die Zeilen fuers Terminal.
+ *
+ * Bewusst Klartext mit `→`, wie der Rest der CLI: `cli/` hat null
+ * Abhaengigkeiten und nirgends ANSI-Farben. Ein gezeichneter Kasten braeche
+ * ausserdem in einem schmalen Terminal auseinander -- ein eingerueckter Satz
+ * nicht.
+ */
+export function formatiere(h) {
+    return `\n  →  ${saeubere(h.text)}\n`;
+}
+/**
+ * Macht aus dem Nachrichtentext EINE harmlose Zeile.
+ *
+ * 🔴 WARUM UEBERHAUPT (Befund der vierten Review-Runde): Der Text kommt aus
+ * der Datenbank und wird in ein TERMINAL geschrieben. Steuerzeichen sind dort
+ * keine Zeichen, sondern Befehle -- eine ANSI-Fluchtfolge kann faerben, den
+ * Bildschirm loeschen oder den Wagen zurueckholen und damit Zeilen
+ * ueberschreiben, die schon dastanden. Der Kanal wuerde dann nicht mehr nur
+ * etwas HINZUFUEGEN, sondern die Ausgabe des Befehls veraendern.
+ *
+ * ⚠️ Und Zeilenumbrueche muessen weg, weil die Ausgabe genau eine eingerueckte
+ * Zeile ist: Ein "\n" mitten im Text schoebe den Rest linksbuendig darunter --
+ * es saehe aus wie Ausgabe des Befehls, nicht wie ein Hinweis.
+ *
+ * 📌 Die Pruefung dazu stand vorher da und konnte nicht rot werden: Sie mass
+ * einen Vordruck ohne Steuerzeichen. *Eine gruene Pruefung ueber einen Wert,
+ * der nie anders aussieht, prueft den Vordruck, nicht den Code.*
+ */
+function saeubere(text) {
+    return text
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Zieht `0.1.6` aus `<!-- kimal3:erzeugt version=0.1.6 -->`.
+ *
+ * 🔴 DER LETZTE TREFFER GILT, nicht der erste (Befund der fuenften
+ * Review-Runde). Der echte Stempel steht immer am DATEIENDE -- aber die
+ * SKILL.md ist ein Text ueber dieses Werkzeug und beschreibt inzwischen selbst,
+ * wie der Kanal funktioniert. Nennt sie eines Tages ein Beispiel wie
+ * `version=9.9.9`, gewaenne der Beispieltext gegen den echten Stempel:
+ * `skillZustand` antwortete fuer immer "still", und Weg 2 waere lautlos tot.
+ *
+ * *Ein Dokument, das seine eigene Maschinenlesbarkeit beschreibt, wird
+ * irgendwann versehentlich zu seinen eigenen Daten.*
+ */
+export function stempelAus(inhalt) {
+    const treffer = [...inhalt.matchAll(/kimal3:erzeugt version=([0-9][0-9.]*)/g)];
+    return treffer.length > 0 ? treffer[treffer.length - 1][1] : null;
+}
+/**
+ * Die DREI Zustaende aus US-4/US-5 -- und sie sind ausdruecklich drei, nicht
+ * zwei:
+ *
+ * | Was liegt dort        | Antwort    |
+ * |-----------------------|------------|
+ * | Datei fehlt           | still      |  <- nie installiert
+ * | Datei ohne Stempel    | veraltet   |  <- 0.1.4 und aelter
+ * | Stempel aelter        | veraltet   |
+ * | Stempel gleich/neuer  | still      |  <- niemand wird rueckwaerts gedraengt
+ *
+ * ⚠️ Die ersten beiden sehen im Dateisystem fast gleich aus und bedeuten das
+ * Gegenteil. `null` heisst hier "es gibt keine Datei", NICHT "leer".
+ */
+export function skillZustand(inhalt, eigeneVersion) {
+    if (inhalt === null)
+        return "still";
+    const stempel = stempelAus(inhalt);
+    if (stempel === null)
+        return "veraltet";
+    return istAelter(stempel, eigeneVersion) ? "veraltet" : "still";
+}
+/**
+ * ⚠️ Sie nennt den Befehl, sie FUEHRT IHN NICHT AUS. Ein Befehl darf nicht
+ * mehr tun, als sein Name verspricht -- die Regel steht schon in kimal3.ts.
+ */
+export function skillMeldung() {
+    return "\n  →  Deine kimal3-Skilldateien sind aelter als die CLI.  kimal3 skill install\n";
+}
+/**
+ * Zerlegt den Kopf `X-Kimal3-Kontext-Stand`: `<firmen-id>:<stand>` (Task 10).
+ *
+ * ⚠️ AM ERSTEN DOPPELPUNKT TRENNEN, nicht am `split(":")[1]`: `stand` ist oft
+ * ein ISO-Zeitstempel und traegt selbst Doppelpunkte
+ * (`2026-08-21T07:12:33.456Z`). Ein `split` wuerde ihn mitten durchschneiden.
+ *
+ * Fehlt der Kopf, ist er leer, hat keinen Doppelpunkt oder ist eine Seite
+ * leer -> `null`. Diese Datei rechnet nur; SIE PRUEFT NICHT, ob die Firmen-ID
+ * echt ist oder der Anrufer ihr Mitglied ist -- das ist Datenbankzugriff und
+ * gehoert der Aufrufstelle (`src/lib/cli/nachricht.ts`).
+ */
+export function kontextStandAusKopf(wert) {
+    if (!wert)
+        return null;
+    const trenner = wert.indexOf(":");
+    if (trenner <= 0)
+        return null;
+    const firmaId = wert.slice(0, trenner);
+    const stand = wert.slice(trenner + 1);
+    if (stand === "")
+        return null;
+    return { firmaId, stand };
+}
+/**
+ * Die ZWEITE Quelle des Update-Kanals (Task 10) -- rein: Sie bekommt den
+ * lokalen Stand (aus dem Kopf, schon geparst) und den server-gefuehrten
+ * Stand samt Firmennamen fertig nachgeschlagen und ENTSCHEIDET nur noch.
+ *
+ * 🔴 WARUM DER SERVER-STAND UND NICHT DER ROHE KOPF VERGLICHEN WIRD: Der
+ * Server weiss nicht, was auf der Platte des Kunden liegt -- die CLI schickt
+ * ihren Stand, die App vergleicht ihn nur mit ihrem eigenen (Bauplan Step 2).
+ *
+ * 🔑 `id: kontext-<serverStand>` (Step 3): Die Tagessperre der CLI merkt sich
+ * Hinweise nach `id` -- aendert die Firma den Kontext ein zweites Mal am
+ * selben Tag, aendert sich `serverStand` und damit automatisch die `id`. Der
+ * Hinweis erscheint also je NEUEM Stand genau einmal, ohne dass diese
+ * Funktion selbst je ein Datum ansieht.
+ *
+ * 🔑 US-8: `firmenName` steht IM TEXT, nicht nur die ID -- wer in zwei Firmen
+ * ist, muss lesen koennen, WELCHE gemeint ist.
+ */
+export function firmenHinweisAus(lokalerStand, serverStand, firmenName) {
+    if (lokalerStand === serverStand)
+        return null;
+    return {
+        id: `kontext-${serverStand}`,
+        text: `${firmenName} hat den Firmenkontext aktualisiert.  kimal3 kontext runter`,
+        gilt_unter_version: null,
+    };
+}

package/dist/version.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+/**
+ * Die eigene Versionsnummer -- GELESEN, nie abgetippt.
+ *
+ * ⚠️ Die Regel dahinter ist gemessen (QA-Befund B-8, 2026-08-18): Stuende die
+ * Zahl als Text im Code, sagte die CLI nach dem naechsten `npm version` die
+ * alte Nummer. Dieselbe Zahl an zwei Tueren mit zwei Werten -- ein Muster, das
+ * in diesem Projekt schon mehrfach zugeschlagen hat.
+ *
+ * 📌 `../package.json` stimmt aus `dist/` UND aus `src/`: Beide liegen eine
+ * Ebene unter `cli/`. Deshalb steht hier kein fester Pfad.
+ *
+ * 🔴 RUECKGABE `null`, NICHT "0.0.0" und auch nicht "unbekannt".
+ * Diese Funktion hat zwei Aufrufer mit gegensaetzlichem Bedarf:
+ *   - `versionsZeilen()` ZEIGT den Wert einem Menschen. Dort ist "unbekannt"
+ *     die ehrliche Antwort -- eine erfundene "0.0.0" waere eine Luege auf dem
+ *     Bildschirm.
+ *   - `hinweisAusgeben()` RECHNET damit. Dort ist "unbekannt" Muell, der jeden
+ *     Versionsvergleich schweigen laesst.
+ * `null` zwingt beide, ihren eigenen Fall zu entscheiden, statt einen
+ * Ersatzwert zu erben, der nur fuer den anderen passt.
+ */
+export function eigeneVersion() {
+    try {
+        const roh = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        if (roh && typeof roh === "object" && "version" in roh) {
+            const v = roh.version;
+            if (typeof v === "string")
+                return v;
+        }
+    }
+    catch {
+        // Kein Absturz, wenn die Datei fehlt oder Unsinn enthaelt. Der Aufrufer
+        // entscheidet, was "keine Nummer" bei ihm bedeutet.
+    }
+    return null;
+}

package/dist/werkbank-name.js

@@ -0,0 +1,217 @@
+/**
+ * Wie eine Werkbank heisst — **eine** Regel fuer beide Auslieferungswege.
+ *
+ * 🔑 **Warum das eine eigene Datei ist** (2026-08-20, bei der Umbenennung von
+ * `meine-werkbank` auf `werkbank-<name>`): Der Ordnername entsteht an ZWEI
+ * Stellen. Der Server setzt ihn beim Ausliefern (Zip-Download auf `/pro` UND
+ * `/api/cli/arbeitsplatz`), und die CLI setzt ihn noch einmal, wenn der Mensch
+ * einen Namen mitgegeben hat. Waeren das zwei Regeln, hiesse derselbe Mensch je
+ * nach Weg anders — genau die Sorte Unterschied, die man erst Tage spaeter
+ * bemerkt.
+ *
+ * ⚠️ **DIESE DATEI IMPORTIERT NICHTS**, aus demselben Grund wie
+ * `befehle-katalog.ts`: Die CLI baut mit NodeNext (Import-Pfade enden auf
+ * `.js`), die App mit dem Bundler. Eine Datei ohne eigene Importe liest sich aus
+ * beiden Welten ohne Uebersetzung.
+ *
+ * 🔴 **Wozu das Ganze** (Entscheidung Dennis, 2026-08-20): *Besitz steht im
+ * Ordnernamen, nicht in einem Possessivpronomen.* Der Vorgaenger `meine-werkbank`
+ * hiess bei JEDEM gleich — liegen zwei davon nebeneinander oder gehen sie zu
+ * GitHub, ist nicht mehr erkennbar, wem welche gehoert. Wo ein Name steht
+ * (`werkbank-sabine`), gehoert der Ordner einer Person; wo keiner steht
+ * (`kontext/`, `KI-Arbeitsplatz/`), gehoert er allen. *Ein Nutzer muss diese
+ * Regel nicht lernen — er sieht sie im Baum.*
+ */
+/** Das Praefix, an dem man eine Werkbank erkennt. Bewacht von `check:arbeitsplatz` (11b). */
+export const WERKBANK_PRAEFIX = "werkbank-";
+/**
+ * Wie lang der Namensteil hoechstens werden darf.
+ *
+ * Nicht aus Geschmack: Windows deckelt einen ganzen Pfad bei 260 Zeichen, und
+ * dieser Ordner traegt darunter noch `projekte/<projekt>/referenzen/…`. Ein
+ * ellenlanger Name aus einer Sammel-Adresse wuerde erst dort unten Fehler
+ * erzeugen — an einer Stelle, an der niemand mehr an den Ordnernamen denkt.
+ */
+const MAX_LAENGE = 40;
+/**
+ * Aus dem, was ein Mensch eingibt (oder aus seiner Adresse kommt), ein Ordnername.
+ *
+ *     "Sabine"            → "werkbank-sabine"
+ *     "Sabine Müller"     → "werkbank-sabine-mueller"
+ *     "werkbank-sabine"   → "werkbank-sabine"   (nicht doppelt)
+ *     "sabine@arno.de"    → "werkbank-sabine"   (der Teil vor dem @)
+ *     "!!!"               → null                (nichts Brauchbares uebrig)
+ *
+ * 🔑 **Warum umgeschrieben und nicht abgelehnt wird:** Der Name landet als
+ * Ordner auf einer echten Platte. Ein `/` darin waere ein Unterordner, ein `:`
+ * unter Windows ein Laufwerk, ein Leerzeichen ein zweites Argument im naechsten
+ * `cd`. Wer „Sabine Müller" eingibt, hat nichts falsch gemacht — er hat einen
+ * Namen genannt, und Namen duerfen Umlaute und Leerzeichen haben.
+ *
+ * ⚠️ **Umlaute werden AUSGESCHRIEBEN, nicht entfernt.** `ü` einfach zu streichen
+ * machte aus „Müller" ein „Mller"; die deutsche Ersatzschreibung `ue` ist die,
+ * die jeder Mensch hier erwartet. Der Weg ueber `normalize("NFD")` allein reicht
+ * dafuer NICHT — er zerlegt `ü` in `u` + Trema und liefert damit „Muller".
+ * Deshalb stehen die vier deutschen Zeichen ausdruecklich davor.
+ *
+ * 📌 Gibt `null` zurueck, wenn nichts uebrig bleibt. Das ist **kein** Fehlerfall
+ * dieser Funktion, sondern eine Auskunft: Der Aufrufer entscheidet, ob er
+ * absagt (die CLI, wo ein Mensch etwas getippt hat) oder still beim Vordruck
+ * bleibt (der Server, wo niemand gefragt wurde).
+ */
+export function werkbankOrdnerAus(roh) {
+    /*
+      🔴 **Spitze Klammern sind eine ABSAGE, keine Zeichen zum Wegwerfen**
+      (Review-Runde 5 zu PR #25). Gemessen: `"<dein-vorname>"` wurde zu
+      `werkbank-dein-vorname` -- ein Ordner, der plausibel aussieht und den
+      niemand wollte.
+  
+      Und die Zeichenkette kommt nicht aus dem Nichts: Beide Absagen dieser CLI
+      und die Tabelle in `SKILL.md` legen sie dem Menschen woertlich hin
+      (`kimal3 werkbank neu <dein-vorname>`). In einer rohen Shell rettet der
+      Zufall -- dort ist `<` eine Umleitung und der Aufruf scheitert vorher. In
+      Claude Code, wo der Aufruf als Zeichenkette weitergereicht wird, rettet
+      nichts.
+  
+      *Genau der Fehler, gegen den `Anleitung.tsx` den Kopier-Kasten entworfen
+      hat: „Ein Platzhalter darin wird mitkopiert und ergibt einen Ordner, den
+      niemand wollte."* Er stand hier eine Ebene tiefer noch offen.
+    */
+    if (roh.includes("<") || roh.includes(">"))
+        return null;
+    const vorDemAt = roh.split("@")[0] ?? "";
+    const grundform = vorDemAt
+        .toLowerCase()
+        .replaceAll("ä", "ae")
+        .replaceAll("ö", "oe")
+        .replaceAll("ü", "ue")
+        .replaceAll("ß", "ss")
+        // Alles andere mit Akzent auf den Grundbuchstaben zurueck (é → e, ç → c).
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        // Was jetzt noch kein a–z oder 0–9 ist, wird zum Trennstrich -- und
+        // mehrere Trennstriche werden einer.
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    // Ein bereits vollstaendiger Ordnername soll nicht `werkbank-werkbank-sabine`
+    // werden. Das ist kein Sonderfall fuer Feinschmecker: Die Hilfe von
+    // `werkbank neu` hat bis heute genau diese Schreibweise beigebracht
+    // (`kimal3 werkbank neu werkbank-sabine`), und alte Anleitungen ueberleben
+    // laenger als der Code, den sie beschreiben.
+    const ohnePraefix = grundform.startsWith(WERKBANK_PRAEFIX)
+        ? grundform.slice(WERKBANK_PRAEFIX.length)
+        : grundform;
+    // ⚠️ Erst kuerzen, DANN den Trennstrich am Ende wegnehmen: Faellt der Schnitt
+    // mitten in „sabine-mueller", bliebe sonst ein „werkbank-sabine-" stehen.
+    const gekuerzt = ohnePraefix.slice(0, MAX_LAENGE).replace(/-+$/g, "");
+    if (gekuerzt === "")
+        return null;
+    return `${WERKBANK_PRAEFIX}${gekuerzt}`;
+}
+/**
+ * Die Vorlage auf einen anderen Werkbank-Namen umschreiben — **Pfade und Texte**.
+ *
+ * 🔑 **Warum auch die Texte** — und warum die Begruendung dafuer sich am
+ * 2026-08-20 zweimal gedreht hat:
+ *
+ * Zuerst hiess sie: *„Die `README.md` sagt woertlich `cd werkbank-dein-name`,
+ * und `check:arbeitsplatz` (Pruefung 11) haelt das fest."* Das stimmte —
+ * bis Review-Runde 3 zeigte, dass ein Name im GEMEINSAMEN Firmentext den Namen
+ * EINES Menschen ist, und Pruefung 11 daraufhin umgedreht wurde: Sie verbietet
+ * ihn dort jetzt.
+ *
+ * 🔬 **Heute nennt deshalb keine ausgelieferte Datei den Werkbank-Namen im
+ * Text** (nachgemessen: `grep` findet ihn nur im Ordnernamen). Die Ersetzung
+ * hat also aktuell **nichts zu tun** — und bleibt trotzdem drin, als Netz fuer
+ * den Fall, dass jemand in eine Werkbank-Datei `werkbank-sabine/projekte/`
+ * schreibt. Dort verbietet es keine Wache, und der Satz zeigte beim naechsten
+ * Menschen auf einen fremden Ordner.
+ *
+ * *Ein Netz, das heute niemand braucht, ist ehrlich zu beschreiben — nicht mit
+ * einer Zusicherung zu begruenden, die inzwischen das Gegenteil sagt.*
+ *
+ * ⚠️ Ersetzt wird der ganze Ordnername, nicht das Praefix — sonst traefe es
+ * jeden Text, der irgendeine Werkbank erwaehnt.
+ *
+ * 🔴 **Und das reicht NICHT, um erklaerende Beispiele zu schuetzen**
+ * (Review-Runde 1 zu PR #25). Hier stand, die Beispiele `werkbank-sabine` in der
+ * Vorlage blieben stehen. Das stimmt nur, solange `alt` der Vordruck ist — bei
+ * der CLI ist `alt` aber der Name, den der SERVER gesetzt hat. Heisst ein Konto
+ * `werkbank-sabine` und ruft `arbeitsplatz neu jonas` auf, wird aus dem
+ * erklaerenden Beispiel ebenfalls `werkbank-jonas`, und der Satz liest sich
+ * *„traegt seinen Namen: `werkbank-jonas`, `werkbank-jonas`"*.
+ *
+ * 🔑 Geschuetzt sind Beispiele deshalb nicht hier, sondern in der VORLAGE: Sie
+ * heissen `werkbank-<vorname>`, und diese Form kann kein echter Ordner tragen —
+ * `<` und `>` ueberleben `werkbankOrdnerAus` nicht. `check:arbeitsplatz` (11d)
+ * haelt das fest. *Eine Zusicherung, die nur fuer einen der beiden Aufrufer
+ * gilt, ist keine Zusicherung dieser Funktion.*
+ *
+ * 📌 Ist `alt` gleich `neu`, kommt die Liste unveraendert zurueck. Der Aufrufer
+ * muss also nicht selbst pruefen, ob sich etwas aendert.
+ */
+export function werkbankUmbenennen(dateien, alt, neu) {
+    if (alt === "" || neu === "" || alt === neu)
+        return [...dateien];
+    const altesPraefix = `${alt}/`;
+    const neuesPraefix = `${neu}/`;
+    /*
+      🔴 **Mit Wortgrenze, nicht mit `replaceAll`** (Review-Runde 5 zu PR #25).
+      Gemessen: Ein nacktes `replaceAll("werkbank-sabine", "werkbank-jonas")`
+      macht aus `werkbank-sabine-alt` ein `werkbank-jonas-alt` -- es zerlegt jedes
+      laengere Token, das mit dem Namen anfaengt.
+  
+      Heute stolpert niemand darueber, weil `check:arbeitsplatz` (11d) solche
+      Token aus der Vorlage haelt. Aber der Doku-Block oben verkauft die
+      Inhalts-Ersetzung ausdruecklich als **Netz fuer kuenftige Texte** -- und ein
+      Netz mit einem Loch ist genau das, was man erst am Tag des Sturzes merkt.
+  
+      Die Grenze gilt auf BEIDEN Seiten: `xwerkbank-sabine` ist ebenso wenig
+      gemeint wie `werkbank-sabine-alt`. Erlaubt sind nur Zeichen, die in keinem
+      Ordnernamen vorkommen koennen -- alles ausser `[a-z0-9-]`.
+    */
+    const grenze = new RegExp(`(?<![a-z0-9-])${maskiere(alt)}(?![a-z0-9-])`, "g");
+    return dateien.map((datei) => ({
+        ...datei,
+        pfad: datei.pfad.startsWith(altesPraefix)
+            ? `${neuesPraefix}${datei.pfad.slice(altesPraefix.length)}`
+            : datei.pfad,
+        inhalt: datei.inhalt.replace(grenze, neu),
+    }));
+}
+/**
+ * Welcher Unterordner die Werkbank ist — **abgeleitet, nicht getippt**.
+ *
+ * Erkennungsregel: der einzige Unterordner, der DIREKT eine eigene `CLAUDE.md`
+ * traegt (Pfad `<ordner>/CLAUDE.md`, genau zwei Teile). Dass es genau einen gibt,
+ * sichert `check:arbeitsplatz` (Pruefung 10) — ohne diese Wache waehlte die Regel
+ * bei mehreren stumm den ersten.
+ *
+ * 🔴 Diese Regel stand vorher ZWEIMAL im Projekt, wortgleich: einmal in
+ * `cli/src/arbeitsplatz-dateien.ts` (Befund R2-3) und einmal in
+ * `src/lib/arbeitsplatz/ausliefern.ts` (Runde 3). Beide Male war die Begruendung
+ * „nicht austippen" — und trotzdem wurde die Ableitung selbst kopiert.
+ * *Zwei Kopien einer Ableitung sind dieselbe zweite Wahrheit wie zwei Kopien des
+ * Namens, nur besser getarnt.*
+ */
+export function werkbankAusDateien(dateien) {
+    for (const datei of dateien) {
+        const teile = datei.pfad.split("/");
+        if (teile.length === 2 && teile[1] === "CLAUDE.md")
+            return teile[0];
+    }
+    return null;
+}
+/**
+ * Sonderzeichen eines regulaeren Ausdrucks entschaerfen.
+ *
+ * 🔑 Der Name kommt aus einer Server-Antwort. `werkbankOrdnerAus` laesst zwar
+ * nur `[a-z0-9-]` durch — aber `werkbankUmbenennen` bekommt `alt` NICHT von
+ * dort, sondern aus der gelieferten Dateiliste (`werkbankAusDateien`). Was von
+ * aussen kommt, wird nie zum Muster. *Eine Regel, die nur fuer den einen
+ * Aufrufer gilt, ist keine Regel dieser Funktion* -- dieselbe Lehre wie bei der
+ * Zusicherung ueber die Beispiele.
+ */
+function maskiere(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.",
   "type": "module",
   "bin": {