kimal3 0.1.5 → 0.1.6

package/dist/befehle/werkbank.js

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

package/dist/befehle-katalog.js

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

package/dist/gesehen.js

@@ -0,0 +1,85 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Welche Nachricht an welchem Tag schon im Terminal stand.
+ *
+ * 🔑 WARUM EINE EIGENE DATEI UND NICHT IN anmeldung.json: `kimal3 logout`
+ * loescht die Anmeldedatei. Laege der Merkzettel darin, kaeme nach jedem
+ * Abmelden jede Nachricht von vorn -- und ausgerechnet der Mensch, der sich
+ * gerade neu anmeldet, bekaeme die Wand.
+ *
+ * 🔴 BEIDE FUNKTIONEN WERFEN NIE. Ein kaputter oder schreibgeschuetzter
+ * Merkzettel darf keinen Befehl scheitern lassen (Spec US-8). Schlimmstenfalls
+ * sieht der Kunde denselben Hinweis zweimal -- das ist kein Schaden, ein
+ * abgebrochener `projekt neu` schon.
+ */
+const ORDNER = join(homedir(), ".kimal3");
+const DATEI = join(ORDNER, "gesehen.json");
+export function leseGesehen() {
+    try {
+        const roh = JSON.parse(readFileSync(DATEI, "utf8"));
+        if (!roh || typeof roh !== "object" || Array.isArray(roh))
+            return {};
+        const raus = {};
+        for (const [k, v] of Object.entries(roh)) {
+            // Nur Zeichenketten uebernehmen. Wer die Datei von Hand bearbeitet hat,
+            // soll damit hoechstens seinen eigenen Merkzettel verlieren.
+            if (typeof v === "string")
+                raus[k] = v;
+        }
+        return raus;
+    }
+    catch {
+        return {};
+    }
+}
+export function merkeGesehen(id, tag) {
+    try {
+        const alles = leseGesehen();
+        /*
+          🔑 ERST LOESCHEN, DANN SETZEN -- damit der Eintrag ans ENDE rutscht.
+          Ohne die erste Zeile behaelt ein schon vorhandener Schluessel seinen
+          alten Platz, und `slice(-20)` unten wirft dann ausgerechnet den weg, den
+          wir gerade geschrieben haben (Befund der vierten Review-Runde: der
+          Kommentar unten versprach genau das Gegenteil).
+    
+          Die Folge waere klein -- derselbe Hinweis erschiene einmal zu viel --,
+          aber sie steht im Widerspruch zu einer Zusage im Code. Und eine Zusage
+          im Code ist das, was der naechste Leser glaubt, statt nachzurechnen.
+        */
+        delete alles[id];
+        alles[id] = tag;
+        /*
+          ⚠️ Nur die letzten 20 behalten. Ohne diese Zeile waechst die Datei mit
+          jeder je gezeigten Nachricht -- langsam, aber ohne Ende, und niemand
+          raeumt sie je auf.
+    
+          🔑 Warum das gefahrlos ist: `Object.entries` gibt Zeichenketten-Schluessel
+          in Einfuegereihenfolge zurueck, und der gerade gesetzte Eintrag ist immer
+          dabei -- entweder als letzter (neu) oder an seinem alten Platz
+          (aktualisiert). Was hinten abfaellt, ist die aelteste Nachricht; die
+          schlimmste Folge waere, dass sie noch einmal erscheint.
+        */
+        const paare = Object.entries(alles).slice(-20);
+        /*
+          ⚠️ `mode: 0o700` wie in anmeldung.ts -- und das ist KEINE Kosmetik
+          (Befund der ersten Review-Runde): `mkdirSync` mit `recursive: true`
+          aendert die Rechte eines Ordners, den es schon gibt, NICHT MEHR. Wer
+          diesen Ordner also zuerst anlegt, legt seine Rechte fuer immer fest.
+    
+          Der Fall ist echt: Ein Mensch mit altem Skill, aber ohne Anmeldung,
+          tippt `kimal3` -- der Skill-Hinweis feuert, dieser Merkzettel entsteht,
+          und `~/.kimal3` bekaeme die Vorgabe-Rechte (auf einem gemeinsam
+          genutzten Rechner meist 0755). Ein spaeteres `kimal3 login` koennte sie
+          nicht mehr enger ziehen. Der Ausweis selbst bliebe zwar 0600 -- aber die
+          Haertung des Ordners waere still verloren, und "still" ist hier das
+          Schlimme.
+        */
+        mkdirSync(ORDNER, { recursive: true, mode: 0o700 });
+        writeFileSync(DATEI, JSON.stringify(Object.fromEntries(paare), null, 2), "utf8");
+    }
+    catch {
+        /* Merkzettel nicht schreibbar -- der Befehl laeuft trotzdem durch. */
+    }
+}