kimal3 0.1.6 → 0.2.1

package/dist/befehle/kontext-runter.js

@@ -0,0 +1,305 @@
+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, lageAusMerkzetteln, ratNachUnberuehrt, } from "../kontext-stand.js";
+import { leseEineDatei, leseMerkzettelDatei, schreibeMerkzettelDatei, schreibeVerwalteteDatei, sichereDatei, } from "../kontext-dateien.js";
+import { ERLAUBT, absage, arbeitsplatzOderAbsage } from "./kontext-gemeinsam.js";
+/**
+ * Holt den Firmenkontext von der App und legt ihn in den verwalteten Dateien
+ * des gefundenen Arbeitsplatzes ab -- `CLAUDE.md` und die fuenf Dateien in
+ * `kontext/`.
+ *
+ * 🔴 **`kontext/kurzprofil.md` ist seit Ruling K-24 (Task 7) dabei.** Sie wurde
+ * beim ERSTEN Ausliefern gefuellt und danach nie wieder aufgefrischt -- waehrend
+ * sie selbst dem Kunden zusicherte, sie werde „zentral in der App gepflegt".
+ *
+ * 🔴 **R2 (Spec §14): Dieser Befehl fragt NIE `git status`.** Er entscheidet
+ * ausschliesslich ueber den Merkzettel (`.kimal3-stand.json`), egal ob der
+ * Ordner ein Git-Repo ist oder nicht -- sonst gaebe es zwei Verhalten fuer
+ * denselben Befehl, und das schwerer erklaerbare traefe ausgerechnet den, der
+ * Git benutzt.
+ *
+ * ⛔ **Unterhalb von `werkbank-<name>/` wird nichts geschrieben** (Spec §4).
+ * Dieser Befehl kennt genau die Pfade aus `VERWALTETE_DATEIEN`, und in keinem
+ * davon steht ein Personenname.
+ *
+ * 🔁 **Ruling T9-2:** Die Gegenrichtung, `kontextHoch`, wohnt seit dem Split
+ * von `kontext.ts` in `kontext-hoch.ts`. Beide teilen sich Fundregel,
+ * Firmenwahl-Absage und die `--firma`/`--firma-id`-Optionen ueber
+ * `kontext-gemeinsam.ts`.
+ */
+const HILFE = `
+  kimal3 kontext runter [--firma "Name" | --firma-id "…"]
+
+  Holt den Firmenkontext (CLAUDE.md + die fuenf Dateien in kontext/) und legt
+  ihn in deinem KI-Arbeitsplatz ab. Was du selbst geaendert hast, fasst der
+  Befehl nicht an -- er sagt dir, wie du es einbringst.
+
+  --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.
+`;
+export async function kontextRunter(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    const zerlegt = zerlege(argv, ERLAUBT);
+    if (!zerlegt.ok) {
+        console.error(zerlegt.meldung);
+        return 1;
+    }
+    // 📌 Seit Task 7 gemeinsam mit `kontext hoch` und `kontext fragen`
+    // (`arbeitsplatzOderAbsage`). Hier standen dieselben vier Zeilen abgetippt;
+    // bei drei Aufrufern ist das keine Wiederholung mehr, sondern eine Falle --
+    // wer eine Zeile schaerft, schaerft eine von dreien.
+    const ordner = arbeitsplatzOderAbsage();
+    if (ordner === null)
+        return 1;
+    const wunsch = zerlegt.werte.optionen.firma;
+    const wunschId = zerlegt.werte.optionen["firma-id"];
+    const suche = new URLSearchParams();
+    if (wunsch !== undefined)
+        suche.set("firma", wunsch);
+    if (wunschId !== undefined)
+        suche.set("firma-id", wunschId);
+    const pfad = suche.toString() ? `/api/cli/kontext?${suche.toString()}` : "/api/cli/kontext";
+    const antwort = await ruf(pfad, { methode: "GET", mitAusweis: true });
+    if (antwort.status !== 200) {
+        return absage(antwort, "kontext runter");
+    }
+    // 🔴 Ein `200` mit unlesbarem Rumpf ist KEIN Erfolg -- dasselbe Muster wie
+    // in `firma-daten.ts`. `ruf` verschluckt Parse-Fehler zu `null`.
+    if (antwort.koerper === null || typeof antwort.koerper !== "object") {
+        console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+        return 3;
+    }
+    const daten = alsKontextAntwort(antwort.koerper);
+    if (daten === null) {
+        console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+        return 3;
+    }
+    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) {
+        const serverDatei = daten.dateien.find((d) => d.pfad === verwalteterPfad);
+        if (!serverDatei) {
+            console.error(`Die Antwort enthaelt keine Datei „${verwalteterPfad}". Bitte melden.`);
+            return 3;
+        }
+        // Zweites Netz -- s. Kommentar an `schreibeVerwalteteDatei`: `pfad` kommt
+        // hier aus der eigenen Iteration, nicht roh vom Server, trotzdem geprueft.
+        if (istUnsichererPfad(serverDatei.pfad)) {
+            console.error(`Die Antwort enthaelt einen unsicheren Pfad: „${serverDatei.pfad}". Bitte melden.`);
+            return 3;
+        }
+        const lokalGelesen = leseEineDatei(ordner, verwalteterPfad);
+        if (!lokalGelesen.ok) {
+            console.error(lokalGelesen.meldung);
+            return 1;
+        }
+        /*
+          🔴 **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,
+            lokal: lokalerMerkzettel,
+            vomServer: daten.merkzettel,
+        });
+        if (lage === "beides") {
+            // `lokalGelesen.inhalt` ist hier garantiert eine Zeichenkette:
+            // `lageFuerDatei` liefert "beides" nie, wenn `lokalerInhalt === null`.
+            const sicherung = sichereDatei(ordner, verwalteterPfad, lokalGelesen.inhalt, heute);
+            if (!sicherung.ok) {
+                console.error(sicherung.meldung);
+                return 1;
+            }
+            // Ruling T8-2: `sichereDatei` ueberschreibt nie und ueberspringt nie --
+            // `nebenVorhandener` sagt nur, ob HEUTE schon eine andere Sicherung
+            // dieser Datei existiert. Beide Faelle sind echte Erfolge und werden
+            // unten bewusst UNTERSCHIEDLICH gemeldet (§8).
+            gesicherte.push({
+                pfad: verwalteterPfad,
+                ziel: sicherung.ziel,
+                nebenVorhandener: sicherung.nebenVorhandener,
+            });
+        }
+        /*
+          🔴 **`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);
+        }
+    }
+    /*
+      🔴 Der Merkzettel des SERVERS wird geschrieben -- unabhaengig davon, ob in
+      diesem Lauf ueberhaupt etwas geaendert wurde. Er traegt fuer JEDE der fuenf
+      Dateien den Stand, der zum jetzt ausgelieferten Inhalt passt (§7b), auch
+      fuer die, die "schon aktuell" waren oder lokal geaendert blieben -- ein
+      lokal geaenderter Eintrag bleibt so beim naechsten Lauf ERKENNBAR lokal
+      geaendert, statt durch einen fehlenden Merkzettel-Eintrag neu "sicher" zu
+      werden.
+  
+      🔴 Task 10a: `firma_id` kommt ausdruecklich aus `daten.firma.id` -- der
+      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);
+    if (!merkzettelSchreiben.ok) {
+        console.error(merkzettelSchreiben.meldung);
+        return 1;
+    }
+    // ---- Ausgabe --------------------------------------------------------
+    // 🔴 Ruling T8-2 (Fix-Runde 1): ZWEI ehrlich verschiedene Faelle, keine
+    // Pauschalmeldung mehr. "Frisch gesichert" und "zusaetzlich neben einer
+    // schon vorhandenen Sicherung von heute" sind beide echte Erfolge -- aber
+    // verschiedene, und der Mensch muss wissen, WAS mit seinem Text passiert
+    // ist. Nie ein Satz, der eine Sicherung behauptet, wo keine (mehr)
+    // entstanden ist (der urspruengliche Befund).
+    //
+    // US-7 bleibt erfuellt: Die Meldung steht VOR der "aktualisiert"-Zeile
+    // (vor dem Ergebnis) und nennt den Ordner. Die eigentliche Reihenfolge
+    // (erst sichern, dann ueberschreiben) erzwingt schon der Code oben.
+    if (gesicherte.length > 0) {
+        console.log(`Ich sichere deine lokale Fassung, bevor ich sie ersetze -- Ordner: ${sicherungsOrdner(heute)}`);
+        for (const g of gesicherte) {
+            if (g.nebenVorhandener) {
+                const bisherige = sicherungsZiel(heute, g.pfad).split("/").pop();
+                const neue = g.ziel.split("/").pop();
+                console.log(`  „${g.pfad}": Von heute gibt es schon eine Sicherung (${bisherige}) -- die bleibt ` +
+                    `unveraendert stehen. Deine neuere Fassung sichere ich zusaetzlich als ${neue}, ` +
+                    "bevor ich die Datei im Ordner ersetze.");
+            }
+            else {
+                console.log(`  „${g.pfad}" -> ${g.ziel.split("/").pop()}`);
+            }
+        }
+    }
+    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).
+    if (unberuehrt.length > 0) {
+        console.log(`Ich fasse nichts an -- du hast lokal geaendert: ${unberuehrt.join(", ")}`);
+        // 🔴 Der Rat haengt an der DATEI, nicht nur an der Rolle -- s.
+        // `ratNachUnberuehrt` (kontext-stand.ts), Review-Befund F-3.
+        for (const zeile of ratNachUnberuehrt(unberuehrt, daten.rolle, daten.adminName)) {
+            console.log(zeile);
+        }
+    }
+    if (geschrieben.length === 0 && unberuehrt.length === 0) {
+        const alleLeer = VERWALTETE_DATEIEN.every((p) => (daten.merkzettel.dateien[p]?.stand ?? LEER) === LEER);
+        if (alleLeer) {
+            console.log("Deine Firma hat noch nichts hinterlegt. Bis dahin bleiben die Vordrucke stehen.");
+        }
+        else {
+            console.log("Dein Firmenkontext ist aktuell.");
+        }
+    }
+    return 0;
+}
+/** Prueft die Antwort-Form, ohne `any` -- eine falsche Form ist unlesbar, keine Ausnahme. */
+function alsKontextAntwort(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    // 🔴 Task 10a: `firma.id` ist die Quelle, aus der `kontextRunter` gleich
+    // den lokalen Merkzettel stempelt -- s. Kommentar an der Schreibstelle.
+    const firmaRoh = k.firma;
+    if (!firmaRoh || typeof firmaRoh !== "object")
+        return null;
+    const firmaId = firmaRoh.id;
+    if (typeof firmaId !== "string" || firmaId.trim() === "")
+        return null;
+    const rolle = k.rolle;
+    if (rolle !== "admin" && rolle !== "member")
+        return null;
+    const adminName = k.admin_name;
+    if (adminName !== null && typeof adminName !== "string")
+        return null;
+    const dateienRoh = k.dateien;
+    if (!Array.isArray(dateienRoh))
+        return null;
+    const dateien = [];
+    for (const eintrag of dateienRoh) {
+        if (!eintrag || typeof eintrag !== "object")
+            return null;
+        const p = eintrag.pfad;
+        const i = eintrag.inhalt;
+        if (typeof p !== "string" || p.trim() === "")
+            return null;
+        if (typeof i !== "string")
+            return null;
+        dateien.push({ pfad: p, inhalt: i });
+    }
+    const merkzettel = alsMerkzettel(k.merkzettel);
+    if (merkzettel === null)
+        return null;
+    return { firma: { id: firmaId }, rolle, adminName, dateien, merkzettel };
+}

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;