kimal3 0.1.6 → 0.2.1

package/README.md

@@ -37,6 +37,9 @@ kimal3 login              Diesen Rechner mit deinem Konto verbinden
 kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen — und dir die /k3-Befehle geben
 kimal3 arbeitsplatz neu   Den ganzen KI-Arbeitsplatz anlegen — Firmenebene und Werkbank
 kimal3 werkbank neu       Nur eine eigene Werkbank in einer bestehenden Firma anlegen
+kimal3 kontext runter     Den Firmenkontext holen — CLAUDE.md und die fünf Dateien in kontext/
+kimal3 kontext fragen     Zeigen, welche Fragen über deine Firma noch unbeantwortet sind
+kimal3 kontext hoch       Deine lokalen Änderungen an den fünf Kontext-Dateien hochschicken
 kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
 kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
 kimal3 firma daten        Die Daten deiner Firma holen, damit Claude sie auswerten kann

package/dist/api.js

@@ -1,9 +1,97 @@
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
 import { hinweisAusAntwort } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
+import { findeArbeitsplatz, leseMerkzettelDatei } from "./kontext-dateien.js";
+import { bekannterStandAus, istKopfwertSicher } from "./kontext-stand.js";
 export class NichtAngemeldet extends Error {
     constructor() { super("nicht angemeldet"); }
 }
+/**
+ * Der EINE Weg, auf dem diese Datei den lokalen Merkzettel liest -- Firmen-ID
+ * und bekannter Stand, oder `null`, wenn sich beides nicht sicher bilden
+ * laesst (Task 10, Step 1).
+ *
+ * 🔑 Zwei Verbraucher, EINE Leseart (A-4): `kontextStandKopf()` baut daraus
+ * den Kopf `X-Kimal3-Kontext-Stand` VOR dem Netzaufruf,
+ * `lokalerKontextStandJetzt()` liefert denselben Stand am ENDE des Befehls an
+ * den Update-Hinweis. Eine zweite, eigene Leseart waere eine zweite Wahrheit
+ * ueber dieselbe Datei.
+ *
+ * ⚠️ WIRFT NIE -- dieselbe Regel wie beim Update-Kanal insgesamt: Ein
+ * Nebenschauplatz darf keinen Befehl umwerfen. `findeArbeitsplatz` und
+ * `leseMerkzettelDatei` werfen zwar selbst schon nicht (s. ihre eigenen
+ * Kommentare), das `try` ist trotzdem das Netz fuer den Fall, dass sich das
+ * einmal aendert.
+ *
+ * 🔴 **Fix-Runde 1, Fund 1:** `firma_id` und jeder `stand` kommen aus dem
+ * Merkzettel auf der Platte des Kunden -- einer Datei, die ausdruecklich zum
+ * Von-Hand-Aufmachen gedacht ist (s. Kopf-Kommentar an `pruefsumme` in
+ * `kontext-stand.ts`). `leseMerkzettel` prueft nur `typeof === "string"`, nie
+ * den INHALT. Ohne `istKopfwertSicher` wuerde ein einziges Nicht-ASCII-
+ * Zeichen darin `headers.set(...)` in `ruf()` unten zum Werfen bringen --
+ * und zwar bei JEDEM folgenden Befehl, nicht nur bei `kontext`-Befehlen. Der
+ * Kunde saehe "kimal3 ist gerade nicht erreichbar" und suchte im Netz, waehrend
+ * der Fehler auf seiner eigenen Platte sitzt.
+ *
+ * 🔑 **Warum stillschweigend `null`, keine Warnung:** Dieselbe Antwort wie
+ * bei den drei anderen Wirklichkeiten, die diese Funktion schon zu `null`
+ * zusammenfaltet (kein Arbeitsplatz, keine bekannte `firma_id` in allen drei
+ * Lesarten von Task 10a). Eine Warnung liefe bei JEDEM Befehl erneut, bis der
+ * Merkzettel neu geschrieben wird (naechstes `kontext runter`/`kontext hoch`
+ * heilt das automatisch) -- und ein Nebenschauplatz, der ploetzlich auf jedem
+ * Befehl eine unerwartete Zeile ausgibt, ist selbst ein Verstoss gegen die
+ * Regel, die ihn ueberhaupt rechtfertigt ("darf keinen Befehl umwerfen" ist
+ * eng verwandt mit "darf keinen Befehl verunstalten"). *Wie viele
+ * verschiedene Wirklichkeiten enden auf `null` -- und ist jede ein sicherer
+ * Ausgang?* Vier, und JEDE fuehrt zum selben, harmlosen Ergebnis: kein Kopf,
+ * kein Hinweis, der Befehl laeuft unveraendert weiter.
+ */
+function lokaleKontextLage() {
+    try {
+        const ordner = findeArbeitsplatz(process.cwd());
+        if (ordner === null)
+            return null;
+        const merkzettel = leseMerkzettelDatei(ordner);
+        if (merkzettel.firma_id === null)
+            return null;
+        return { firmaId: merkzettel.firma_id, stand: bekannterStandAus(merkzettel) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Welchen Firmenstand traegt der Merkzettel auf dieser Platte GERADE JETZT?
+ *
+ * 🔴 WOZU DAS GUT IST (offener Punkt A-4): Der Wert, den `kontextStandKopf()`
+ * unten in den Kopf schreibt, wird VOR dem `fetch` gelesen -- er ist der
+ * Stand, den die CLI hatte, als der Befehl begann. Genau daran hing der
+ * Fehler: Nach `kimal3 kontext runter` riet der Hinweis am Ende zu genau dem
+ * Befehl, der gerade gelaufen war. Diese Funktion ist deshalb kein zweiter
+ * Weg zum selben Wert, sondern derselbe Weg zu einem SPAETEREN Zeitpunkt --
+ * ausgelesen wird sie in `hinweisText()` (`kimal3.ts`), also nachdem der
+ * Befehl den Merkzettel neu geschrieben hat.
+ *
+ * ⚠️ SIE DARF NICHTS ZWISCHENSPEICHERN. Ein gemerkter Wert waere wieder der
+ * Stand von vorhin, und der ganze Fix waere umsonst -- deshalb liest sie bei
+ * jedem Aufruf erneut von der Platte. `check:nachrichten` misst genau das.
+ *
+ * `null` heisst "wir wissen den Stand nicht" (kein Arbeitsplatz, keine
+ * Firmen-ID im Merkzettel, Datei unlesbar) -- und "wir wissen es nicht" darf
+ * nie einen Hinweis unterdruecken (s. `hinweisErledigt` in `nachricht.ts`).
+ */
+export function lokalerKontextStandJetzt() {
+    return lokaleKontextLage()?.stand ?? null;
+}
+function kontextStandKopf() {
+    const lage = lokaleKontextLage();
+    if (lage === null)
+        return null;
+    const wert = `${lage.firmaId}:${lage.stand}`;
+    if (!istKopfwertSicher(wert))
+        return null;
+    return wert;
+}
 /**
  * Ein Aufruf gegen die App. `mitAusweis` haengt den Schluessel an.
  *
@@ -40,6 +128,30 @@ export async function ruf(pfad, optionen = {}) {
     const version = eigeneVersion();
     if (version !== null)
         kopf["X-Kimal3-Version"] = version;
+    /*
+      🔴 DER ZWEITE KOPF (Task 10) -- der lokal bekannte Firmenstand, damit der
+      Server einen firmenbezogenen Hinweis anhaengen kann ("deine Firma hat den
+      Kontext geaendert"). Der Server weiss nicht, was auf DIESER Platte liegt
+      -- deshalb schickt die CLI ihn mit, statt dass der Server raet.
+  
+      ⚠️ ASCII PFLICHT, aus demselben Grund wie der Versions-Kopf oben: die
+      Firmen-ID ist eine UUID, der Stand ein ISO-Zeitstempel oder `"leer"" --
+      beides ASCII. Der Firmenname geht NIE hier mit, nur die ID; den Namen
+      loest der Server fuer den Hinweistext selbst auf (Step 4, US-8).
+  
+      🔴 GAR KEIN KOPF, wenn sich kein Arbeitsplatz findet ODER der lokale
+      Merkzettel keine Firmen-ID kennt -- letzteres kollabiert bewusst DREI
+      Wirklichkeiten in einen Wert (altes Merkzettel-Format ohne das Feld,
+      kaputtes JSON, ausdruecklich `null`, s. `leseMerkzettel` in
+      `kontext-stand.ts`). Diese Funktion unterscheidet sie nicht: Alle drei
+      heissen "wir wissen die Firma nicht sicher", und "kein Kopf" ist in
+      JEDEM der drei Faelle die richtige, sichere Antwort -- kein Hinweis
+      bleibt der Vorgabewert, auch wenn er einen der drei Faelle zu Unrecht
+      (aber folgenlos) mit erwischt.
+    */
+    const kontextKopf = kontextStandKopf();
+    if (kontextKopf !== null)
+        kopf["X-Kimal3-Kontext-Stand"] = kontextKopf;
     const methode = optionen.methode ?? "POST";
     // Content-Type nur, wenn wirklich etwas im Rumpf steht. Ein GET mit
     // "Content-Type: application/json" und ohne Rumpf ist eine Luege ueber die

package/dist/arbeitsplatz-dateien.js

@@ -1,7 +1,36 @@
 import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { feld, ruf } from "./api.js";
-import { schlussFehler } from "./fehler.js";
+import { ruf } from "./api.js";
+/*
+  🔴 **Ja, hierher -- und nicht in eine zweite eigene Absage** (Punkt A-3,
+  2026-08-26). `absage` ist die Ausgabe, die `kimal3 kontext runter` und
+  `kimal3 kontext hoch` schon benutzen: Sie trennt 402 vor 401, schickt den
+  Rest an `schlussFehler` und nennt bei `409` die eigenen Firmen als **fertige
+  Befehle zum Kopieren**. Genau das braucht `arbeitsplatz neu` jetzt auch.
+
+  Der bequeme Weg waere gewesen, die vier Zweige hier abzutippen. Dann gaebe es
+  zwei Absage-Sprachen fuer dieselbe Frage („welche Firma meinst du?") -- und
+  der Kunde muesste zweimal dasselbe lernen. Der Preis ist ein Import aus
+  `befehle/` in ein Modul darueber.
+
+  🔴 **DIESER IMPORT SCHLIESST EINEN KREIS -- und der Kommentar behauptete hier
+  einen Nachmittag lang das Gegenteil** („er ist kreisfrei"). Nachgemessen
+  (Review-Befund 4, 2026-08-26): `arbeitsplatz-dateien` -> `befehle/
+  kontext-gemeinsam` -> `kontext-dateien` (holt `findeArbeitsplatz`) ->
+  `arbeitsplatz-dateien` (holt `istUnsicherenPfad`). Der Kreis ist da.
+
+  ⚠️ **Er ist heute harmlos, und nur deshalb:** In keinem der drei Module
+  laeuft beim LADEN etwas, das ein anderes braucht -- es werden ausschliesslich
+  Funktionen definiert und erst beim Aufruf benutzt. Wer hier oder in einem der
+  beiden anderen Module Arbeit auf die oberste Ebene legt (eine Konstante, die
+  eine importierte Funktion aufruft), bekommt `undefined` statt einer Funktion,
+  und zwar erst zur Laufzeit beim Kunden.
+
+  *Ein Kommentar, der Kreisfreiheit behauptet, laedt genau dazu ein* -- er
+  liest sich wie eine gepruefte Zusage. Deshalb steht der Kreis jetzt hier,
+  statt weg-behauptet zu werden.
+*/
+import { absage } from "./befehle/kontext-gemeinsam.js";
 /*
   🔁 Die Ableitung „welcher Unterordner ist die Werkbank" wohnt seit dem
   2026-08-20 in `werkbank-name.ts` -- gemeinsam mit der App, die sie fuer `/pro`
@@ -10,6 +39,34 @@ import { schlussFehler } from "./fehler.js";
   Kopien des Namens, nur besser getarnt.*
 */
 export { werkbankAusDateien as werkbankOrdner } from "./werkbank-name.js";
+/**
+ * Die Optionen, die `arbeitsplatz neu` und `werkbank neu` zur Firmenwahl
+ * annehmen -- **dieselbe Liste** wie bei `kontext runter`/`kontext hoch`,
+ * weitergereicht statt abgeschrieben.
+ *
+ * ⚠️ Zwei eigene Listen hätten dieselbe Frage („welche Firma meinst du?") bei
+ * vier Befehlen aus zwei Quellen beantwortet. Eine davon würde eines Tages
+ * `--firmen-id` heißen, und niemand merkte es beim Lesen.
+ */
+export { ERLAUBT as FIRMEN_OPTIONEN } from "./befehle/kontext-gemeinsam.js";
+/**
+ * Aus dem Wunsch die Suchparameter -- **rein**, damit `check:firmenwahl` sie
+ * ohne Netz messen kann.
+ *
+ * 🔑 `URLSearchParams` und keine selbstgebaute Zeichenkette: Ein Firmenname
+ * darf `&`, `=`, `?` und Leerzeichen enthalten (`Blume & Co`), und von Hand
+ * zusammengesetzt zerbräche daran die Anfrage -- ohne Fehlermeldung, mit einer
+ * Antwort für die falsche Firma.
+ */
+export function firmenSuche(wunsch) {
+    const suche = new URLSearchParams();
+    if (wunsch.firma !== undefined)
+        suche.set("firma", wunsch.firma);
+    if (wunsch.firmaId !== undefined)
+        suche.set("firma-id", wunsch.firmaId);
+    const text = suche.toString();
+    return text === "" ? "" : `?${text}`;
+}
 /**
  * Holt die Vorlage von der App — **eine** Route für beide Befehle.
  *
@@ -17,9 +74,20 @@ export { werkbankAusDateien as werkbankOrdner } from "./werkbank-name.js";
  * Dateien, dieselbe Pro-Prüfung, derselbe Ausweis. Eine zweite Route wäre eine
  * zweite Tür, die man einzeln absichern und einzeln nachmessen müsste — für
  * exakt denselben Inhalt. Der Ausschnitt entsteht hier auf dem Rechner.
+ *
+ * 🔴 **Beide Parameter sind PFLICHT** (Punkt A-3, 2026-08-26). `wunsch` könnte
+ * bequem entfallen, wenn niemand eine Firma nennt -- und genau so bleibt eine
+ * gebaute Rechnung an der Aufrufstelle tot, ohne dass ein Compiler oder ein
+ * Wächter etwas merkt (dieselbe Falle wie bei `lageFuerDatei`, Punkt A-1).
+ * `befehl` nennt den Befehl, den die 409-Absage zum Kopieren anbietet -- stünde
+ * dort fest `kontext runter`, bekäme ein Mensch bei `werkbank neu` einen Rat,
+ * der seine Werkbank nicht anlegt.
  */
-export async function vorlageHolen() {
-    const antwort = await ruf("/api/cli/arbeitsplatz", { methode: "GET", mitAusweis: true });
+export async function vorlageHolen(befehl, wunsch) {
+    const antwort = await ruf(`/api/cli/arbeitsplatz${firmenSuche(wunsch)}`, {
+        methode: "GET",
+        mitAusweis: true,
+    });
     if (antwort.status === 200) {
         const daten = alsVorlageAntwort(antwort.koerper);
         if (daten === null) {
@@ -28,24 +96,18 @@ export async function vorlageHolen() {
         }
         return { ok: true, daten };
     }
-    const meldung = feld(antwort.koerper, "meldung") ?? "Das hat nicht geklappt.";
-    // 402 VOR 401: Beide heissen "kommst hier nicht rein", verlangen aber
-    // Gegenteiliges. Wer sie zusammenwirft, raet `kimal3 login` -- und der
-    // meldet sich dann erfolgreich an, ohne dass es etwas aendert.
-    if (antwort.status === 402) {
-        console.error(meldung);
-        return { ok: false, wert: 4 };
-    }
-    if (antwort.status === 401) {
-        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
-        return { ok: false, wert: 2 };
-    }
-    // 🔑 Den Rest entscheidet `schlussFehler` fuer alle Befehle gemeinsam --
-    // insbesondere die `404` (die App kennt die Route noch nicht) und `429`/
-    // `408` (ueberlastet, wiederholbar).
-    const schluss = schlussFehler(antwort.status, meldung);
-    console.error(schluss.text);
-    return { ok: false, wert: schluss.wert };
+    /*
+      🔴 **Hier standen dieselben vier Zweige noch einmal abgetippt** (402 vor
+      401, Rest an `schlussFehler`) -- Zeichen für Zeichen das, was `absage`
+      ohnehin tut, nur ohne den `409`-Zweig. Dadurch fehlte genau die Auskunft,
+      um die es bei Punkt A-3 geht: welche Firma gemeint ist.
+  
+      ⚠️ **Und das Weglassen war unsichtbar**, denn `409` kam von dieser Route
+      bis zum 2026-08-26 gar nicht -- sie hat die Frage still selbst entschieden.
+      *Ein Zweig, den es nie zu sehen gab, fehlt niemandem, bis der Server
+      anfängt zu fragen.*
+    */
+    return { ok: false, wert: absage(antwort, befehl) };
 }
 /** Prueft die Antwort-Form, ohne `any` -- eine falsche Form ist unlesbar, keine Ausnahme. */
 function alsVorlageAntwort(koerper) {

package/dist/argumente.js

@@ -6,6 +6,156 @@
  * Uebergehen. Wer `--titl` tippt, soll es erfahren, statt ein Projekt ohne
  * Titel anzulegen.
  */
+/**
+ * Trennt die **vorderen Woerter** von den Optionen.
+ *
+ * 🔴 **Warum es das seit dem 2026-08-26 gibt** (Punkt A-3): `arbeitsplatz neu`
+ * und `werkbank neu` haben ein Wort ohne `--` -- den Vornamen
+ * (`kimal3 arbeitsplatz neu sabine`). `zerlege` lehnt genau das ab, und zwar
+ * absichtlich (s. B-4 oben). Beide Befehle brauchen jetzt zusaetzlich
+ * `--firma`/`--firma-id`, also braucht es einen Schnitt VOR `zerlege`, statt
+ * dessen Strenge aufzuweichen.
+ *
+ * Geschnitten wird beim **ersten** Wort, das mit `--` beginnt. Alles davor
+ * sind Woerter, alles ab dort geht unveraendert an `zerlege` -- samt seiner
+ * Strenge: Ein Wort ohne `--` HINTER einer Option bleibt ein Fehler
+ * (`kimal3 arbeitsplatz neu --firma A muell`).
+ *
+ * ⚠️ **Nur `--`, nicht `-`.** Ein einzelnes `-x` bleibt ein Wort und laeuft in
+ * die Namenspruefung des Befehls. Das ist die heutige Bedeutung: `-h` faengt
+ * jeder Befehl selbst ab, bevor er hier ankommt, und ein `-force` soll die
+ * Meldung „damit kann ich hier nichts anfangen" bekommen und keine
+ * Options-Meldung ueber etwas, das gar keine Option ist.
+ */
+export function trenneNamenUndOptionen(argv) {
+    const erste = argv.findIndex((teil) => teil.startsWith("--"));
+    if (erste === -1)
+        return { woerter: argv, optionen: [] };
+    return { woerter: argv.slice(0, erste), optionen: argv.slice(erste) };
+}
+/**
+ * Die getippten Optionen wieder zu einer Zeile machen, die man kopieren kann.
+ *
+ * 🔴 **Gegen Review-Befund 3 zu A-3 (2026-08-26).** Der Vorschlag bei einem
+ * mehrteiligen Namen entsteht, BEVOR die Optionen zerlegt sind -- er kannte
+ * also nur die Woerter. Aus `arbeitsplatz neu sabine mueller --firma "Blume &
+ * Co"` wurde der Rat `kimal3 arbeitsplatz neu sabine-mueller`, **ohne die
+ * Firma**. Wer ihn kopierte, lief demselben `409` ein zweites Mal in die Arme.
+ *
+ * 🔑 Das ist die Kehrseite der Sache, die derselbe Commit eine Bildschirmhoehe
+ * tiefer ausdruecklich richtig macht („der getippte Vorname reist in der Absage
+ * mit"). *Ein Rat, der die Haelfte der Eingabe vergisst, ist ein Rat in eine
+ * zweite Absage.*
+ *
+ * ⚠️ **Anfuehrungszeichen, wo sie noetig sind.** Ein Firmenname mit Leerzeichen
+ * („Blume & Co") ergaebe ohne sie eine Zeile, die beim Einfuegen in etwas ganz
+ * anderes zerfaellt. Geprueft wird auf Leerzeichen und auf das leere Wort --
+ * beides kommt aus einem echten Firmennamen, nicht aus einem Sonderfall.
+ */
+export function alsBefehlszeile(optionen) {
+    /*
+      🔴 **`(teil) => alsWort(teil)` und NICHT `map(alsWort)`** -- gefunden vom
+      eigenen Waechter, Minuten nach dem Einbauen (2026-08-27). `Array.map`
+      reicht jedem Aufruf DREI Werte: Element, Listenplatz, ganze Liste. Der
+      Listenplatz landete damit auf dem zweiten Parameter `immer` -- und weil
+      jeder Platz ausser dem ersten wahr ist, bekam ab dem zweiten Wort jedes
+      seine Anfuehrungszeichen: `--firma "Nordwind"` statt `--firma Nordwind`.
+      *Ein Parameter mit Vorgabewert ist eine offene Tuer fuer jeden, der
+      ungefragt ein zweites Argument mitschickt.*
+    */
+    return optionen.map((teil) => alsWort(teil)).join(" ");
+}
+/**
+ * EIN Wort so in eine Befehlszeile setzen, dass es beim Kopieren wieder genau
+ * dieses Wort ergibt.
+ *
+ * 🔴 **Gegen Befund 4 der zweiten Review-Runde (2026-08-27).** An NEUN Stellen
+ * stand dieselbe Zeile — `wert.includes(" ") ? `"${wert}"` : wert` — und alle
+ * neun hatten dieselbe Lücke: Ein Wert, der selbst ein Anführungszeichen
+ * enthält, sprengt die Anführungszeichen, die man um ihn herum setzt.
+ *
+ * Der Fall: `kimal3 arbeitsplatz neu sabine --firma 'Blume "Nord" GmbH'`. Der
+ * angebotene Rat lautete danach `--firma "Blume "Nord" GmbH"`. Wer ihn
+ * kopiert, gibt seiner Kommandozeile **drei** Wörter statt einem und bekommt
+ * eine andere, verwirrendere Absage als die, die er gerade gelesen hat.
+ * *Ein Rat, der beim Kopieren zerfällt, ist ein Rat in eine zweite Absage* —
+ * genau die Lehre, gegen die `alsBefehlszeile` oben gebaut wurde.
+ *
+ * 🔑 **Warum einfache Anführungszeichen und keine Maskierung mit `\`:**
+ * `'…'` bedeutet in beiden Kommandozeilen dasselbe, die auf den Rechnern
+ * unserer Kunden laufen — in der von Mac/Linux (`sh`) wie in der von Windows
+ * (PowerShell). Eine Maskierung mit `\"` gilt nur in der ersten; in
+ * PowerShell müsste man das Zeichen verdoppeln. *Eine Bauform, die nur auf
+ * einem der beiden Rechner hält, ist in einem Produkt für beide keine
+ * Bauform.*
+ *
+ * 🔑 **`immer` heisst „setz die Anfuehrungszeichen auch dann, wenn es ohne
+ * ginge".** Die Zeilen unter „Deine Firmen:" haben sie seit jeher, und dort
+ * gehoeren sie hin: Sie sind zum Kopieren UND zum Weitertippen gedacht -- wer
+ * „Suedwind" durch „Blume & Co" ersetzt, hat die Anfuehrungszeichen dann schon
+ * stehen. Beim Zusammenbauen einer getippten Zeile (`alsBefehlszeile`) und
+ * beim `cd` waere das umgekehrt eine Aenderung an dem, was der Kunde bisher
+ * sieht -- deshalb dort die Vorgabe `false`.
+ *
+ * ⚠️ **Die eine Lage, die offen bleibt:** ein Wert mit BEIDEN Sorten
+ * Anführungszeichen. Dafür gibt es keine Schreibweise, die in beiden
+ * Kommandozeilen dasselbe heißt. Der Rückfall maskiert nach `sh`-Regeln — und
+ * für genau diesen Fall gibt es ohnehin `--firma-id`, das ohne jedes
+ * Sonderzeichen auskommt.
+ */
+export function alsWort(wert, immer = false) {
+    if (wert === "")
+        return '""';
+    /*
+      Was eine Kommandozeile nicht wörtlich stehen lässt: Leerzeichen (trennen),
+      Anführungszeichen beider Sorten (zitieren) -- und `$` wie ````
+      (rechnen).
+  
+      ⚠️ Der Rückwärtsstrich ist bewusst NICHT dabei: In einem Firmennamen
+      kommt er nicht vor, und ihn mitzunehmen hieße, ihn auch maskieren zu
+      müssen -- was in PowerShell wieder falsch wäre.
+    */
+    /*
+      🔴 **EINE ERLAUBNISLISTE, KEINE VERBOTSLISTE** (Befund 1 der FÜNFTEN
+      Review-Runde, 2026-08-27) -- und die Verbotsliste hatte drei Runden
+      gebraucht, um dreimal zu lecken: erst fehlten die Anführungszeichen, dann
+      `$` und das Akzent-Zeichen, dann `&`, `;`, `|`, Klammern, `<`, `>`.
+  
+      Der Fall, der es aufgedeckt hat: eine Firma namens `Blume&Co` -- **ohne**
+      Leerzeichen, also fiel sie durch jede Prüfung. Die angebotene Zeile hieß
+      `--firma Blume&Co`; in PowerShell ist das ein Syntaxfehler, in `sh`
+      startet es `--firma Blume` im Hintergrund und führt danach `Co` aus.
+  
+      🔑 *Eine Liste dessen, was gefährlich ist, ist immer unvollständig -- die
+      Liste dessen, was harmlos ist, kann man zu Ende schreiben.* Also
+      umgekehrt: Buchstaben (auch Umlaute), Ziffern und eine Handvoll
+      unverfänglicher Satzzeichen bleiben unangetastet, **alles andere wird
+      zitiert**. Ein Anführungszeichen zu viel ist folgenlos; eines zu wenig
+      hat jetzt dreimal einen Rat zerlegt.
+    */
+    if (!immer && /^[A-Za-z0-9À-ÿ._\/@:+-]+$/.test(wert))
+        return wert;
+    /*
+      🔴 **`$` UND ```` MÜSSEN AUS DEN DOPPELTEN ANFÜHRUNGSZEICHEN HERAUS**
+      (Befund 4 der dritten Review-Runde, 2026-08-27). Doppelte Anführungszeichen
+      halten Leerzeichen zusammen, aber sie schützen NICHT vor dem Rechnen: Eine
+      Firma namens `Cash$$ GmbH` ergab die Zeile
+      `--firma "Cash$$ GmbH"`, und `$$` ist in `sh` die Nummer des laufenden
+      Programms. Der Kunde kopiert den angebotenen Befehl und liest danach
+      *„Zu ‚Cash1234 GmbH' gehörst du nicht."* -- wieder ein Rat, der beim
+      Kopieren zerfällt, nur eine Stufe subtiler als der Fall, gegen den diese
+      Funktion gebaut wurde.
+  
+      Deshalb: doppelte Anführungszeichen nur, wenn wirklich nichts Rechnendes
+      drinsteht. Sonst die einfachen, die in beiden Kommandozeilen alles wörtlich
+      nehmen.
+    */
+    if (!/["$\`]/.test(wert))
+        return `"${wert}"`;
+    if (!wert.includes("'"))
+        return `'${wert}'`;
+    return `"${wert.replace(/(["$\`])/g, "\\$1")}"`;
+}
 export function zerlege(argv, erlaubt) {
     const optionen = {};
     for (let i = 0; i < argv.length; i++) {

package/dist/befehle/arbeitsplatz.js

@@ -1,5 +1,8 @@
 import { resolve } from "node:path";
-import { dateienSchreiben, vorlageHolen, werkbankOrdner, istUnsichererOrdnername, } from "../arbeitsplatz-dateien.js";
+import { FIRMEN_OPTIONEN, dateienSchreiben, vorlageHolen, werkbankOrdner, istUnsichererOrdnername, } from "../arbeitsplatz-dateien.js";
+import { alsBefehlszeile, alsWort, trenneNamenUndOptionen, zerlege } from "../argumente.js";
+import { fragenAus, traegtFragenVon } from "../fragen-lesen.js";
+import { FIRMEN_TEXTE } from "../kontext-stand.js";
 import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
 /**
  * Holt die KI-Arbeitsplatz-Vorlage vom Server und legt sie lokal an --
@@ -23,7 +26,7 @@ import { werkbankOrdnerAus, werkbankUmbenennen } from "../werkbank-name.js";
  * `../arbeitsplatz-dateien.ts`, weil `werkbank neu` dieselbe braucht.
  */
 const HILFE = `
-  kimal3 arbeitsplatz neu [dein-vorname]
+  kimal3 arbeitsplatz neu [dein-vorname] [--firma "Name" | --firma-id "…"]
 
   Holt deine KI-Arbeitsplatz-Vorlage und legt sie hier als Ordner an --
   die ganze Familie: Firmenebene, Werkbank, Beispielprojekt.
@@ -35,6 +38,13 @@ 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 -- der
+                   Firmenkontext kommt gleich mit in den Ordner.
+                   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 --
      eigene Arbeit wird dadurch nie versehentlich ueberschrieben.
 
@@ -76,12 +86,33 @@ const HILFE = `
  * Runde 3 zu PR #24 auf `/pro` gefunden hat.
  */
 function hinweisFuer(ordnerName) {
-    const ziel = ordnerName.includes(" ") ? `"${ordnerName}"` : ordnerName;
+    const ziel = alsWort(ordnerName);
     return ("  Steht dein Arbeitsplatz schon und dir fehlt nur die eigene Werkbank?\n" +
         "  Dann geh HINEIN und leg sie dort an:\n" +
         `    cd ${ziel}\n` +
         "    kimal3 werkbank neu <dein-vorname>");
 }
+export function fragenstandAus(dateien) {
+    let offen = 0;
+    let gesamt = 0;
+    for (const text of FIRMEN_TEXTE) {
+        const geliefert = dateien.find((d) => d.pfad === text.pfad);
+        if (geliefert === undefined)
+            return { art: "unbekannt" };
+        if (!traegtFragenVon(geliefert.inhalt, text.ankerPraefix))
+            return { art: "unbekannt" };
+        // ⚠️ `fragenAus` nimmt genau EIN Argument -- trotzdem steht hier die
+        // ausgeschriebene Form. `filter`/`map` reichen der Funktion drei Werte, und
+        // ein zweiter Parameter bekaeme spaeter stillschweigend den Listenplatz
+        // (`alsWort`, 2026-08-27).
+        const fragen = fragenAus(geliefert.inhalt);
+        gesamt += fragen.length;
+        offen += fragen.filter((f) => f.antwort === "").length;
+    }
+    // 🔑 Null Fragen in fuenf Dateien, die ihre Anker alle tragen, gibt es nicht
+    // -- und selbst dann waere „nichts offen" die ehrliche Antwort.
+    return offen === 0 ? { art: "keine" } : { art: "offen", offen, gesamt };
+}
 export async function arbeitsplatzNeu(argv) {
     if (argv.includes("--help") || argv.includes("-h")) {
         console.log(HILFE);
@@ -97,37 +128,64 @@ export async function arbeitsplatzNeu(argv) {
       `werkbank-arno-ki`. Diese Meldungen und die Hilfe sind die einzigen Stellen,
       an denen er das erfaehrt, bevor es passiert.
     */
-    const nameArg = argv[0];
+    /*
+      🔴 **Erst schneiden, dann zerlegen** (Punkt A-3, 2026-08-26). Dieser Befehl
+      hat ein Wort OHNE `--` (den Vornamen), und `zerlege` lehnt genau das ab.
+      Deshalb trennt `trenneNamenUndOptionen` beim ersten `--`: davor die
+      Woerter, ab dort die Optionen. Die Strenge von `zerlege` bleibt damit
+      unangetastet -- sie war teuer erkauft (B-3 und B-4, 2026-08-18).
+    */
+    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 `arbeitsplatz neu sabine --force`
-          wurde damit der Rat `arbeitsplatz neu sabine---force`. Die `--`-Wache ein paar
-          Zeilen hoeher sieht nur `argv[0]`.
+          wurde damit der Rat `arbeitsplatz 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 und das der
+          Vorschlag genauso wenig einsammeln darf.
+        */
+        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 woerter = argv.filter((w) => !w.startsWith("-"));
-        const vorschlag = woerter.length === argv.length && woerter.length > 1
+        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 arbeitsplatz neu ${woerter.join("-")}\n`
+                `  kimal3 arbeitsplatz 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 JETZT die Optionen -- nach den Namens-Absagen, damit ein Mensch mit
+      zwei Vornamen die Schreibhilfe bekommt und nicht eine Options-Meldung.
+    */
+    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"],
+    };
     /*
       Der Name wird UMGESCHRIEBEN, nicht abgelehnt (s. `werkbankOrdnerAus`) --
       "Sabine Mueller" ist ein gueltiger Name, nur kein gueltiger Ordner. `null`
@@ -146,7 +204,24 @@ export async function arbeitsplatzNeu(argv) {
             return 1;
         }
     }
-    const holen = await vorlageHolen();
+    /*
+      🔴 **HIER ENTSCHEIDET SICH, OB UEBERHAUPT ETWAS ENTSTEHT** (Punkt A-3).
+      Gehoert der Mensch zu mehreren Firmen und hat keine genannt, antwortet die
+      Route `409`, `vorlageHolen` gibt `1` zurueck -- und `dateienSchreiben`
+      weiter unten wird nie erreicht. Es wird also **kein halber Ordner**
+      angelegt, den er danach von Hand wegraeumen muesste.
+    */
+    /*
+      🔑 **Der getippte Vorname reist in der Absage mit.** Wer
+      `kimal3 arbeitsplatz neu sabine` tippt und die Rueckfrage bekommt, soll die
+      fertige Zeile kopieren koennen, ohne seinen Namen ein zweites Mal
+      hineinzuschreiben -- sonst hiesse seine Werkbank nach dem zweiten Versuch
+      anders als beim ersten gewollt, und niemand saehe, woran es lag.
+    */
+    const befehlsname = nameArg === undefined
+        ? "arbeitsplatz neu"
+        : `arbeitsplatz neu ${alsWort(nameArg)}`;
+    const holen = await vorlageHolen(befehlsname, wunsch);
     if (!holen.ok)
         return holen.wert;
     const daten = holen.daten;
@@ -253,8 +328,55 @@ export async function arbeitsplatzNeu(argv) {
     // zuverlaessig ins Leere.*
     const werkbank = werkbankOrdner(dateien);
     const cdZiel = werkbank !== null ? `${ordnerName}/${werkbank}` : ordnerName;
-    console.log(`    cd ${cdZiel.includes(" ") ? `"${cdZiel}"` : cdZiel}`);
+    console.log(`    cd ${alsWort(cdZiel)}`);
     console.log("    claude");
     console.log('    dann "Lass uns einrichten" tippen');
+    /*
+      🔴 **HIER RISS DIE KETTE.**
+      Bis zum 2026-08-28 endete dieser Befehl immer mit denselben drei Zeilen: Der
+      Mensch hat einen Ordner, ein Einrichtungsgespraech -- und einen Stapel
+      unbeantworteter Fragen ueber seine Firma, von denen ihm niemand erzaehlt.
+      *Er hat den Ordner und das Gefuehl, fertig zu sein.*
+  
+      ⚠️ Hier stand kurz „siebzehn Fragen", abgeschrieben aus der Spec. Gemessen
+      am 2026-08-28 sind es **sechzehn** (4 + 3 + 4 + 2 + 3 Anker in den fuenf
+      Vorlagen). Deshalb steht die Zahl unten NICHT im Text, sondern kommt aus
+      derselben Zaehlung, die auch `kimal3 kontext fragen` ausgibt.
+      *Eine Zahl im Fliesstext ist eine zweite Wahrheit, die still verrottet.*
+  
+      🔑 **Der Rat haengt an der Lage, nicht am Befehl.** Nur wenn wirklich Fragen
+      offen sind, steht `/k3kontext` da. Bei einer Firma, die ihre fuenf Texte
+      schon gepflegt hat, bleibt die Ausgabe Zeichen fuer Zeichen die von vorher.
+      *Ein Rat, der immer erscheint, ist keine Auskunft, sondern Deko* -- so
+      ausdruecklich in US-1 der Spec
+      (`docs/superpowers/specs/2026-08-28-k3-befehle-design.md`).
+  
+      ⚠️ **Er sagt NICHT „und schick es hoch".** Ob dieser Mensch Admin seiner
+      Firma ist, steht in dieser Antwort nicht drin -- `/api/cli/arbeitsplatz`
+      liefert `wurzel` und `dateien`, sonst nichts. Die Schwesterroute
+      `/api/cli/kontext` traegt eine `rolle`, diese nicht. Also raet die Ausgabe
+      zu dem Schritt, den JEDER gehen kann: die Fragen beantworten.
+  
+      🔴 **Was danach passiert, deutet `/k3kontext` an der MELDUNG von
+      `kimal3 kontext hoch` -- nicht an der Zahl.** Hier stand bis zur zweiten
+      Review-Runde „der deutet Rueckgabewert 1 als ‚du bist kein Admin'", und
+      genau diese Gleichung hat dieselbe Scheibe an zwei anderen Stellen als
+      falsch geloescht: `kontext hoch` gibt `1` auch dann zurueck, wenn die Firma
+      erfolgreich gespeichert hat und nur der lokale Merkzettel scheiterte
+      (`kontext-hoch.ts`, Merkzettel-Zweig). *Ein Kommentar, der ein Verhalten erklaert, wird
+      beim naechsten Lesen abgenickt -- dieser haette den Fehler zurueckgeholt,
+      den der Commit daneben entfernt.*
+  
+      ⚠️ Der Ordner ist zu diesem Zeitpunkt geschrieben; ein Zaehlfehler darf
+      daran nichts mehr aendern. Deshalb steht das hier ganz unten und kann nur
+      noch schweigen, nie abbrechen.
+    */
+    const stand = fragenstandAus(dateien);
+    if (stand.art === "offen") {
+        console.log("");
+        console.log(`  Danach: ${stand.offen} von ${stand.gesamt} Fragen über deine Firma sind noch offen.`);
+        console.log("  Claude stellt sie dir einzeln und trägt deine Antworten ein:");
+        console.log("    /k3kontext");
+    }
     return 0;
 }