kimal3 0.1.6 → 0.2.0

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,62 @@
 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 Wert fuer den Kopf `X-Kimal3-Kontext-Stand` -- `<firmen-id>:<stand>`
+ * aus dem lokalen Merkzettel, oder `null`, wenn er sich nicht bilden laesst
+ * (Task 10, Step 1).
+ *
+ * ⚠️ 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 kontextStandKopf() {
+    try {
+        const ordner = findeArbeitsplatz(process.cwd());
+        if (ordner === null)
+            return null;
+        const merkzettel = leseMerkzettelDatei(ordner);
+        if (merkzettel.firma_id === null)
+            return null;
+        const wert = `${merkzettel.firma_id}:${bekannterStandAus(merkzettel)}`;
+        if (!istKopfwertSicher(wert))
+            return null;
+        return wert;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Ein Aufruf gegen die App. `mitAusweis` haengt den Schluessel an.
  *
@@ -40,6 +93,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/befehle/kontext-fragen.js

@@ -0,0 +1,165 @@
+import { FIRMEN_TEXTE } from "../kontext-stand.js";
+import { fragenAus, traegtFragenVon } from "../fragen-lesen.js";
+import { leseEineDatei } from "../kontext-dateien.js";
+import { arbeitsplatzOderAbsage, fremdeDateiAbsage } from "./kontext-gemeinsam.js";
+/**
+ * `kimal3 kontext fragen` -- zeigt, welche Fragen ueber die Firma noch offen
+ * sind.
+ *
+ * 🔴 **DIESER BEFEHL FUEHRT KEIN GESPRAECH.** Er gibt Daten aus: Datei, Anker,
+ * Frage, Hinweis. Das Gespraech fuehrt Claude, angeleitet vom Skill. *Ein
+ * Werkzeug, das selbst ein Gespraech fuehren will, baut eine zweite,
+ * schlechtere Fassung von dem, wofuer der Kunde Claude ohnehin schon hat.*
+ *
+ * 🔑 **Er braucht kein Netz und keine Anmeldung.** Alles, was er wissen muss,
+ * steht in den fuenf Dateien auf der Platte -- die Fragen samt Ankern und
+ * Hinweisen sind Teil des ausgelieferten Textes. Deshalb laeuft er auch dann,
+ * wenn der Ausweis abgelaufen ist, und deshalb kann er nichts kaputt machen:
+ * **er liest, er schreibt nirgends.**
+ *
+ * ⚠️ **Die Reihenfolge ist die von `FIRMEN_TEXTE`** -- dieselbe wie die der
+ * Felder im Formular auf `/firma/kontext`. Wer beides nebeneinander hat, findet
+ * dieselbe Frage an derselben Stelle.
+ */
+/*
+  🔴 **ECHTE UMLAUTE, auch hier** (Review-Befund J2). Diese Zeilen liest ein
+  Kunde im Terminal -- die ASCII-Umschrift dieses Ordners gilt ausschliesslich
+  fuer Kommentare. Hier stand eine Fassung in Umschrift, waehrend die
+  Erfolgsausgabe derselben Datei Umlaute setzte: *eine Datei, zwei Schreibweisen,
+  und der Unterschied war nicht zu begruenden.*
+*/
+const HILFE = `
+  kimal3 kontext fragen
+
+  Zeigt, welche Fragen über deine Firma in kontext/ noch unbeantwortet sind —
+  mit Datei, Anker, Frage und Hinweis.
+
+  Der Befehl liest nur. Er braucht weder Netz noch Anmeldung und ändert nichts.
+
+  Antworten trägst du in die genannte Datei unter ihre Frage ein; danach
+  schickt "kimal3 kontext hoch" sie an die Firma (nur als Admin).
+`;
+/** `[optional]` hinter einer Frage, die keine Pflicht ist -- sonst nichts. */
+function zusatz(frage) {
+    return frage.pflicht ? "" : "  [optional]";
+}
+/*
+  ⚠️ **Bewusst NICHT `async`, anders als die Nachbarn `kontextRunter` und
+  `kontextHoch`.** Die beiden warten auf den Server; dieser Befehl nicht. Ein
+  `async` ohne `await` waere ein Versprechen auf Arbeit, die nicht stattfindet
+  -- und beim Lesen die falsche Erwartung, dass hier etwas ueber das Netz geht.
+  Der Verteiler in `kimal3.ts` ist selbst `async` und nimmt beides.
+*/
+export function kontextFragen(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    /*
+      ⚠️ **Der Befehl nimmt GAR KEIN Argument -- auch kein `--firma`.** Er fragt
+      den Server nicht, also gibt es keine Firma zu waehlen; und er liest fest die
+      fuenf Dateien neben sich, also auch keinen Dateinamen.
+  
+      🔴 Geprueft wird auf JEDES Argument, nicht nur auf solche mit `-` davor. Ein
+      stillschweigend geschlucktes `--firma "Nordwind"` waere schlimmer als eine
+      Absage -- der Mensch glaubte dann, er habe eine Firma ausgewaehlt -- und ein
+      verschlucktes `marke` genauso: Er saehe alle 17 Fragen und hielte sie fuer
+      die einer Datei.
+    */
+    if (argv.length > 0) {
+        console.error(`„${argv[0]}" kenne ich hier nicht — dieser Befehl nimmt keine Angaben.`);
+        console.error("  Er liest die fünf Dateien in kontext/ neben dir und gibt aus, was offen ist.");
+        return 1;
+    }
+    const ordner = arbeitsplatzOderAbsage();
+    if (ordner === null)
+        return 1;
+    /*
+      🔴 **EINE FEHLENDE DATEI IST EIN ABBRUCH, KEINE LUECKE IN DER LISTE.**
+      Wer aus vier von fuenf Dateien eine Liste offener Fragen baut und sie als
+      die Antwort hinlegt, sagt einem Menschen, er sei fertig, waehrend drei
+      Fragen nirgends stehen. Dieselbe Regel wie bei `kontext hoch`: lieber ein
+      Abbruch, der sagt warum, als ein halber Stand, den niemand benennen kann.
+    */
+    const gelesen = [];
+    for (const datei of FIRMEN_TEXTE) {
+        const antwort = leseEineDatei(ordner, datei.pfad);
+        if (!antwort.ok) {
+            console.error(antwort.meldung);
+            return 1;
+        }
+        if (antwort.inhalt === null) {
+            console.error(`„${datei.pfad}" gibt es hier nicht — dann fehlen mir ihre Fragen.`);
+            console.error("  `kimal3 kontext runter` holt die Datei; danach noch einmal.");
+            return 1;
+        }
+        /*
+          🔴 **EINE DATEI OHNE IHRE FRAGEN IST DERSELBE FALL WIE EINE FEHLENDE**
+          (Review-Befund J1). Ohne diese Zeilen lieferte `fragenAus` eine leere
+          Liste, und die Datei fiel aus BEIDEN Summen -- gemessen mit der
+          ausgelieferten `README.md` als `kontext/marke.md`: „12 von 12 Fragen",
+          „Die Marke" nirgends genannt. Nach zwoelf Antworten haette der Befehl
+          `✓ Alle 12 Fragen … sind beantwortet` gemeldet, und `kontext hoch` waere
+          einen Schritt spaeter -- im Ablauf, den unser eigener Skill vorgibt --
+          auf genau dieser Datei mit Rueckgabewert 1 abgebrochen.
+    
+          🔑 Woertlich dieselbe Beschreibung des Ordners wie dort
+          (`fremdeDateiAbsage`): Zwei Befehle, die dieselbe Lage verschieden
+          benennen, sind zwei Wahrheiten.
+        */
+        if (!traegtFragenVon(antwort.inhalt, datei.ankerPraefix)) {
+            fremdeDateiAbsage(datei.pfad, datei.titel, datei.ankerPraefix, "Ich kann ihre Fragen deshalb nicht zählen — und zähle dann gar nicht.");
+            return 1;
+        }
+        gelesen.push({ pfad: datei.pfad, titel: datei.titel, fragen: fragenAus(antwort.inhalt) });
+    }
+    const gesamt = gelesen.reduce((summe, d) => summe + d.fragen.length, 0);
+    const offen = gelesen.reduce((summe, d) => summe + d.fragen.filter((f) => f.antwort === "").length, 0);
+    /*
+      🔑 **Alles beantwortet -> EIN Satz, keine Liste** (Auftrag, Step 1). Eine
+      leere Liste mit Ueberschriften sieht aus wie ein Fehler; ein Satz ist eine
+      Antwort.
+  
+      ⚠️ Er sagt „in deinen Kontext-Dateien" und nicht „alle Fragen deiner
+      Firma". Gemessen wurde, was in diesen fuenf Dateien steht -- wer einen
+      Anker geloescht hat, hat eine Frage, die hier nicht auftaucht (s.
+      `fragen-lesen.ts`). *Ein Satz darf nur behaupten, was seine Messung
+      deckt.*
+    */
+    if (offen === 0) {
+        console.log(`✓ Alle ${gesamt} Fragen, die in deinen Dateien stehen, sind beantwortet.`);
+        /*
+          🔴 **DIE ZWEITE ZEILE BENENNT DIE LUECKE, STATT SIE ZU VERSTECKEN**
+          (Review-Befund J5). Gezaehlt wird, was in den fuenf Dateien steht. Wer den
+          Ankerkommentar EINER Frage loescht und sie unbeantwortet laesst, hat sie
+          hier nicht mehr -- `fragenAus` erkennt eine Frage am Anker (Ruling K-14),
+          die App zusaetzlich am Wortlaut. Dann stuende hier `Alle 16 …`, waehrend
+          die App weiter „16 von 17" fuehrt.
+    
+          🔑 Der Ausweg gehoert in dieselbe Ausgabe wie die Zahl. *Eine Zahl, deren
+          Grenze man kennt, gehoert nicht ohne ihre Grenze hingeschrieben* -- sonst
+          liest ein Mensch „fertig" und die App widerspricht ihm morgen.
+        */
+        console.log("  Gezählt ist, was in kontext/ steht. Nennt die App unter Firma → Kontext");
+        console.log("  eine höhere Zahl, fehlt in einer Datei eine Frage — `kimal3 kontext runter`");
+        console.log("  holt sie zurück.");
+        return 0;
+    }
+    console.log(`${offen} von ${gesamt} Fragen über deine Firma sind noch offen.\n`);
+    for (const datei of gelesen) {
+        const offeneDieserDatei = datei.fragen.filter((f) => f.antwort === "");
+        if (offeneDieserDatei.length === 0)
+            continue;
+        console.log(`${datei.pfad}  —  ${datei.titel}`);
+        for (const frage of offeneDieserDatei) {
+            console.log(`  <!-- k3:${frage.anker} -->${zusatz(frage)}`);
+            console.log(`  ## ${frage.ueberschrift}`);
+            if (frage.hinweis !== "")
+                console.log(`     ${frage.hinweis}`);
+            console.log("");
+        }
+    }
+    console.log("  Die Antwort kommt in der genannten Datei unter ihre Überschrift.");
+    console.log("  Danach als Admin:  kimal3 kontext hoch");
+    return 0;
+}

package/dist/befehle/kontext-gemeinsam.js

@@ -0,0 +1,171 @@
+import { feld } from "../api.js";
+import { schlussFehler } from "../fehler.js";
+import { BASIS_URL } from "../anmeldung.js";
+import { findeArbeitsplatz } from "../kontext-dateien.js";
+/**
+ * Was `kontext runter` (`kontext-runter.ts`) und `kontext hoch`
+ * (`kontext-hoch.ts`) TEILEN -- die `--firma`/`--firma-id`-Optionen und die
+ * Absage-Logik fuer `/api/cli/kontext`.
+ *
+ * 🔴 **Ruling T9-2 (Split von `kontext.ts`, ehemals 400 Code-Zeilen mit zwei
+ * Befehlen).** Diese Datei existiert, damit die 409-Firmenwahl-Logik nicht
+ * zweimal existiert: zwei Kopien einer Entscheidung ueber Sichern/
+ * Ueberschreiben sind genau das Fehlerbild, das dieses Projekt schon mehrfach
+ * teuer bezahlt hat.
+ *
+ * 🔑 Was hier NICHT steht: alles, das nur EINE der beiden Richtungen betrifft.
+ * Die Fundregel-Implementierung (`findeArbeitsplatz`) bleibt in
+ * `kontext-dateien.ts` -- sie war schon vorher gemeinsam genutzt, aber importiert
+ * (Ruling T8-1), nicht hier definiert. Die Antwort-Formen `KontextAntwort` und
+ * `HochAntwort` bleiben bei ihrem jeweiligen Befehl, weil sie unterschiedliche
+ * Felder pruefen.
+ */
+/**
+ * Den Arbeitsplatz suchen -- und, wenn keiner da ist, die Absage GLEICH
+ * ausgeben.
+ *
+ * 🔴 **Sie steht hier, weil es jetzt DREI Aufrufer gibt** (`kontext runter`,
+ * `kontext hoch`, `kontext fragen`). Bis Task 7 waren es zwei, und beide
+ * trugen dieselben vier Zeilen abgetippt. Bei der dritten Kopie ist es keine
+ * Wiederholung mehr, sondern eine Falle: Wer eine Zeile schaerft, schaerft
+ * eine von dreien, und zwei Befehle erklaeren dieselbe Lage danach anders.
+ *
+ * `null` heisst "kein Arbeitsplatz" -- die Meldung steht dann schon auf
+ * stderr, der Aufrufer gibt nur noch `1` zurueck.
+ */
+export function arbeitsplatzOderAbsage() {
+    const ordner = findeArbeitsplatz(process.cwd());
+    if (ordner !== null)
+        return ordner;
+    console.error("Hier steht kein KI-Arbeitsplatz -- ich suche von hier aufwaerts nach einem");
+    console.error("Ordner, der `kontext/` UND `CLAUDE.md` enthaelt.");
+    console.error("");
+    console.error("  Wechsle in deinen Arbeitsplatz-Ordner und versuch es dort noch einmal.");
+    return null;
+}
+/**
+ * Was ein Mensch liest, wenn eine der fuenf Dateien keine einzige ihrer Fragen
+ * mehr traegt -- **woertlich dieselben Zeilen fuer `kontext hoch` und
+ * `kontext fragen`** (Review-Befund J1).
+ *
+ * 🔴 **WARUM SIE GETEILT WIRD.** `kontext fragen` zaehlte eine solche Datei
+ * vorher stillschweigend mit NULL Fragen und liess sie aus beiden Summen
+ * fallen. Gemessen mit der ausgelieferten `README.md` als `kontext/marke.md`:
+ * „12 von 12 Fragen" statt 17, „Die Marke" nirgends genannt -- und nach zwoelf
+ * Antworten meldete der Befehl `✓ Alle 12 Fragen … sind beantwortet`, waehrend
+ * `kontext hoch` einen Schritt spaeter auf genau dieser Datei abbrach.
+ * *Der lesende Befehl gab die beruhigende Auskunft, der schreibende
+ * verweigerte sich.* Das ist die Form von Fund F, und es ist die Regel, gegen
+ * die diese Aufgabe gebaut ist: **Ein Fehlerfall darf nie denselben Namen
+ * tragen wie ein Erfolgsfall.**
+ *
+ * ⚠️ `folge` ist die EINE Zeile, die sich unterscheiden darf -- was der
+ * jeweilige Befehl gerade nicht getan hat. Die Beschreibung des Ordners
+ * (Zeile 1 und 2) ist bei beiden Zeichen fuer Zeichen dieselbe; zwei Fassungen
+ * davon wuerden auseinanderlaufen, und dann beschriebe jeder Befehl eine
+ * andere Lage.
+ *
+ * 🔑 ECHTE UMLAUTE -- das hier liest ein Kunde im Terminal. Die ASCII-Umschrift
+ * dieses Ordners gilt nur fuer Kommentare.
+ */
+export function fremdeDateiAbsage(pfad, titel, ankerPraefix, folge) {
+    console.error(`„${pfad}" sieht nicht aus wie „${titel}". ${folge}`);
+    console.error(`  Ich finde darin keine einzige Frage dieser Datei (Zeilen wie \`<!-- k3:${ankerPraefix}… -->\`).`);
+    console.error("  Hol sie mit `kimal3 kontext runter` zurück und trag deine Antworten dort ein.");
+}
+/** `--firma`/`--firma-id` -- die einzigen Optionen, die beide Richtungen kennen. */
+export const ERLAUBT = ["firma", "firma-id"];
+/**
+ * Alles, was `/api/cli/kontext` NICHT mit `200` beantwortet -- fuer GET
+ * (`kontextRunter`) und POST (`kontextHoch`) gleichermassen. `befehl` sagt,
+ * welcher der beiden fuer die kopierfertigen Zeilen richtig ist.
+ *
+ * 🔑 Dieselbe Struktur wie `firmaDaten` in `firma-daten.ts` -- 402 vor 401
+ * (verlangen Gegenteiliges), 409 nennt die eigenen Firmen bzw. die IDs bei
+ * gleichnamigen, der Rest geht an `schlussFehler`. Die kopierfertigen Zeilen
+ * unten sind eine BEWUSSTE Kopie und keine Wiederverwendung von
+ * `firmen-liste.ts`: Dessen `firmenZeilen`/`firmenIdZeilen` schreiben den
+ * Befehl `kimal3 firma daten …` fest in die Zeile -- fuer `kontext *`
+ * waere das ein falscher, nicht ausfuehrbarer Rat.
+ *
+ * 🔴 **`409` heisst hier ZWEI verschiedene Dinge** (Task 9): Bei GET und bei
+ * POST kommt ein `409` mit `grund` von `waehleFirma` (mehrdeutige Firmenwahl,
+ * unten weiterbehandelt) -- POST kann ZUSAETZLICH `grund: "veraltet"` senden
+ * (§7d, `postRoh` in `route.ts`): Die Firma wurde inzwischen von jemand
+ * anderem geaendert. Die `meldung` dafuer nennt bereits WER und WANN sowie
+ * den Ausweg (`--ueberschreiben`) -- sie kommt woertlich vom Server und wird
+ * hier nur ausgegeben, nicht neu formuliert.
+ */
+export function absage(antwort, befehl) {
+    const meldung = feld(antwort.koerper, "meldung") ?? "Das hat nicht geklappt.";
+    if (antwort.status === 402) {
+        console.error(meldung);
+        return 4;
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
+        return 2;
+    }
+    if (antwort.status === 409) {
+        const grund = feld(antwort.koerper, "grund");
+        if (grund === "veraltet") {
+            console.error(meldung);
+            return 1;
+        }
+        const koerper = antwort.koerper;
+        const namen = Array.isArray(koerper?.firmen)
+            ? koerper.firmen.filter((x) => typeof x === "string")
+            : [];
+        console.error(meldung);
+        const auswahl = Array.isArray(koerper.auswahl)
+            ? koerper.auswahl.filter((x) => !!x &&
+                typeof x === "object" &&
+                typeof x.id === "string" &&
+                typeof x.name === "string")
+            : [];
+        if (auswahl.length > 0) {
+            console.error("\n  Diese beiden heissen gleich — nimm die ID:");
+            firmenIdZeilenKontext(auswahl, befehl).forEach((z) => console.error(z));
+        }
+        else {
+            const zeilen = firmenZeilenKontext(namen, befehl);
+            if (zeilen.length > 0) {
+                console.error("\n  Deine Firmen:");
+                zeilen.forEach((z) => console.error(z));
+            }
+        }
+        if (grund === "keine-firma") {
+            console.error(`\n  Eine Firma anlegen: ${BASIS_URL}/firma/neu`);
+        }
+        return 1;
+    }
+    const schluss = schlussFehler(antwort.status, meldung);
+    console.error(schluss.text);
+    return schluss.wert;
+}
+/**
+ * `firmenZeilen` aus `firmen-liste.ts`, nur mit dem richtigen Befehl in der
+ * Zeile -- s. Kommentar an `absage`.
+ */
+function firmenZeilenKontext(namen, befehl) {
+    const anzahl = (name) => namen.filter((n) => n === name).length;
+    const gesehen = new Set();
+    const zeilen = [];
+    for (const name of namen) {
+        if (gesehen.has(name))
+            continue;
+        gesehen.add(name);
+        const wieOft = anzahl(name);
+        if (wieOft === 1) {
+            zeilen.push(`    kimal3 ${befehl} --firma "${name}"`);
+        }
+        else {
+            zeilen.push(`    „${name}" — kommt ${wieOft}× vor und ist über den Namen nicht wählbar.`);
+        }
+    }
+    return zeilen;
+}
+/** `firmenIdZeilen` aus `firmen-liste.ts`, nur mit dem richtigen Befehl. */
+function firmenIdZeilenKontext(auswahl, befehl) {
+    return auswahl.map((f, i) => `    kimal3 ${befehl} --firma-id "${f.id}"   # ${f.name} (${i + 1}.)`);
+}

package/dist/befehle/kontext-hoch.js

@@ -0,0 +1,203 @@
+import { zerlege } from "../argumente.js";
+import { ruf } from "../api.js";
+import { FIRMEN_TEXTE, alsMerkzettel, bekannterStandAus, merkzettelNachHoch, } from "../kontext-stand.js";
+import { traegtFragenVon } from "../fragen-lesen.js";
+import { leseEineDatei, leseMerkzettelDatei, schreibeMerkzettelDatei } from "../kontext-dateien.js";
+import { ERLAUBT, absage, arbeitsplatzOderAbsage, fremdeDateiAbsage } from "./kontext-gemeinsam.js";
+/*
+  🪦 **Hier stand `feldSchluessel`, gestrichen mit Ruling K-6 (Task 7).**
+
+  Sie leitete den Feldnamen der Route aus dem Dateinamen ab (`marke.md` ->
+  `marke_md`). Fuer vier der fuenf Dateien war das richtig; die fuenfte,
+  `kontext/kurzprofil.md`, fuellt `drei_saetze` und haette daraus `kurzprofil_md`
+  bekommen -- ein Feld, das die Route nicht kennt. Die Zuordnung steht jetzt als
+  Tabelle in `FIRMEN_TEXTE` (`../kontext-stand.js`), und dass sie mit `FELDER`
+  in der App uebereinstimmt, prueft `check:kontext`.
+*/
+// 📌 `bekannterStandAus` wohnte hier (Fix-Runde 1, Review-Fund 1) und ist seit
+// Task 10 nach `../kontext-stand.js` umgezogen -- `cli/src/api.ts` braucht
+// dieselbe Rechnung fuer den Kopf `X-Kimal3-Kontext-Stand`, und ein Import
+// von HIER haette `api.ts` in einen Kreisimport mit sich selbst gezwungen
+// (diese Datei importiert `ruf` aus `../api.js`). Die volle Begruendung der
+// Rechnung selbst steht jetzt dort.
+const HILFE_HOCH = `
+  kimal3 kontext hoch [--firma "Name" | --firma-id "…"] [--ueberschreiben]
+
+  Schickt deine lokalen Aenderungen an allen fuenf Firmen-Texten nach oben --
+  fuer den Firmen-Admin. Nur wer Admin ist, darf das; die App entscheidet.
+
+  Die fuenf sind die Dateien in kontext/: kurzprofil.md, firma.md, marke.md,
+  systeme.md, sicherheit.md.
+
+  Welche Fragen darin noch offen sind, zeigt "kimal3 kontext fragen".
+
+  --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.
+
+  --ueberschreiben      Speichert auch dann, wenn die Firma inzwischen von
+                        jemand anderem geaendert wurde (§7d).
+`;
+/**
+ * Schickt die fuenf Firmen-Texte des gefundenen Arbeitsplatzes nach oben --
+ * die Gegenrichtung zu `kontextRunter` (`kontext-runter.ts`). Fundregel,
+ * Firmenwahl-Absage und die `--firma`/`--firma-id`-Optionen teilt sie sich mit
+ * `kontextRunter` ueber `kontext-gemeinsam.ts` (Ruling T9-2).
+ *
+ * 🔴 **FUENF GLEICHRANGIGE DATEIEN IN `kontext/` -- kein Sonderfall mehr
+ * (Ruling K-6, Task 7).** Bis hierher las dieser Befehl die drei Saetze aus der
+ * Firmen-`CLAUDE.md` heraus. Seit Task 6 stehen dort nur noch die ANTWORTEN,
+ * ohne Anker und ohne Ueberschriften -- zurueckgeschickt haetten sie die Spalte
+ * mit einem Text gefuellt, in dem die App keine einzige beantwortete Frage
+ * findet. Das Formular haette danach wieder das leere Fragengeruest gezeigt,
+ * mit den Saetzen der Firma unsichtbar dahinter. Gepflegt wird stattdessen
+ * `kontext/kurzprofil.md`, wie die vier anderen auch.
+ *
+ * 🔴 **Importiert bewusst KEIN `FELDER` aus `src/app/firma/kontext-felder.ts`.**
+ * `cli/src/` ist ein eigenes Paket mit eigenem `tsconfig` und darf nichts aus
+ * `src/` importieren (s. Kopf von `kontext-stand.ts`). Welche Datei welches
+ * Feld fuellt, steht deshalb in `FIRMEN_TEXTE` -- und dass diese Tabelle mit
+ * `FELDER` uebereinstimmt, ist eine Pruefung in `check:kontext`.
+ */
+export async function kontextHoch(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE_HOCH);
+        return 0;
+    }
+    const ueberschreiben = argv.includes("--ueberschreiben");
+    // ⚠️ `zerlege` kennt keine Optionen ohne Wert -- `--ueberschreiben` wird
+    // deshalb VOR der Zerlegung herausgefiltert, genau wie `--help`/`-h` oben
+    // nie an `zerlege` gereicht werden.
+    const ohneFlag = argv.filter((a) => a !== "--ueberschreiben");
+    const zerlegt = zerlege(ohneFlag, ERLAUBT);
+    if (!zerlegt.ok) {
+        console.error(zerlegt.meldung);
+        return 1;
+    }
+    const ordner = arbeitsplatzOderAbsage();
+    if (ordner === null)
+        return 1;
+    // 🔴 Fix-Runde 1: der bekannte Stand kommt aus ALLEN Merkzettel-Eintraegen
+    // (`bekannterStandAus`), nicht nur aus den Dateien, die gleich gelesen
+    // werden. Die Firmenzeile traegt genau EIN `geaendert_am` fuer alle fuenf
+    // Felder -- jeder nicht-leere Eintrag kennt es also, auch der der `CLAUDE.md`.
+    const lokalerMerkzettel = leseMerkzettelDatei(ordner);
+    const bekannterStand = bekannterStandAus(lokalerMerkzettel);
+    /*
+      ---- die fuenf Texte lesen ---------------------------------------------
+  
+      🔴 JEDER ABBRUCH HIER PASSIERT VOR DEM ERSTEN `ruf` -- es wird nichts
+      gesendet, auch nichts Halbes. Ein Lauf, der vier von fuenf Texten schickt
+      und dabei einen Fehler meldet, laesst den Admin ratlos zurueck: Er weiss
+      dann nicht, was jetzt in der App steht. *Ein halber Stand, den niemand
+      benennen kann, ist teurer als ein Abbruch, der klar sagt, warum.*
+    */
+    const werte = {};
+    for (const datei of FIRMEN_TEXTE) {
+        const gelesen = leseEineDatei(ordner, datei.pfad);
+        if (!gelesen.ok) {
+            console.error(gelesen.meldung);
+            return 1;
+        }
+        if (gelesen.inhalt === null) {
+            console.error(`„${datei.pfad}" gibt es hier nicht -- ich schicke nichts Halbes hoch.`);
+            console.error("  Erst `kimal3 kontext runter` ausfuehren, dann bearbeiten, dann noch einmal.");
+            return 1;
+        }
+        /*
+          🔴 **DIE FALSCHE DATEI ERWISCHT -- DER ABBRUCH (Spec, Abschnitt 11).**
+    
+          Ohne diese Pruefung schickt der Befehl jeden Inhalt hoch, der an dieser
+          Stelle liegt. Die App zerlegt ihn gegen den Fragenkatalog GENAU DIESER
+          Datei, findet keine einzige Antwort -- und legt den kompletten Text als
+          „Zusatz" ab. Die Firma haette danach einen Zusatz statt eines
+          Firmentextes, und die CLI haette dazu „✓ hochgeschickt" gemeldet.
+          *Ein Fehlerfall darf nie denselben Namen tragen wie ein Erfolgsfall.*
+    
+          Der Fall ist nicht ausgedacht: Er entsteht durch ein verrutschtes
+          `cp`/`Copy-Item` ebenso wie durch eine Datei, die jemand von Hand
+          angelegt hat, weil `kontext runter` noch nie lief.
+        */
+        if (!traegtFragenVon(gelesen.inhalt, datei.ankerPraefix)) {
+            fremdeDateiAbsage(datei.pfad, datei.titel, datei.ankerPraefix, "Nichts wurde gespeichert.");
+            return 1;
+        }
+        werte[datei.feld] = gelesen.inhalt;
+    }
+    // ---- senden -------------------------------------------------------------
+    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 koerper = { stand: bekannterStand, ...werte };
+    if (ueberschreiben)
+        koerper.ueberschreiben = true;
+    const antwort = await ruf(pfad, { methode: "POST", mitAusweis: true, koerper });
+    if (antwort.status !== 200) {
+        return absage(antwort, "kontext hoch");
+    }
+    // 🔴 Ein `200` mit unlesbarem Rumpf ist KEIN Erfolg -- dasselbe Muster wie
+    // in `kontextRunter` und in `firma-daten.ts`.
+    if (antwort.koerper === null || typeof antwort.koerper !== "object") {
+        console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+        return 3;
+    }
+    const ergebnis = alsHochAntwort(antwort.koerper);
+    if (ergebnis === null) {
+        console.error("Die Antwort war nicht lesbar. Bitte gleich noch einmal.");
+        return 3;
+    }
+    /*
+      🔴 §6b: Der Merkzettel aus der ANTWORT wird JETZT geschrieben -- im selben
+      Zug wie der Erfolg, nicht danach. Ohne ihn saehe das naechste
+      `kontext runter` „Server neuer" UND „lokal geaendert", wo keiner ist, und
+      sicherte die eigene, gerade erst hochgeladene Fassung unnoetig weg.
+  
+      Schlaegt das Schreiben fehl, ist die Firma trotzdem gespeichert -- das
+      Scheitern betrifft nur die lokale Buchfuehrung. Ein Fehlerfall darf nie
+      denselben Namen tragen wie ein Erfolgsfall (§8), deshalb sagt die Meldung
+      das ausdruecklich, statt einen missglueckten Datei-Schreibvorgang wie ein
+      gescheitertes Hochladen aussehen zu lassen.
+    */
+    /*
+      🔴 **NICHT die Antwort des Servers eins zu eins** -- s. `merkzettelNachHoch`.
+      Ueber die Firmen-`CLAUDE.md` weiss dieser Befehl nichts: Er hat sie nicht
+      gesendet und schreibt sie nicht. Traege ihr Eintrag die Pruefsumme aus der
+      Antwort, meldete der naechste `kontext runter` „du hast lokal geaendert:
+      CLAUDE.md" und riete zu `kontext hoch` -- dem Befehl, der sie gar nicht
+      mitnimmt. Gemessen auf der Kundenstrecke am 2026-08-25.
+    */
+    const zuSchreiben = merkzettelNachHoch(ergebnis.merkzettel, lokalerMerkzettel, FIRMEN_TEXTE.map((d) => d.pfad));
+    const merkzettelSchreiben = schreibeMerkzettelDatei(ordner, zuSchreiben);
+    if (!merkzettelSchreiben.ok) {
+        console.error("Die Firma hat deine Aenderungen gespeichert -- nur der lokale Merkzettel liess sich nicht schreiben:");
+        console.error(merkzettelSchreiben.meldung);
+        return 1;
+    }
+    // US-3: WAS hochgeladen wurde, nicht nur "fertig".
+    //
+    // 🔑 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`. */
+function alsHochAntwort(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    const merkzettel = alsMerkzettel(k.merkzettel);
+    if (merkzettel === null)
+        return null;
+    const uebernommenRoh = k.uebernommen;
+    if (!Array.isArray(uebernommenRoh) || !uebernommenRoh.every((x) => typeof x === "string"))
+        return null;
+    return { merkzettel, uebernommen: uebernommenRoh };
+}