kimal3 0.2.0 → 0.2.1

package/dist/befehle/kontext-hoch.js

@@ -173,19 +173,52 @@ export async function kontextHoch(argv) {
       mitnimmt. Gemessen auf der Kundenstrecke am 2026-08-25.
     */
     const zuSchreiben = merkzettelNachHoch(ergebnis.merkzettel, lokalerMerkzettel, FIRMEN_TEXTE.map((d) => d.pfad));
+    /*
+      🔴 **DIE ERFOLGSMELDUNG STEHT VOR DEM MERKZETTEL** (Review-Runde 4).
+  
+      Sie stand darunter -- und fiel damit in genau dem Fall aus, in dem sie am
+      meisten gebraucht wird: Die Firma hat gespeichert, nur die lokale Datei
+      liess sich nicht schreiben. Der Mensch las eine Fehlermeldung und erfuhr
+      **nicht einmal, WAS oben angekommen ist**, obwohl der Vorgang gelungen war.
+  
+      🔑 Die Reihenfolge ist die Wahrheit: Erst sagen, was passiert ist, dann,
+      was daneben schiefging. Was hochgeschickt wurde, haengt nicht daran, ob ein
+      Merkzettel auf der Platte landet.
+    */
+    console.log(`✓ hochgeschickt: ${ergebnis.uebernommen.join(", ")}`);
     const merkzettelSchreiben = schreibeMerkzettelDatei(ordner, zuSchreiben);
     if (!merkzettelSchreiben.ok) {
-        console.error("Die Firma hat deine Aenderungen gespeichert -- nur der lokale Merkzettel liess sich nicht schreiben:");
+        /*
+          🔴 **ECHTE UMLAUTE -- das liest ein Kunde im Terminal** (Projektregel,
+          Review-Befund J2; dieselbe Begruendung steht in `kontext-fragen.ts:26`
+          und `kontext-gemeinsam.ts:72`). Hier stand die ASCII-Umschrift.
+    
+          ⚠️ Sie war nicht nur unschoen, sie hat etwas kaputt gemacht: Diese Zeile
+          ist ein NACHSCHLAGE-SCHLUESSEL. `SKILL.md` und `k3kontext.md` fuehren sie
+          woertlich in einer Tabelle "Was in der Meldung steht", damit Claude den
+          Fall erkennt -- und dieser Fall ist der teuerste ueberhaupt, weil er ein
+          ERFOLG ist, der wie ein Fehler aussieht. Wer nach dem Satz mit Umlauten
+          sucht und die Umschrift vorfindet, erkennt ihn nicht und faellt auf die
+          naechstbeste Zeile zurueck -- „du bist kein Admin".
+          *Ein Text, den eine Anleitung zitiert, ist eine Schnittstelle.*
+    
+          🔬 Bewacht von `check:cli` -- aber **nur die Fassung in `k3kontext.md`**
+          (Review-Runde 5; hier stand, `SKILL.md` sei mitgedeckt, und das stimmte
+          nicht). In `SKILL.md` steht derselbe Satz ueber einen Zeilenumbruch
+          verteilt und ist durch eine `includes`-Pruefung ohnehin nicht erfassbar.
+          *Wer den Satz hier aendert, aendert ihn dort von Hand mit.*
+        */
+        console.error("Die Firma hat deine Änderungen gespeichert — nur der lokale Merkzettel ließ sich nicht schreiben:");
         console.error(merkzettelSchreiben.meldung);
         return 1;
     }
-    // US-3: WAS hochgeladen wurde, nicht nur "fertig".
+    // US-3: WAS hochgeladen wurde, nicht nur "fertig" -- die Zeile steht seit
+    // Runde 4 oben, vor der Merkzettel-Pruefung (Begruendung dort).
     //
     // 🔑 Der Erklaersatz darunter ist mit Fund F ersatzlos WEGGEFALLEN. Er
     // benannte eine Ausnahme, die es nicht mehr gibt -- fuenf Texte, zwei
     // Richtungen, kein Sonderfall zu lernen. Die Namen kommen aus der Antwort
     // der Route (`uebernommen`), nicht aus einer zweiten Liste hier.
-    console.log(`✓ hochgeschickt: ${ergebnis.uebernommen.join(", ")}`);
     return 0;
 }
 /** Prueft die Antwort-Form von POST, ohne `any`. */

package/dist/befehle/kontext-runter.js

@@ -2,7 +2,7 @@ import { zerlege } from "../argumente.js";
 import { ruf } from "../api.js";
 import { heuteAus } from "../nachricht.js";
 import { istUnsichererPfad } from "../arbeitsplatz-dateien.js";
-import { LEER, VERWALTETE_DATEIEN, alsMerkzettel, sicherungsOrdner, sicherungsZiel, lageFuerDatei, ratNachUnberuehrt, } from "../kontext-stand.js";
+import { LEER, VERWALTETE_DATEIEN, alsMerkzettel, sicherungsOrdner, sicherungsZiel, lageAusMerkzetteln, ratNachUnberuehrt, } from "../kontext-stand.js";
 import { leseEineDatei, leseMerkzettelDatei, schreibeMerkzettelDatei, schreibeVerwalteteDatei, sichereDatei, } from "../kontext-dateien.js";
 import { ERLAUBT, absage, arbeitsplatzOderAbsage } from "./kontext-gemeinsam.js";
 /**
@@ -85,6 +85,11 @@ export async function kontextRunter(argv) {
     const lokalerMerkzettel = leseMerkzettelDatei(ordner);
     const heute = heuteAus(new Date());
     const geschrieben = [];
+    // Punkt A-1: die Teilmenge von `geschrieben`, bei der NICHT die Firma etwas
+    // geaendert hat, sondern wir unsere eigene Vorlage. Der Mensch soll den
+    // Unterschied lesen koennen -- sonst wundert er sich, warum sich eine Datei
+    // aendert, an der seine Firma nachweislich nichts getan hat.
+    const vorlageErneuert = [];
     const gesicherte = [];
     const unberuehrt = [];
     for (const verwalteterPfad of VERWALTETE_DATEIEN) {
@@ -104,13 +109,26 @@ export async function kontextRunter(argv) {
             console.error(lokalGelesen.meldung);
             return 1;
         }
-        const eintrag = lokalerMerkzettel.dateien[verwalteterPfad] ?? null;
-        const serverStand = daten.merkzettel.dateien[verwalteterPfad]?.stand ?? LEER;
-        const lage = lageFuerDatei({
+        /*
+          🔴 **DIE BEIDEN MERKZETTEL GEHEN ALS GANZES HINEIN -- Punkt A-1,
+          2026-08-26.** Hier standen vorher drei Zeilen, die den Eintrag, den
+          Firmenstand und den Vordruck-Abdruck einzeln aus den beiden Dateien
+          herausklaubten. Genau dieser Schritt war die Blindstelle: Der
+          Vordruck-Abdruck wurde nie herausgeklaubt, das Argument war optional,
+          und deshalb bekam ein Kunde mit einer bestehenden Datei Verbesserungen
+          an unserem Fragenkatalog NIE zu sehen -- der Befehl meldete stattdessen
+          „Dein Firmenkontext ist aktuell".
+    
+          🔑 Die Zuordnung „was kommt aus welchem Merkzettel" wohnt jetzt in
+          `lageAusMerkzetteln` (`kontext-stand.ts`), wo `check:kontext` sie messen
+          kann. *Was gesichert sein muss, gehoert auf die reine Seite.*
+        */
+        const lage = lageAusMerkzetteln({
+            pfad: verwalteterPfad,
             lokalerInhalt: lokalGelesen.inhalt,
             serverInhalt: serverDatei.inhalt,
-            eintrag,
-            serverStand,
+            lokal: lokalerMerkzettel,
+            vomServer: daten.merkzettel,
         });
         if (lage === "beides") {
             // `lokalGelesen.inhalt` ist hier garantiert eine Zeichenkette:
@@ -130,13 +148,29 @@ export async function kontextRunter(argv) {
                 nebenVorhandener: sicherung.nebenVorhandener,
             });
         }
-        if (lage === "server-neuer" || lage === "beides") {
+        /*
+          🔴 **`vorlage-neuer` schreibt wie `server-neuer` -- und sichert bewusst
+          NICHT** (Punkt A-1, 2026-08-26). Diese Lage heisst: Die Datei steht noch
+          Zeichen fuer Zeichen so da, wie wir sie zuletzt geliefert haben (die
+          Pruefsumme im Merkzettel passt), die Firma hat nichts geaendert -- nur
+          WIR haben unsere Frage besser formuliert. Es gibt hier also nichts von
+          einem Menschen zu verlieren. Haette er die Datei angefasst, waere die
+          Lage `beides` und die Sicherung liefe eine Bedingung weiter oben.
+    
+          ⚠️ Bis zu diesem Punkt fiel `vorlage-neuer` durch ALLE drei `if`s: nicht
+          geschrieben, nicht gesichert, nicht gemeldet. Der Fall konnte bisher nie
+          entstehen, weil die Kette dahinter tot war -- ein Zweig, den niemand
+          vermisst hat, weil ihn niemand erreichen konnte.
+        */
+        if (lage === "server-neuer" || lage === "beides" || lage === "vorlage-neuer") {
             const geschriebenErg = schreibeVerwalteteDatei(ordner, verwalteterPfad, serverDatei.inhalt);
             if (!geschriebenErg.ok) {
                 console.error(geschriebenErg.meldung);
                 return 1;
             }
             geschrieben.push(verwalteterPfad);
+            if (lage === "vorlage-neuer")
+                vorlageErneuert.push(verwalteterPfad);
         }
         if (lage === "lokal-geaendert") {
             unberuehrt.push(verwalteterPfad);
@@ -155,6 +189,15 @@ export async function kontextRunter(argv) {
       Firma, die diese Antwort tatsaechlich beantwortet hat (`waehleFirma` in
       der Route), nicht aus dem Merkzettel-Feld selbst. Wer zu MEHREREN Firmen
       gehoert, soll im Ordner von Firma A niemals lesen "B hat sich geaendert".
+  
+      🔴 **Punkt A-1: MIT DIESER ZEILE HAELT DER MERKZETTEL DEN NEUEN
+      VORLAGEN-FINGERABDRUCK FEST.** `daten.merkzettel.dateien` kommt aus der
+      Antwort des Servers und traegt je Datei ihr `vorlage` (`alsMerkzettel`
+      verlangt es ausdruecklich). Waere es der LOKALE Merkzettel, staende hier
+      weiter der Abdruck von gestern -- und der naechste Lauf meldete denselben
+      Unterschied noch einmal, Tag fuer Tag. *Der Teil, den man leicht
+      uebersieht: Eine Verbesserung, die jeden Tag neu gemeldet wird, ist
+      dieselbe Sorte Fehlalarm wie eine, die nie ankommt.*
     */
     const merkzettelZumSchreiben = { firma_id: daten.firma.id, dateien: daten.merkzettel.dateien };
     const merkzettelSchreiben = schreibeMerkzettelDatei(ordner, merkzettelZumSchreiben);
@@ -191,6 +234,14 @@ export async function kontextRunter(argv) {
     if (geschrieben.length > 0) {
         console.log(`✓ aktualisiert: ${geschrieben.join(", ")}`);
     }
+    // 🔴 Punkt A-1: Eine eigene Zeile, kein stilles Mitschreiben. „Aktualisiert"
+    // heisst fuer den Leser sonst automatisch „meine Firma hat etwas gesagt" --
+    // und dann sucht er in der App eine Aenderung, die es dort nicht gibt.
+    if (vorlageErneuert.length > 0) {
+        console.log(`  Davon aus unserer verbesserten Vorlage: ${vorlageErneuert.join(", ")}`);
+        console.log("  Diese Dateien standen noch genau so da, wie wir sie geliefert hatten — es ist nichts\n" +
+            "  von dir verloren gegangen. Hättest du darin etwas geändert, hätte ich vorher gesichert.");
+    }
     // §8: Ein Fehlerfall darf nie denselben Namen tragen wie ein Erfolgsfall --
     // "nichts geschrieben" heisst hier DREI verschiedene Dinge, und die Ausgabe
     // muss sie unterscheiden, nicht nur die Rueckgabe (alle drei geben 0).

package/dist/befehle/skill-install.js

@@ -4,22 +4,21 @@ import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 import { STEMPEL_MARKE } from "../nachricht.js";
 import { eigeneVersion } from "../version.js";
-/**
- * Namen, die frueher einmal ausgeliefert wurden und heute nicht mehr.
- *
- * 🔑 **Wofuer das da ist** (Review-Befund, 2026-08-18): Die Befehle landen im
- * GEMEINSAMEN Ordner `~/.claude/commands/` und werden dort nur ueberschrieben,
- * nie entfernt. Wird ein Befehl spaeter umbenannt oder gestrichen, ueberlebt
- * die alte Datei jedes `skill install` und bietet weiter Anweisungen an, die
- * auf einen nicht mehr vorhandenen Unterbefehl zeigen. `SKILL.md` kann das
- * nicht passieren -- es ist EINE Datei, die ueberschrieben wird.
- *
- * ⚠️ Warum eine Liste und nicht "alles loeschen, was wir nicht ausliefern":
- * Der Ordner gehoert dem Menschen. Ein `k3*.md`, das er selbst angelegt hat,
- * duerfen wir nicht wegraeumen. **Wer einen Befehl umbenennt oder entfernt,
- * traegt den alten Namen hier ein** -- sonst bleibt er beim Nutzer stehen.
- */
-const VERALTETE_BEFEHLE = [];
+export const VERALTETE_BEFEHLE = [
+    /*
+      🔴 **Der ERSTE Eintrag ueberhaupt** (2026-08-28). `/k3firma` heisst jetzt
+      `/k3analyse`, weil der Befehl Zahlen holt und daraus eine Frage beantwortet
+      -- das ist eine Auswertung, und der alte Name sagte nur, WORUEBER sie geht.
+      Ohne diese Zeile staenden beide Dateien nebeneinander und taeten dasselbe;
+      nur wuerde `k3firma.md` nie wieder gepflegt.
+  
+      ⚠️ Damit laeuft `raeumeVeralteteAuf` zum ersten Mal scharf. Der Kommentar
+      an der Funktion sagt es selbst: Die Schleife ist nie gelaufen. Deshalb
+      gehoert zu diesem Eintrag eine Rot-Probe in BEIDE Richtungen -- eine Datei
+      MIT unserer Marke muss verschwinden, eine OHNE muss liegen bleiben.
+    */
+    { alt: "k3firma.md", ersetztDurch: "k3analyse.md" },
+];
 /**
  * Woran wir unsere eigenen Befehlsdateien erkennen.
  *
@@ -344,7 +343,42 @@ function slashBefehleInstallieren() {
         console.error(`Die Slash-Befehle liessen sich nicht alle schreiben: ${String(fehler)}`);
         gestoert = true;
     }
-    raeumeVeralteteAuf(zielOrdner, VERALTETE_BEFEHLE);
+    /*
+      🔴 **NUR aufraeumen, wenn das Schreiben durchlief** (Review-Runde 2,
+      2026-08-28). Der Aufruf stand ausserhalb des `try` und lief deshalb auch
+      nach einem Fehler -- mit einer boesen Folge: `k3firma.md` wird geloescht,
+      obwohl `k3analyse.md` womoeglich nie geschrieben wurde. Der Mensch haette
+      danach **keinen von beiden** Befehlen.
+  
+      ⚠️ Und der Fall ist naeher, als er klingt: Die Dateien werden alphabetisch
+      kopiert, `k3analyse.md` ist die ZWEITE. Ein Rechteproblem oder eine volle
+      Platte genau dort genuegt.
+  
+      🔑 Die sichere Richtung ist eindeutig: Lieber traegt jemand den alten
+      Befehl eine Runde laenger mit sich herum, als dass er ohne dasteht. Ein
+      zweiter Lauf holt beides nach -- der Rueckgabewert sagt ihm das ohnehin.
+    */
+    /*
+      🔴 **Nachgeschaerft in Runde 3.** Die erste Fassung hiess `if (!gestoert)`
+      und deckte nur EINE der drei Arten ab, auf die eine Datei nicht landet:
+      `gestoert` (eine Ausnahme beim Kopieren) -- aber nicht `unlesbar` und nicht
+      `uebersprungen` (dort liegt eine Datei OHNE unsere Marke, die wir bewusst
+      stehen lassen). In beiden Faellen waere `k3firma.md` geloescht worden,
+      obwohl `k3analyse.md` nie geschrieben wurde.
+  
+      🔑 Die Bedingung trifft jetzt die Absicht direkt: **Ein alter Name wird nur
+      entfernt, wenn sein Ersatz wirklich liegt.** Steht kein Ersatz in der
+      Tabelle, gilt der Eintrag als ersatzlos gestrichen und darf immer weg.
+    */
+    /*
+      ⚠️ **Beide Schreibweisen, genau wie `raeumeVeralteteAuf`** (Review-Runde 4).
+      `VERALTETE_BEFEHLE` nimmt `"k3alt"` UND `"k3alt.md"`; `geschrieben` traegt
+      immer den Dateinamen. Ohne die Angleichung schluege der Vergleich fehl, und
+      ein Eintrag ohne `.md` bliebe fuer immer liegen.
+    */
+    const alsDatei = (n) => (n.endsWith(".md") ? n : `${n}.md`);
+    const ersatzLiegt = VERALTETE_BEFEHLE.filter((e) => e.ersetztDurch === null || geschrieben.includes(alsDatei(e.ersetztDurch))).map((e) => e.alt);
+    raeumeVeralteteAuf(zielOrdner, ersatzLiegt);
     return {
         geschrieben: geschrieben.map((n) => n.replace(/\.md$/, "")),
         uebersprungen: uebersprungen.map((n) => n.replace(/\.md$/, "")),

package/dist/befehle/werkbank.js

@@ -1,7 +1,10 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { dateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
+import { FIRMEN_OPTIONEN, dateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
+import { alsBefehlszeile, alsWort, trenneNamenUndOptionen, zerlege } from "../argumente.js";
 import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
+import { FIRMEN_CLAUDE_MD, MERKZETTEL_PFAD, firmenAbgleich, firmennameAusClaudeMd, leseMerkzettel, } from "../kontext-stand.js";
+import { leseEineDatei, leseMerkzettelDatei } from "../kontext-dateien.js";
 /**
  * Legt **nur eine Werkbank** an — in einem Firmen-Ordner, der schon steht.
  *
@@ -54,7 +57,7 @@ import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
  * darf ein lokaler Befehl nicht überschreiben.
  */
 const HILFE = `
-  kimal3 werkbank neu [dein-vorname]
+  kimal3 werkbank neu [dein-vorname] [--firma "Name" | --firma-id "…"]
 
   Legt eine eigene Werkbank in einem bestehenden Firmen-Ordner an.
   Die Firmenebene (kontext/, CLAUDE.md, README.md) wird NICHT angefasst.
@@ -63,6 +66,12 @@ const HILFE = `
                 wird "werkbank-sabine". Ohne Angabe steht dort der Name,
                 den der Server aus deiner Anmelde-Adresse gebildet hat.
 
+  --firma "Name"   Noetig, wenn du zu mehreren Firmen gehoerst.
+                   Die Absage nennt dir die Namen als fertige Befehle.
+
+  --firma-id "…"   Fuer den Fall, dass zwei deiner Firmen GLEICH heissen.
+                   Auch diese Absage nennt dir fertige Befehle.
+
   🔴 Bricht ab, wenn der Zielordner schon existiert und NICHT leer ist.
 
   Du hast noch gar keinen Firmen-Ordner?
@@ -94,7 +103,7 @@ const HILFE = `
  * Eingestaendnis, dass man es nicht weiss -- hier weiss man es.*
  */
 function hinweisFuer(ordnerName) {
-    const ziel = ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName;
+    const ziel = alsWort(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" +
@@ -116,37 +125,58 @@ export async function werkbankNeu(argv) {
       `werkbank-werkbank-sabine` zu bauen. *Alte Anleitungen ueberleben laenger
       als der Code, den sie beschreiben.*
     */
-    const nameArg = argv[0];
+    /*
+      🔴 **Erst schneiden, dann zerlegen** -- wortgleich zum Zwilling in
+      `arbeitsplatz.ts` (Punkt A-3, 2026-08-26). Dieser Befehl hat ein Wort OHNE
+      `--` (den Vornamen), und `zerlege` lehnt genau das ab.
+    */
+    const { woerter, optionen: optionsArgv } = trenneNamenUndOptionen(argv);
+    const nameArg = woerter[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) {
+    if (woerter.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]`.
+          wurde damit der Rat `werkbank neu sabine---force`.
           *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.
+    
+          ⚠️ Seit dem 2026-08-26 stehen die `--`-Optionen schon gar nicht mehr in
+          `woerter` (der Schnitt oben). Der Filter bleibt trotzdem: Er faengt das
+          EINFACHE `-` (`-force`), das kein Schnitt-Zeichen ist.
         */
-        const woerter = argv.filter((w) => !w.startsWith("-"));
-        const vorschlag = woerter.length === argv.length && woerter.length > 1
+        const einfacheWoerter = woerter.filter((w) => !w.startsWith("-"));
+        /*
+          🔴 **Die getippten Optionen reisen mit** (Review-Befund 3, 2026-08-26).
+          Ohne sie riet die Zeile zu einem Befehl, der bei einem Menschen in zwei
+          Firmen sofort wieder in dieselbe Absage laeuft -- s. `alsBefehlszeile`.
+        */
+        const optionsAnhang = optionsArgv.length === 0 ? "" : ` ${alsBefehlszeile(optionsArgv)}`;
+        const vorschlag = einfacheWoerter.length === woerter.length
             ? `Besteht dein Name aus mehreren Woertern? Dann schreib ihn zusammen:\n` +
-                `  kimal3 werkbank neu ${woerter.join("-")}\n`
+                `  kimal3 werkbank neu ${einfacheWoerter.join("-")}${optionsAnhang}\n`
             : "";
-        console.error(`Mit „${argv[1]}" kann ich hier nichts anfangen -- nur EIN Name ist erlaubt.\n` +
+        console.error(`Mit „${woerter[1]}" kann ich hier nichts anfangen -- nur EIN Name ist erlaubt.\n` +
             `${vorschlag}${HILFE}`);
         return 1;
     }
+    // 🔑 Erst NACH den Namens-Absagen -- s. Zwilling in `arbeitsplatz.ts`.
+    const zerlegt = zerlege(optionsArgv, FIRMEN_OPTIONEN);
+    if (!zerlegt.ok) {
+        console.error(`${zerlegt.meldung}\n${HILFE}`);
+        return 1;
+    }
+    const wunsch = {
+        firma: zerlegt.werte.optionen.firma,
+        firmaId: zerlegt.werte.optionen["firma-id"],
+    };
     // `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.
@@ -161,7 +191,17 @@ export async function werkbankNeu(argv) {
             return 1;
         }
     }
-    const holen = await vorlageHolen();
+    /*
+      🔴 **HIER ENTSCHEIDET SICH, OB UEBERHAUPT ETWAS ENTSTEHT** (Punkt A-3) --
+      dieselbe Stelle wie beim Zwilling: Bei mehreren Firmen ohne Angabe kommt
+      `409`, dieser Aufruf endet mit `1`, und `dateienSchreiben` weiter unten
+      wird nie erreicht.
+    */
+    // 🔑 Der getippte Vorname reist in der Absage mit -- s. Zwilling.
+    const befehlsname = nameArg === undefined
+        ? "werkbank neu"
+        : `werkbank neu ${alsWort(nameArg)}`;
+    const holen = await vorlageHolen(befehlsname, wunsch);
     if (!holen.ok)
         return holen.wert;
     const daten = holen.daten;
@@ -305,6 +345,77 @@ export async function werkbankNeu(argv) {
         console.error("  verschiedene Firmenordner mit verschiedenen Regeln darin.");
         return 1;
     }
+    /*
+      🔴 **STEHT DIE GELIEFERTE FIRMA UEBERHAUPT HIER?** (Befund 1 der zweiten
+      Review-Runde, 2026-08-27.)
+  
+      Bis hierher ist geprueft, dass NEBEN uns eine Firmenebene liegt -- aber
+      nicht, ob es DIE Firma ist, deren Namen die Lieferung gleich in die
+      `werkbank-<name>/CLAUDE.md` schreibt. Seit A-11 ist das keine Kosmetik
+      mehr: Dort stand frueher fuer jede Firma derselbe Platzhalter, jetzt steht
+      dort ein Name, den Claude bei jedem Start liest. Die ganze Fallgeschichte
+      haengt an `firmenAbgleich` in `../kontext-stand.js`.
+  
+      🔑 **Der Vergleich laeuft ueber die IDs im Merkzettel** -- der des Ordners,
+      in dem wir stehen, gegen den, der gerade geliefert wurde. Beide Seiten
+      kennen ihre Firma aus derselben Quelle, es wird nichts geraten.
+  
+      🔴 **UND ER STEHT VOR `dateienSchreiben`.** Ein Abbruch hier hinterlaesst
+      keine halbe Werkbank -- dieselbe Haltung wie in `kontextHoch`
+      („ich schicke nichts Halbes hoch“).
+    */
+    const inhaltAus = (pfad) => daten.dateien.find((d) => d.pfad === pfad)?.inhalt ?? null;
+    const hierGelesen = leseEineDatei(process.cwd(), FIRMEN_CLAUDE_MD);
+    const abgleich = firmenAbgleich({
+        id: leseMerkzettelDatei(process.cwd()).firma_id,
+        name: firmennameAusClaudeMd(hierGelesen.ok ? hierGelesen.inhalt : null),
+    }, {
+        id: leseMerkzettel(inhaltAus(MERKZETTEL_PFAD)).firma_id,
+        name: firmennameAusClaudeMd(inhaltAus(FIRMEN_CLAUDE_MD)),
+    });
+    /*
+      🔴 **DER VERDACHT WARNT, ER SPERRT NICHT** (Befund 1 der vierten
+      Review-Runde). Steht der Name nur deshalb anders da, weil jemand die
+      `CLAUDE.md` seiner Firma bearbeitet hat -- was er ausdruecklich darf --,
+      waere eine Absage falsch UND ausweglos. Die Zeile hier sagt, was sie
+      sieht, und laesst den Menschen entscheiden.
+    */
+    if (abgleich.art === "zweifel") {
+        console.error(`Achtung: Dieser Ordner nennt als Firma „${abgleich.hier}",`);
+        console.error(`du hast aber „${abgleich.gewaehlt}" gewaehlt.`);
+        console.error("Ich lege die Werkbank trotzdem an -- vielleicht heisst die Firma bei euch");
+        console.error("nur anders geschrieben. Stimmt es nicht, loesch den neuen Ordner wieder.");
+        console.error("");
+    }
+    if (abgleich.art === "andere-firma") {
+        /*
+          🔴 **ZWEI LAGEN, ZWEI SAETZE** (Befund 3 der dritten Review-Runde). Hier
+          stand ein Rueckfall `?? "die genannte Firma"`, und der war erreichbar:
+          Wer zu genau EINER Firma gehoert, tippt gar kein `--firma`. Steht er im
+          Ordner einer anderen Firma, las er woertlich *„Dieser Ordner gehoert zu
+          einer ANDEREN Firma als ‚die genannte Firma'."* -- ein Satz, der nichts
+          benennt und wie ein Fehler im Programm aussieht.
+          *Ein Platzhalter in einer Meldung ist ein Satz, den niemand geschrieben
+          hat.*
+        */
+        const genannt = wunsch.firma ?? wunsch.firmaId;
+        if (genannt === undefined) {
+            console.error("Dieser Ordner gehoert zu einer anderen Firma als der, zu der du gehoerst.");
+            console.error("Ich lege hier keine Werkbank an, die einen fremden Firmennamen traegt --");
+            console.error("sie wuerde Claude bei jedem Start die falsche Firma nennen.");
+            console.error("");
+            console.error("  Deine Werkbank gehoert in den Ordner DEINER Firma. Geh dorthin und");
+            console.error("  versuch es dort noch einmal.");
+            return 1;
+        }
+        console.error(`Dieser Ordner gehoert zu einer ANDEREN Firma als „${genannt}".`);
+        console.error("Ich lege hier keine Werkbank an, die einen fremden Firmennamen traegt --");
+        console.error("sie wuerde Claude bei jedem Start die falsche Firma nennen.");
+        console.error("");
+        console.error(`  Soll die Werkbank fuer „${genannt}" sein? Dann gehoert sie in DEREN Ordner.`);
+        console.error("  Soll sie fuer die Firma hier sein? Dann nimm deren Namen.");
+        return 1;
+    }
     /*
       🔑 Der Zielordner ist der Werkbank-Name -- entweder der, den der Server
       schon gesetzt hat (`werkbank`, aus der Anmelde-Adresse gebildet), oder der
@@ -351,7 +462,7 @@ export async function werkbankNeu(argv) {
     console.log("  Die Firmenebene ist unberuehrt geblieben.");
     console.log("");
     console.log("  Weiter geht's:");
-    console.log(`    cd ${ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName}`);
+    console.log(`    cd ${alsWort(ordnerName)}`);
     console.log("    claude");
     console.log('    dann "Lass uns einrichten" tippen');
     return 0;

package/dist/befehle-katalog.js

@@ -42,7 +42,13 @@ export const BEFEHLE = [
         tippen: "! kimal3 skill install",
         terminal: "kimal3 skill install",
         details: [
-            "Der Befehl, der aus den anderen erst etwas macht: Er legt 🤖 Claudes Anleitung ab (den „Skill“) und 🧑 deine vier Slash-Befehle.",
+            // ⚠️ KEINE Anzahl hier (Review-Runde 5): Hier stand „deine vier
+            // Slash-Befehle“, und die Zahl war ab `/k3kontext` falsch — auf der
+            // Pro-Seite UND in der Terminal-Hilfe, denn dieser Text wird an beiden
+            // Stellen ausgegeben. Dieselbe Lehre wie bei „13 Pruefungen“ in
+            // `check:arbeitsplatz`: Eine Anzahl im Fliesstext ist eine Behauptung,
+            // die verrottet. Welche es sind, sagt `/k3` beim Laufen.
+            "Der Befehl, der aus den anderen erst etwas macht: Er legt 🤖 Claudes Anleitung ab (den „Skill“) und 🧑 deine Slash-Befehle.",
             "Er läuft NICHT automatisch — einmal nach der Installation, und nach jedem Update noch einmal. Sonst arbeitet Claude weiter mit der alten Anleitung.",
             "Geklappt hat es, wenn er „Skill angelegt“ meldet und die Slash-Befehle aufzählt. Beides kennt Claude ab der NÄCHSTEN Sitzung — die laufende einmal neu starten.",
         ],
@@ -108,10 +114,10 @@ export const BEFEHLE = [
     },
     {
         befehl: "kimal3 kontext fragen",
-        beschreibung: "Zeigen, welche Fragen über deine Firma noch unbeantwortet sind",
-        wer: "du",
-        rhythmus: "bevor ihr den Firmenkontext ausfüllt — und wann immer du wissen willst, was fehlt",
-        tippen: "! kimal3 kontext fragen",
+        beschreibung: "Die Fragen über deine Firma beantworten — Claude führt dich durch",
+        wer: "claude",
+        ausloeser: "beantworten wir die Fragen über meine Firma",
+        tippen: "/k3kontext",
         terminal: "kimal3 kontext fragen",
         details: [
             "Liest die fünf Dateien in kontext/ und gibt jede Frage aus, unter der noch nichts steht — mit Datei, Frage und Hinweis. Sind alle beantwortet, sagt er das in einem Satz.",
@@ -128,7 +134,8 @@ export const BEFEHLE = [
         terminal: "kimal3 kontext hoch",
         details: [
             "Schickt alle fünf Firmen-Texte an deine Firma — die Dateien in kontext/ (kurzprofil.md, firma.md, marke.md, systeme.md, sicherheit.md). Damit kommen sie beim nächsten kontext runter auch bei den Kolleginnen und Kollegen an.",
-            "🔴 Nur der Firmen-Admin darf das. Bist du keiner, kommt Rückgabewert 1 — das ist hier kein „nochmal versuchen“, sondern „gib deine Ergänzung an den Admin weiter“.",
+            "🔴 Nur der Firmen-Admin darf das. Bist du keiner, sagt er es dir — dann gib deine Ergänzung an den Admin weiter, ein zweiter Versuch ändert daran nichts.",
+            "⚠️ Klappt etwas nicht, zählt die MELDUNG, nicht die Zahl dahinter: Dieselbe 1 steht für „du bist kein Admin“, „hier steht kein Arbeitsplatz“, „jemand anderes hat inzwischen geändert“ (Ausweg --ueberschreiben) und mehreres mehr. Sie steht sogar unter einer Meldung, die mit „Die Firma hat deine Änderungen gespeichert“ beginnt und nur sagt, dass eine Datei auf deiner Platte nicht geschrieben werden konnte — DAS ist ein Erfolg: alles ist oben angekommen. Lies den Satz, nicht die Zahl.",
             "Sieht eine der fünf Dateien nicht mehr aus wie ihre Frageliste — etwa weil etwas Fremdes darüberkopiert wurde —, bricht er ab und schickt gar nichts, auch die vier anderen nicht. kimal3 kontext runter holt die Datei zurück.",
             "Geklappt hat es, wenn er „✓ hochgeschickt“ mit den Dateinamen meldet.",
         ],
@@ -162,7 +169,7 @@ export const BEFEHLE = [
         beschreibung: "Die Daten deiner Firma holen, damit Claude sie auswerten kann",
         wer: "claude",
         ausloeser: "werte meine Firma aus",
-        tippen: "/k3firma <deine Frage>",
+        tippen: "/k3analyse <deine Frage>",
         terminal: 'kimal3 firma daten --firma "Nordwind Handel GmbH"',
         details: [
             "Holt Kennzahlen, Menschen und Projekte deiner Firma — auswerten tut Claude. Frag einfach los: „Welche drei Projekte bringen den meisten messbaren Ertrag?“",

package/dist/firmen-liste.js

@@ -2,8 +2,10 @@
  * Die Firmen-Auswahl, die eine Absage dem Menschen anbietet.
  *
  * 🔑 Eine reine Rechnung, damit `check:cli` sie ohne Server pruefen kann --
- * dieselbe Ueberlegung wie bei `fehler.ts`.
+ * dieselbe Ueberlegung wie bei `fehler.ts`. `alsWort` unten ist ebenfalls eine
+ * reine Rechnung, der Import bricht das also nicht.
  */
+import { alsWort } from "./argumente.js";
 /**
  * Aus den Namen der eigenen Firmen die Zeilen bauen, die unter „Deine Firmen:"
  * stehen.
@@ -42,7 +44,7 @@ export function firmenZeilen(namen) {
             // Fertiger Befehl statt blosser Liste: Der naechste Schritt ist dann
             // Kopieren statt Abtippen -- und ein Name mit Leerzeichen braucht
             // Anfuehrungszeichen, an die sonst niemand denkt.
-            zeilen.push(`    kimal3 firma daten --firma "${name}"`);
+            zeilen.push(`    kimal3 firma daten --firma ${alsWort(name, true)}`);
         }
         else {
             zeilen.push(`    „${name}" — kommt ${wieOft}× vor und ist über den Namen nicht wählbar.`);

package/dist/kimal3.js

@@ -13,7 +13,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
-import { gemerkterHinweis, NichtAngemeldet } from "./api.js";
+import { gemerkterHinweis, lokalerKontextStandJetzt, NichtAngemeldet } from "./api.js";
 import { leseGesehen, merkeGesehen } from "./gesehen.js";
 import { formatiere, heuteAus, skillMeldung, skillZustand, sollZeigen, } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
@@ -99,8 +99,26 @@ function hinweisText() {
         if (eigene === null)
             return null;
         const heute = heuteAus(new Date());
+        /*
+          🔴 HIER, UND NICHT FRUEHER (offener Punkt A-4). Diese Zeile liest den
+          Merkzettel auf der Platte in genau dem Augenblick, in dem der Hinweis
+          ausgegeben werden soll -- also NACH dem Befehl.
+    
+          Genau darin lag der Fehler: Den Stand, den der Server fuer seinen
+          Hinweis vergleicht, schickt die CLI im Kopf mit, und der wird VOR dem
+          Netzaufruf gelesen (`kontextStandKopf` in `api.ts`). Direkt nach
+          `kimal3 kontext runter` stand deshalb "Dein Firmenkontext ist aktuell."
+          und darunter der Rat, `kimal3 kontext runter` auszufuehren. Der zweite
+          Aufruf schwieg dann von selbst -- die Meldung kam schlicht einen Aufruf
+          zu spaet.
+    
+          🔑 `sollZeigen` VERLANGT diesen Wert (kein optionales Argument): Wer ihn
+          hier vergisst, bekommt einen Uebersetzungsfehler statt einer Rechnung,
+          die niemand mehr benutzt.
+        */
+        const standJetzt = lokalerKontextStandJetzt();
         const h = gemerkterHinweis();
-        if (h && sollZeigen(h, eigene, leseGesehen(), heute)) {
+        if (h && sollZeigen(h, eigene, leseGesehen(), heute, standJetzt)) {
             // Hoechstens EIN Hinweis je Aufruf -- zwei sind eine Wand.
             return { text: formatiere(h), kennung: h.id, tag: heute };
         }