kimal3 0.1.5 → 0.2.0

package/dist/fragen-lesen.js

@@ -0,0 +1,178 @@
+/*
+  Die Fragen aus einer Kontext-Datei lesen -- die reine Rechnung hinter
+  `kimal3 kontext fragen` und hinter dem Abbruch von `kimal3 kontext hoch`.
+
+  🔑 WOHER DIE FRAGEN KOMMEN -- die eine Entscheidung dieser Datei:
+  **Aus der Datei selbst, nicht aus einem Katalog.** Jede ausgelieferte
+  Kontext-Datei traegt ihre Fragen bereits vollstaendig bei sich: einen Anker
+  (`<!-- k3:marke_anrede -->`), darunter die Frage als `## `-Ueberschrift,
+  darunter unsere Hinweiszeilen mit `>`, darunter die Antwort des Menschen.
+  Das Format beschreibt sich selbst.
+
+  🔴 WARUM DAS NICHT NUR BEQUEM, SONDERN DAS EINZIG EHRLICHE IST: Die CLI kann
+  nichts aus `src/` importieren (eigenes Paket, eigenes tsconfig -- s. Kopf von
+  `kontext-stand.ts`). Ein Katalog in `cli/src/` waere eine ZWEITE Fassung der
+  17 Fragen, und sie friert in dem Moment ein, in dem `npm publish` laeuft: Der
+  Kunde hat dann eine CLI von gestern und Dateien von heute. Die Datei auf
+  seiner Platte kommt dagegen IMMER vom Server -- sie ist die einzige Quelle,
+  die nicht gegenueber dem abweichen kann, was er wirklich vor sich hat.
+
+  ⚠️ DIESE DATEI IMPORTIERT NICHTS -- dieselbe Auflage wie `kontext-stand.ts`.
+  Nur so kann `scripts/check-kontext.mts` sie neben `FRAGEN` (aus der App) in
+  denselben Lauf holen und beide gegeneinander messen.
+
+  📌 Der Preis, ausgesprochen: Wer den ANKER einer Frage aus seiner Datei
+  loescht, die Ueberschrift aber stehen laesst, hat eine Frage, die hier nicht
+  mehr auftaucht. Die App faengt diesen Fall ab (sie erkennt die Frage am
+  Wortlaut) und setzt den Anker beim naechsten Speichern wieder ein. Die
+  Ausgabe von `kontext fragen` sagt deshalb "Fragen in deinen Dateien" und
+  nicht "alle Fragen deiner Firma" -- sie behauptet nur, was sie messen kann.
+*/
+/**
+ * `<!-- k3:anrede -->` bzw. `<!-- k3:unwoerter optional -->`.
+ *
+ * ⚠️ Woertlich dasselbe Muster wie `ANKER_MUSTER` in
+ * `src/app/firma/kontext-zerlegen.ts`. Es steht hier ein zweites Mal, weil
+ * diese Datei nichts importieren darf (s. Kopf) -- dass beide dasselbe meinen,
+ * misst `check:kontext`, indem er die ECHTEN Vorlagen durch beide Seiten
+ * schickt und die Ergebnisse vergleicht.
+ */
+const ANKER_MUSTER = /^<!--\s*k3:([a-z0-9_]+)(\s+optional)?\s*-->$/;
+function istHinweis(zeile) {
+    return zeile.trimStart().startsWith(">");
+}
+function istUeberschrift(zeile) {
+    return zeile.startsWith("## ");
+}
+/**
+ * Alle Fragen, die in `text` stehen -- in der Reihenfolge der Datei.
+ *
+ * Der Durchgang ist zeilenweise und haelt drei Dinge auseinander:
+ * 1. **Anker** -- er merkt sich, wessen Frage als Naechstes kommt.
+ * 2. **Ueberschrift** -- steht ein Anker offen, beginnt hier seine Frage.
+ * 3. **Darunter** -- die unmittelbar folgenden `>`-Zeilen sind UNSER Hinweis,
+ *    alles Weitere bis zur naechsten Ueberschrift ist die Antwort.
+ *
+ * 🔑 DER HINWEIS ZAEHLT NUR UNMITTELBAR UNTER DER UEBERSCHRIFT -- genau wie in
+ * `scripts/arbeitsplatz-inhalt.mts`, wo derselbe Katalog fuer die App entsteht.
+ * Sonst kaeme eine `>`-Zeile, die ein Mensch mitten in seine Antwort setzt,
+ * als unser Hinweis heraus.
+ *
+ * 🔴 AUS DER ANTWORT FALLEN TROTZDEM ALLE `>`-ZEILEN HERAUS, auch spaetere --
+ * das ist die Regel, nach der auch die App zerlegt (`zerlege`). Ein Zitatblock
+ * gehoert uns; ginge er als Antwort durch, stuende unser eigener Satz als
+ * Aussage der Firma in der Datenbank.
+ *
+ * ⚠️ Ein Anker OHNE Ueberschrift darunter zaehlt nicht -- er wird vom naechsten
+ * Anker oder von der naechsten Ueberschrift ueberschrieben. *Ein Anker, der auf
+ * eine Ueberschrift drei Absaetze weiter zeigt, ist kein Anker, sondern ein
+ * Zufall, der aussieht wie Absicht.*
+ */
+export function fragenAus(text) {
+    const zeilen = text.split(/\r?\n/);
+    const fragen = [];
+    let offenerAnker = null;
+    let aktuell = null;
+    let hinweisNochOffen = false;
+    const hinweise = [];
+    const antwort = [];
+    /** Die laufende Frage abschliessen -- Hinweis und Antwort festschreiben. */
+    const schliesse = () => {
+        if (aktuell === null)
+            return;
+        aktuell.hinweis = hinweise.join(" ").trim();
+        aktuell.antwort = antwort.join("\n").trim();
+        aktuell = null;
+        hinweise.length = 0;
+        antwort.length = 0;
+    };
+    for (const zeile of zeilen) {
+        const treffer = ANKER_MUSTER.exec(zeile.trim());
+        if (treffer) {
+            schliesse();
+            offenerAnker = { anker: treffer[1], pflicht: !treffer[2] };
+            continue;
+        }
+        if (istUeberschrift(zeile)) {
+            schliesse();
+            if (offenerAnker) {
+                aktuell = {
+                    anker: offenerAnker.anker,
+                    ueberschrift: zeile.slice(3).trim(),
+                    hinweis: "",
+                    pflicht: offenerAnker.pflicht,
+                    antwort: "",
+                };
+                hinweisNochOffen = true;
+                fragen.push(aktuell);
+            }
+            offenerAnker = null;
+            continue;
+        }
+        /*
+          🔴 **RULING K-14: EIN ANKER, UNTER DEM NICHT UNMITTELBAR SEINE FRAGE
+          STEHT, ZAEHLT NICHT.** Leerzeilen sind erlaubt, Text nicht. Ohne diese
+          drei Zeilen machte ein verwaister Anker die naechstbeste Ueberschrift zur
+          Frage -- und `kimal3 kontext fragen` stellte einem Menschen eine Frage,
+          die niemand geschrieben hat. Dieselbe Regel wie im Erzeuger
+          (`frageZeileNach` in `scripts/arbeitsplatz-inhalt.mts`).
+    
+          ⚠️ Die App ist an dieser Stelle NACHSICHTIGER: `zerlege` haengt einen
+          verwaisten Anker an die naechste Ueberschrift, wie weit sie auch weg ist.
+          Der Unterschied ist gewollt und folgenlos, solange keine ausgelieferte
+          Datei einen verwaisten Anker hat -- und genau das prueft
+          `check:arbeitsplatz` fuer jede Vorlage.
+        */
+        if (offenerAnker && zeile.trim() !== "")
+            offenerAnker = null;
+        if (aktuell === null)
+            continue;
+        if (istHinweis(zeile)) {
+            // Nur der Block DIREKT unter der Ueberschrift ist unser Hinweis;
+            // spaetere `>`-Zeilen fallen weg, gehoeren aber auch nicht zur Antwort.
+            if (hinweisNochOffen)
+                hinweise.push(zeile.trimStart().slice(1).trim());
+            continue;
+        }
+        // ⚠️ SCHON EINE LEERZEILE BEENDET DEN HINWEISBLOCK -- woertlich dieselbe
+        // Grenze wie im Erzeuger (`katalogAus` in `scripts/arbeitsplatz-inhalt.mts`).
+        // Zoege sie hier weiter, kaeme aus einer Datei mit einem Zitat weiter unten
+        // ein anderer Hinweis heraus als in der App, und `check:kontext` haette
+        // recht, wenn er rot wird.
+        hinweisNochOffen = false;
+        antwort.push(zeile);
+    }
+    schliesse();
+    return fragen;
+}
+/**
+ * Sieht dieser Text aus wie die Datei, die er sein soll?
+ *
+ * 🔴 **DER ABBRUCH VON `kimal3 kontext hoch` HAENGT AN DIESER ZEILE** (Spec,
+ * Abschnitt 11). Ohne sie schickt der Befehl JEDEN Dateiinhalt hoch, den er an
+ * der Stelle findet. Die App zerlegt ihn dann gegen den Katalog 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 einen Haken gemeldet. *Ein Fehlerfall darf nie denselben
+ * Namen tragen wie ein Erfolgsfall.*
+ *
+ * 🔑 **WORAN ERKANNT WIRD: an mindestens einem Anker, der zu DIESER Datei
+ * gehoert.** Die Anker sind je Datei benannt (`marke_anrede`, `firma_angebot`,
+ * `kurz_kunden` …), und `FIRMEN_TEXTE` (`kontext-stand.ts`) fuehrt je Datei
+ * ihren Praefix. Damit faellt nicht nur die voellig fremde Datei durch, sondern
+ * auch der haeufigere Unfall: `marke.md` ueber `firma.md` kopiert. Ein blosses
+ * "irgendein Anker steht drin" haette genau den durchgewunken.
+ *
+ * ⚠️ **Dass die Praefixe wirklich passen, ist keine Verabredung, sondern eine
+ * Messung:** `check:kontext` haelt jeden Anker aus `FRAGEN` (der App) gegen den
+ * Praefix, den `FIRMEN_TEXTE` fuer seine Datei nennt.
+ *
+ * 📌 **Der Preis, ausgesprochen:** Wer ALLE Anker einer Datei loescht und nur
+ * die Ueberschriften stehen laesst, bekommt hier ein Nein, obwohl die App den
+ * Text noch am Wortlaut erkennen wuerde. Das ist die sichere Seite: Es geht
+ * nichts verloren, die Meldung sagt warum, und `kimal3 kontext runter` stellt
+ * die Datei wieder her. Die andere Seite waere der stille Datenverlust oben.
+ */
+export function traegtFragenVon(text, ankerPraefix) {
+    return fragenAus(text).some((f) => f.anker.startsWith(ankerPraefix));
+}

package/dist/gesehen.js

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

package/dist/kimal3.js

@@ -11,17 +11,24 @@
  * `kimal3 login`, bei 4 hilft genau das nicht. Wer beide auf dieselbe Zahl
  * legt, laesst Claude den falschen Rat geben.
  */
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
-import { NichtAngemeldet } from "./api.js";
+import { gemerkterHinweis, NichtAngemeldet } from "./api.js";
+import { leseGesehen, merkeGesehen } from "./gesehen.js";
+import { formatiere, heuteAus, skillMeldung, skillZustand, sollZeigen, } from "./nachricht.js";
+import { eigeneVersion } from "./version.js";
 import { hilfeText } from "./befehle-katalog.js";
 import { arbeitsplatzNeu } from "./befehle/arbeitsplatz.js";
+import { werkbankNeu } from "./befehle/werkbank.js";
 import { firmaDaten } from "./befehle/firma-daten.js";
+import { kontextFragen } from "./befehle/kontext-fragen.js";
+import { kontextRunter } from "./befehle/kontext-runter.js";
+import { kontextHoch } from "./befehle/kontext-hoch.js";
 import { login } from "./befehle/login.js";
 import { logout } from "./befehle/logout.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
-import { skillInstall } from "./befehle/skill-install.js";
+import { skillDatei, skillInstall } from "./befehle/skill-install.js";
 // 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
 // `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
 // Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten
@@ -57,20 +64,167 @@ const HILFE = hilfeText();
  * eine Ebene unter `cli/`.
  */
 function versionsZeilen() {
-    let version = "unbekannt";
+    // 📌 Seit dem 2026-08-21 wird die Nummer NICHT mehr hier gelesen, sondern in
+    // `version.ts` -- sie hat einen zweiten Aufrufer bekommen (den Skill-Stempel
+    // in `skill install`). Zwei Lesestellen fuer dieselbe Zahl waeren genau das
+    // Muster, gegen das der Kommentar oben schon einmal geschrieben wurde.
+    //
+    // "unbekannt" bleibt hier stehen und wandert NICHT in `version.ts`: Diese
+    // Zeile zeigt einem Menschen etwas an, und da ist "unbekannt" die ehrliche
+    // Antwort. Der andere Aufrufer RECHNET mit dem Wert und braucht dort das
+    // Gegenteil -- er will lieber gar keine Nummer als eine erfundene.
+    const version = eigeneVersion() ?? "unbekannt";
+    return `  kimal3 ${version}\n  spricht mit ${BASIS_URL}`;
+}
+/**
+ * Welcher Update-Hinweis soll ans Ende -- oder keiner?
+ *
+ * 🔑 WARUM stderr (entschieden wird es erst beim Schreiben, gemeint ist es
+ * hier): Dort stoert der Hinweis keine Weiterverarbeitung --
+ * `kimal3 firma daten > firma.json` bleibt sauberes JSON --, und Claude sieht
+ * ihn trotzdem, denn es liest beide Kanaele.
+ *
+ * 🔴 WARUM ALLES IN EINEM try STECKT: Diese Funktion laeuft NACH dem
+ * eigentlichen Befehl. Wenn sie wirft, faellt ein bereits erfolgreicher Befehl
+ * auf Rueckgabewert 3 -- und Claude gaebe den Rat "gleich noch einmal" fuer
+ * etwas, das laengst erledigt ist. Die Zahlen sind laut dem Kopf dieser Datei
+ * die eigentliche Schnittstelle; ein Nebenschauplatz darf sie nicht anfassen.
+ */
+function hinweisText() {
     try {
-        const roh = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-        if (roh && typeof roh === "object" && "version" in roh) {
-            const v = roh.version;
-            if (typeof v === "string")
-                version = v;
+        const eigene = eigeneVersion();
+        // Ohne eigene Nummer ist jeder Vergleich geraten -- dann lieber schweigen.
+        // Das ist der Fall "package.json unlesbar", und da hat der Kunde groessere
+        // Sorgen als einen Update-Hinweis.
+        if (eigene === null)
+            return null;
+        const heute = heuteAus(new Date());
+        const h = gemerkterHinweis();
+        if (h && sollZeigen(h, eigene, leseGesehen(), heute)) {
+            // Hoechstens EIN Hinweis je Aufruf -- zwei sind eine Wand.
+            return { text: formatiere(h), kennung: h.id, tag: heute };
+        }
+        /*
+          Weg 2: ohne Netz.
+          ⚠️ Er greift immer dann, wenn oben NICHTS gezeigt wird -- nicht nur,
+          wenn gar kein Netz-Hinweis ankam (praezisiert nach der dritten
+          Review-Runde). Auch "die Nachricht stand heute schon da" und "sie gilt
+          fuer diese Fassung nicht" fuehren hierher. Das ist gewollt: Es bleibt
+          bei einem Hinweis je Aufruf.
+          *Hier stand vorher "nur, wenn kein Netz-Hinweis kam" -- eine Bedingung,
+          die der Code nicht hat. Genau der Kommentartyp, den dieses Projekt schon
+          zweimal teuer bezahlt hat.*
+        */
+        // Der Pfad kommt aus `skill-install.ts` -- dort wird er geschrieben, hier
+        // gelesen. Zwei Zusammenbauten desselben Ortes driften, und der zweite
+        // verrottet lautlos (Befund der vierten Review-Runde).
+        const datei = skillDatei();
+        const inhalt = existsSync(datei) ? readFileSync(datei, "utf8") : null;
+        if (skillZustand(inhalt, eigene) === "veraltet") {
+            // Auch dieser Hinweis nur einmal am Tag, unter einer festen Kennung.
+            // Sie kann mit keiner Nachrichten-UUID kollidieren.
+            const gesehen = leseGesehen();
+            if (gesehen["skill-veraltet"] !== heute) {
+                return { text: skillMeldung(), kennung: "skill-veraltet", tag: heute };
+            }
         }
     }
     catch {
-        // Kein Absturz, wenn die Datei fehlt: "unbekannt" ist eine ehrliche
-        // Antwort, ein Stapelabzug waere keine.
+        /* Ein Nebenschauplatz darf den Befehl nicht umwerfen. */
+    }
+    return null;
+}
+/**
+ * Den Hinweis schreiben und ERST DANN aussteigen.
+ *
+ * 🔴 WARUM NICHT EINFACH `console.error` UND `process.exit`: Auf Windows ist
+ * `process.stderr` auch bei Roehren und Terminals ASYNCHRON, und
+ * `process.exit()` wirft ausstehende Schreibvorgaenge weg (Befund der ersten
+ * Review-Runde). Der Hinweis ist das Letzte, was geschrieben wird -- er waere
+ * damit genau das Erste, was verlorengeht. *Ein Merkmal, dessen ganzer Wert an
+ * der letzten Zeile haengt, darf diese Zeile nicht dem Zufall ueberlassen.*
+ *
+ * `process.exitCode` wird vorher gesetzt: Sollte der Rueckruf wider Erwarten
+ * ausbleiben und der Prozess von selbst enden, stimmt die Zahl trotzdem -- und
+ * die Zahl ist laut dem Kopf dieser Datei die eigentliche Schnittstelle.
+ */
+function endeMitHinweis(code) {
+    try {
+        process.exitCode = code;
+        /*
+          🔴 NUR NACH EINEM GELUNGENEN BEFEHL (Befund der sechsten Review-Runde).
+          `haupt()` WIRFT bei den meisten Fehlern nicht, sondern gibt eine Zahl
+          zurueck -- 1 fuer einen unbekannten Befehl, 2 und 4 aus den Befehlen
+          selbst. Der Hinweis landete damit unter Fehlermeldungen, obwohl der
+          `.catch`-Zweig unten und der Wrapper auf dem Server beide das Gegenteil
+          begruenden: "Eine Fehlermeldung ist der schlechteste Augenblick fuer eine
+          Nebenbemerkung."
+    
+          ⚠️ Schlimmer als die Optik ist die Nebenwirkung: Der gescheiterte Lauf
+          verbrauchte den EINEN Platz des Tages. Wer sich vertippt und danach
+          richtig tippt, saehe die Nachricht dann heute gar nicht mehr.
+        */
+        const raus = code === 0 ? hinweisText() : null;
+        /*
+          🔴 BEIDE KANAELE LEEREN, NICHT NUR STDERR. Die erste Fassung dieser
+          Funktion sicherte stderr -- und liess den haeufigeren Weg (kein Hinweis)
+          bei einem nackten `process.exit` stehen. Genau der Fehler, gegen den sie
+          geschrieben war, stand also noch daneben.
+    
+          Es trifft naemlich vor allem STDOUT: `firma daten` schreibt ein
+          mehrere Kilobyte grosses JSON mit `console.log` und landet dann hier.
+          Auf Windows sind beide Kanaele asynchron; `process.exit()` wirft
+          Ausstehendes weg. Das Ergebnis waere das schlimmstmoegliche: ein
+          abgeschnittenes JSON MIT Rueckgabewert 0 -- Claude liest es als
+          gelungene Auskunft.
+    
+          🔑 Warum ueberhaupt noch `process.exit` und kein natuerliches Ende:
+          Nach einem `fetch` haelt Node seine Verbindungen eine Weile offen. Der
+          Befehl wuerde sekundenlang scheinbar haengen, nachdem er fertig ist.
+    
+          Die Notbremse ist `unref`t: Sie haelt die Schleife nicht am Leben,
+          feuert aber, falls ein Kanal wirklich haengt. Und weil `exitCode` schon
+          oben steht, stimmt die Zahl in JEDEM dieser Wege -- auch dann, wenn der
+          Prozess von selbst endet.
+    
+          🔴 UND DIE REIHENFOLGE IST DER PUNKT (Befund der sechsten Review-Runde):
+          ERST stdout leeren, DANN den Hinweis auf stderr schreiben. Die beiden
+          Kanaele haben eigene Puffer, und ihre Reihenfolge ist nur dann sicher,
+          wenn beide synchron sind -- auf einer POSIX-Roehre ist stdout es NICHT.
+          Bei `kimal3 firma daten 2>&1 | tee firma.json` mit mehr als 64 KiB
+          Nutzlast koennte die kleine stderr-Zeile also VOR dem grossen JSON
+          ankommen und mitten hineinrutschen. Genau das verbietet US-1 ("nie
+          mittendrin"), und es waere eine Ausgabe, die SKILL.md als Firmendaten
+          zu lesen anweist.
+          📌 Auf Windows liess es sich nicht herstellen -- dort sind Roehren
+          synchron. *Eine Reihenfolge, die nur auf dem Rechner haelt, auf dem man
+          sie gemessen hat, ist keine Reihenfolge, sondern ein Zufall.*
+        */
+        setTimeout(() => process.exit(code), 2000).unref();
+        process.stdout.write("", () => {
+            if (!raus) {
+                process.stderr.write("", () => process.exit(code));
+                return;
+            }
+            // Erst schreiben, DANN vermerken -- und nur, wenn kein Fehler zurueckkam.
+            process.stderr.write(`${raus.text}\n`, (fehler) => {
+                if (!fehler)
+                    merkeGesehen(raus.kennung, raus.tag);
+                process.exit(code);
+            });
+        });
+    }
+    catch {
+        /*
+          ⚠️ Auch das Schreiben selbst kann werfen -- ein geschlossener
+          Ausgabekanal genuegt. Ohne dieses `catch` liefe der Wurf in den
+          `.catch`-Zweig unten, und der macht aus einem GELUNGENEN Befehl eine
+          3 ("gleich noch einmal"). Das ist genau das, was der Kommentar an
+          `hinweisText` verspricht, dass es nie passiert -- versprochen war es
+          dort aber nur fuer die halbe Strecke.
+        */
+        process.exit(code);
     }
-    return `  kimal3 ${version}\n  spricht mit ${BASIS_URL}`;
 }
 /**
  * Was diese Zeile sagen KANN — und was nicht.
@@ -126,11 +280,22 @@ async function haupt() {
         return skillInstall();
     if (argv[0] === "arbeitsplatz" && argv[1] === "neu")
         return arbeitsplatzNeu(argv.slice(2));
+    if (argv[0] === "werkbank" && argv[1] === "neu")
+        return werkbankNeu(argv.slice(2));
+    if (argv[0] === "kontext" && argv[1] === "runter")
+        return kontextRunter(argv.slice(2));
+    if (argv[0] === "kontext" && argv[1] === "hoch")
+        return kontextHoch(argv.slice(2));
+    if (argv[0] === "kontext" && argv[1] === "fragen")
+        return kontextFragen(argv.slice(2));
     console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);
     return 1;
 }
 haupt()
-    .then((code) => process.exit(code))
+    .then((code) => endeMitHinweis(code))
+    // ⚠️ Im Fehlerzweig bewusst KEIN Hinweis. Wer gerade eine Fehlermeldung
+    // liest, braucht keine zweite Zeile ueber Updates -- und ein Netz-Hinweis
+    // kann hier ohnehin nicht angekommen sein, denn genau das Netz hat versagt.
     .catch((f) => {
     if (f instanceof NichtAngemeldet) {
         console.error("Bitte zuerst `kimal3 login` ausführen.");