kimal3 0.1.5 → 0.1.6

package/dist/kimal3.js

@@ -11,17 +11,21 @@
  * `kimal3 login`, bei 4 hilft genau das nicht. Wer beide auf dieselbe Zahl
  * legt, laesst Claude den falschen Rat geben.
  */
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
-import { NichtAngemeldet } from "./api.js";
+import { gemerkterHinweis, NichtAngemeldet } from "./api.js";
+import { leseGesehen, merkeGesehen } from "./gesehen.js";
+import { formatiere, heuteAus, skillMeldung, skillZustand, sollZeigen, } from "./nachricht.js";
+import { eigeneVersion } from "./version.js";
 import { hilfeText } from "./befehle-katalog.js";
 import { arbeitsplatzNeu } from "./befehle/arbeitsplatz.js";
+import { werkbankNeu } from "./befehle/werkbank.js";
 import { firmaDaten } from "./befehle/firma-daten.js";
 import { login } from "./befehle/login.js";
 import { logout } from "./befehle/logout.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
-import { skillInstall } from "./befehle/skill-install.js";
+import { skillDatei, skillInstall } from "./befehle/skill-install.js";
 // 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
 // `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
 // Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten
@@ -57,20 +61,167 @@ const HILFE = hilfeText();
  * eine Ebene unter `cli/`.
  */
 function versionsZeilen() {
-    let version = "unbekannt";
+    // 📌 Seit dem 2026-08-21 wird die Nummer NICHT mehr hier gelesen, sondern in
+    // `version.ts` -- sie hat einen zweiten Aufrufer bekommen (den Skill-Stempel
+    // in `skill install`). Zwei Lesestellen fuer dieselbe Zahl waeren genau das
+    // Muster, gegen das der Kommentar oben schon einmal geschrieben wurde.
+    //
+    // "unbekannt" bleibt hier stehen und wandert NICHT in `version.ts`: Diese
+    // Zeile zeigt einem Menschen etwas an, und da ist "unbekannt" die ehrliche
+    // Antwort. Der andere Aufrufer RECHNET mit dem Wert und braucht dort das
+    // Gegenteil -- er will lieber gar keine Nummer als eine erfundene.
+    const version = eigeneVersion() ?? "unbekannt";
+    return `  kimal3 ${version}\n  spricht mit ${BASIS_URL}`;
+}
+/**
+ * Welcher Update-Hinweis soll ans Ende -- oder keiner?
+ *
+ * 🔑 WARUM stderr (entschieden wird es erst beim Schreiben, gemeint ist es
+ * hier): Dort stoert der Hinweis keine Weiterverarbeitung --
+ * `kimal3 firma daten > firma.json` bleibt sauberes JSON --, und Claude sieht
+ * ihn trotzdem, denn es liest beide Kanaele.
+ *
+ * 🔴 WARUM ALLES IN EINEM try STECKT: Diese Funktion laeuft NACH dem
+ * eigentlichen Befehl. Wenn sie wirft, faellt ein bereits erfolgreicher Befehl
+ * auf Rueckgabewert 3 -- und Claude gaebe den Rat "gleich noch einmal" fuer
+ * etwas, das laengst erledigt ist. Die Zahlen sind laut dem Kopf dieser Datei
+ * die eigentliche Schnittstelle; ein Nebenschauplatz darf sie nicht anfassen.
+ */
+function hinweisText() {
     try {
-        const roh = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-        if (roh && typeof roh === "object" && "version" in roh) {
-            const v = roh.version;
-            if (typeof v === "string")
-                version = v;
+        const eigene = eigeneVersion();
+        // Ohne eigene Nummer ist jeder Vergleich geraten -- dann lieber schweigen.
+        // Das ist der Fall "package.json unlesbar", und da hat der Kunde groessere
+        // Sorgen als einen Update-Hinweis.
+        if (eigene === null)
+            return null;
+        const heute = heuteAus(new Date());
+        const h = gemerkterHinweis();
+        if (h && sollZeigen(h, eigene, leseGesehen(), heute)) {
+            // Hoechstens EIN Hinweis je Aufruf -- zwei sind eine Wand.
+            return { text: formatiere(h), kennung: h.id, tag: heute };
+        }
+        /*
+          Weg 2: ohne Netz.
+          ⚠️ Er greift immer dann, wenn oben NICHTS gezeigt wird -- nicht nur,
+          wenn gar kein Netz-Hinweis ankam (praezisiert nach der dritten
+          Review-Runde). Auch "die Nachricht stand heute schon da" und "sie gilt
+          fuer diese Fassung nicht" fuehren hierher. Das ist gewollt: Es bleibt
+          bei einem Hinweis je Aufruf.
+          *Hier stand vorher "nur, wenn kein Netz-Hinweis kam" -- eine Bedingung,
+          die der Code nicht hat. Genau der Kommentartyp, den dieses Projekt schon
+          zweimal teuer bezahlt hat.*
+        */
+        // Der Pfad kommt aus `skill-install.ts` -- dort wird er geschrieben, hier
+        // gelesen. Zwei Zusammenbauten desselben Ortes driften, und der zweite
+        // verrottet lautlos (Befund der vierten Review-Runde).
+        const datei = skillDatei();
+        const inhalt = existsSync(datei) ? readFileSync(datei, "utf8") : null;
+        if (skillZustand(inhalt, eigene) === "veraltet") {
+            // Auch dieser Hinweis nur einmal am Tag, unter einer festen Kennung.
+            // Sie kann mit keiner Nachrichten-UUID kollidieren.
+            const gesehen = leseGesehen();
+            if (gesehen["skill-veraltet"] !== heute) {
+                return { text: skillMeldung(), kennung: "skill-veraltet", tag: heute };
+            }
         }
     }
     catch {
-        // Kein Absturz, wenn die Datei fehlt: "unbekannt" ist eine ehrliche
-        // Antwort, ein Stapelabzug waere keine.
+        /* Ein Nebenschauplatz darf den Befehl nicht umwerfen. */
+    }
+    return null;
+}
+/**
+ * Den Hinweis schreiben und ERST DANN aussteigen.
+ *
+ * 🔴 WARUM NICHT EINFACH `console.error` UND `process.exit`: Auf Windows ist
+ * `process.stderr` auch bei Roehren und Terminals ASYNCHRON, und
+ * `process.exit()` wirft ausstehende Schreibvorgaenge weg (Befund der ersten
+ * Review-Runde). Der Hinweis ist das Letzte, was geschrieben wird -- er waere
+ * damit genau das Erste, was verlorengeht. *Ein Merkmal, dessen ganzer Wert an
+ * der letzten Zeile haengt, darf diese Zeile nicht dem Zufall ueberlassen.*
+ *
+ * `process.exitCode` wird vorher gesetzt: Sollte der Rueckruf wider Erwarten
+ * ausbleiben und der Prozess von selbst enden, stimmt die Zahl trotzdem -- und
+ * die Zahl ist laut dem Kopf dieser Datei die eigentliche Schnittstelle.
+ */
+function endeMitHinweis(code) {
+    try {
+        process.exitCode = code;
+        /*
+          🔴 NUR NACH EINEM GELUNGENEN BEFEHL (Befund der sechsten Review-Runde).
+          `haupt()` WIRFT bei den meisten Fehlern nicht, sondern gibt eine Zahl
+          zurueck -- 1 fuer einen unbekannten Befehl, 2 und 4 aus den Befehlen
+          selbst. Der Hinweis landete damit unter Fehlermeldungen, obwohl der
+          `.catch`-Zweig unten und der Wrapper auf dem Server beide das Gegenteil
+          begruenden: "Eine Fehlermeldung ist der schlechteste Augenblick fuer eine
+          Nebenbemerkung."
+    
+          ⚠️ Schlimmer als die Optik ist die Nebenwirkung: Der gescheiterte Lauf
+          verbrauchte den EINEN Platz des Tages. Wer sich vertippt und danach
+          richtig tippt, saehe die Nachricht dann heute gar nicht mehr.
+        */
+        const raus = code === 0 ? hinweisText() : null;
+        /*
+          🔴 BEIDE KANAELE LEEREN, NICHT NUR STDERR. Die erste Fassung dieser
+          Funktion sicherte stderr -- und liess den haeufigeren Weg (kein Hinweis)
+          bei einem nackten `process.exit` stehen. Genau der Fehler, gegen den sie
+          geschrieben war, stand also noch daneben.
+    
+          Es trifft naemlich vor allem STDOUT: `firma daten` schreibt ein
+          mehrere Kilobyte grosses JSON mit `console.log` und landet dann hier.
+          Auf Windows sind beide Kanaele asynchron; `process.exit()` wirft
+          Ausstehendes weg. Das Ergebnis waere das schlimmstmoegliche: ein
+          abgeschnittenes JSON MIT Rueckgabewert 0 -- Claude liest es als
+          gelungene Auskunft.
+    
+          🔑 Warum ueberhaupt noch `process.exit` und kein natuerliches Ende:
+          Nach einem `fetch` haelt Node seine Verbindungen eine Weile offen. Der
+          Befehl wuerde sekundenlang scheinbar haengen, nachdem er fertig ist.
+    
+          Die Notbremse ist `unref`t: Sie haelt die Schleife nicht am Leben,
+          feuert aber, falls ein Kanal wirklich haengt. Und weil `exitCode` schon
+          oben steht, stimmt die Zahl in JEDEM dieser Wege -- auch dann, wenn der
+          Prozess von selbst endet.
+    
+          🔴 UND DIE REIHENFOLGE IST DER PUNKT (Befund der sechsten Review-Runde):
+          ERST stdout leeren, DANN den Hinweis auf stderr schreiben. Die beiden
+          Kanaele haben eigene Puffer, und ihre Reihenfolge ist nur dann sicher,
+          wenn beide synchron sind -- auf einer POSIX-Roehre ist stdout es NICHT.
+          Bei `kimal3 firma daten 2>&1 | tee firma.json` mit mehr als 64 KiB
+          Nutzlast koennte die kleine stderr-Zeile also VOR dem grossen JSON
+          ankommen und mitten hineinrutschen. Genau das verbietet US-1 ("nie
+          mittendrin"), und es waere eine Ausgabe, die SKILL.md als Firmendaten
+          zu lesen anweist.
+          📌 Auf Windows liess es sich nicht herstellen -- dort sind Roehren
+          synchron. *Eine Reihenfolge, die nur auf dem Rechner haelt, auf dem man
+          sie gemessen hat, ist keine Reihenfolge, sondern ein Zufall.*
+        */
+        setTimeout(() => process.exit(code), 2000).unref();
+        process.stdout.write("", () => {
+            if (!raus) {
+                process.stderr.write("", () => process.exit(code));
+                return;
+            }
+            // Erst schreiben, DANN vermerken -- und nur, wenn kein Fehler zurueckkam.
+            process.stderr.write(`${raus.text}\n`, (fehler) => {
+                if (!fehler)
+                    merkeGesehen(raus.kennung, raus.tag);
+                process.exit(code);
+            });
+        });
+    }
+    catch {
+        /*
+          ⚠️ Auch das Schreiben selbst kann werfen -- ein geschlossener
+          Ausgabekanal genuegt. Ohne dieses `catch` liefe der Wurf in den
+          `.catch`-Zweig unten, und der macht aus einem GELUNGENEN Befehl eine
+          3 ("gleich noch einmal"). Das ist genau das, was der Kommentar an
+          `hinweisText` verspricht, dass es nie passiert -- versprochen war es
+          dort aber nur fuer die halbe Strecke.
+        */
+        process.exit(code);
     }
-    return `  kimal3 ${version}\n  spricht mit ${BASIS_URL}`;
 }
 /**
  * Was diese Zeile sagen KANN — und was nicht.
@@ -126,11 +277,16 @@ async function haupt() {
         return skillInstall();
     if (argv[0] === "arbeitsplatz" && argv[1] === "neu")
         return arbeitsplatzNeu(argv.slice(2));
+    if (argv[0] === "werkbank" && argv[1] === "neu")
+        return werkbankNeu(argv.slice(2));
     console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);
     return 1;
 }
 haupt()
-    .then((code) => process.exit(code))
+    .then((code) => endeMitHinweis(code))
+    // ⚠️ Im Fehlerzweig bewusst KEIN Hinweis. Wer gerade eine Fehlermeldung
+    // liest, braucht keine zweite Zeile ueber Updates -- und ein Netz-Hinweis
+    // kann hier ohnehin nicht angekommen sein, denn genau das Netz hat versagt.
     .catch((f) => {
     if (f instanceof NichtAngemeldet) {
         console.error("Bitte zuerst `kimal3 login` ausführen.");

package/dist/nachricht.js

@@ -0,0 +1,198 @@
+/**
+ * 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";
+}

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, "\\$&");
+}