kimal3 0.1.6 → 0.2.0

package/dist/befehle/kontext-runter.js

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

package/dist/befehle-katalog.js

@@ -84,6 +84,55 @@ export const BEFEHLE = [
             "Gib deinen Vornamen mit — der Ordner trägt ihn: aus sabine wird werkbank-sabine. Ohne Angabe bildet der Server ihn aus deiner Anmelde-Adresse. So sieht man später, wem welche Werkbank gehört.",
         ],
     },
+    /*
+      🔴 Auch diese zwei Eintraege stehen direkt NEBEN `werkbank neu` und nicht
+      am Ende der Liste, aus demselben Grund wie oben bei `arbeitsplatz neu`:
+      Wer hier liest, sucht den naechsten Schritt, nicht das Alphabet. Wer
+      einen KI-Arbeitsplatz gerade angelegt oder betreten hat, fragt sich als
+      Naechstes, wie der Firmenkontext (CLAUDE.md + kontext/*.md) aktuell
+      bleibt -- nicht, wie man ein Projekt eintraegt.
+    */
+    {
+        befehl: "kimal3 kontext runter",
+        beschreibung: "Den Firmenkontext holen — CLAUDE.md und die fünf Dateien in kontext/",
+        wer: "du",
+        rhythmus: "wann immer die Firma etwas geändert haben könnte",
+        tippen: "! kimal3 kontext runter",
+        terminal: "kimal3 kontext runter",
+        details: [
+            "Holt CLAUDE.md und die fünf Dateien in kontext/ von deiner Firma und legt sie in deinem KI-Arbeitsplatz ab. Was du selbst lokal geändert hast, fasst er nicht an — er sagt dir, wie du es einbringst.",
+            "Hast du eine Datei lokal geändert UND hat die Firma sie inzwischen auch geändert, sichert er deine Fassung zuerst nach kontext/vorher-<datum>/, bevor er sie ersetzt — nichts geht verloren.",
+            "Geklappt hat es, wenn er die aktualisierten Dateien nennt oder „Dein Firmenkontext ist aktuell“ sagt.",
+            "⚠️ Wie werkbank neu braucht er ein eigenes Pro-Konto. Ohne das kommt Rückgabewert 4 — dann nicht wiederholen.",
+        ],
+    },
+    {
+        befehl: "kimal3 kontext fragen",
+        beschreibung: "Zeigen, welche Fragen über deine Firma noch unbeantwortet sind",
+        wer: "du",
+        rhythmus: "bevor ihr den Firmenkontext ausfüllt — und wann immer du wissen willst, was fehlt",
+        tippen: "! kimal3 kontext fragen",
+        terminal: "kimal3 kontext fragen",
+        details: [
+            "Liest die fünf Dateien in kontext/ und gibt jede Frage aus, unter der noch nichts steht — mit Datei, Frage und Hinweis. Sind alle beantwortet, sagt er das in einem Satz.",
+            "Er liest nur: kein Netz, keine Anmeldung, kein Schreiben. Deshalb ist er der richtige erste Schritt — Claude stellt dir die Fragen dann einzeln und trägt deine Antworten in die Dateien ein.",
+            "Danach schickt kimal3 kontext hoch sie an die Firma. Das darf nur der Admin; alle anderen geben ihre Antworten an ihn weiter.",
+        ],
+    },
+    {
+        befehl: "kimal3 kontext hoch",
+        beschreibung: "Deine lokalen Änderungen an den fünf Firmen-Texten hochschicken",
+        wer: "du",
+        rhythmus: "nachdem du kontext/*.md bearbeitet hast — nur als Admin",
+        tippen: "! kimal3 kontext hoch",
+        terminal: "kimal3 kontext hoch",
+        details: [
+            "Schickt alle fünf Firmen-Texte an deine Firma — die Dateien in kontext/ (kurzprofil.md, firma.md, marke.md, systeme.md, sicherheit.md). Damit kommen sie beim nächsten kontext runter auch bei den Kolleginnen und Kollegen an.",
+            "🔴 Nur der Firmen-Admin darf das. Bist du keiner, kommt Rückgabewert 1 — das ist hier kein „nochmal versuchen“, sondern „gib deine Ergänzung an den Admin weiter“.",
+            "Sieht eine der fünf Dateien nicht mehr aus wie ihre Frageliste — etwa weil etwas Fremdes darüberkopiert wurde —, bricht er ab und schickt gar nichts, auch die vier anderen nicht. kimal3 kontext runter holt die Datei zurück.",
+            "Geklappt hat es, wenn er „✓ hochgeschickt“ mit den Dateinamen meldet.",
+        ],
+    },
     {
         befehl: "kimal3 projekt neu …",
         beschreibung: "Ein Projekt ins Erfolgsprofil eintragen",

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/kimal3.js

@@ -21,6 +21,9 @@ 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";
@@ -279,6 +282,12 @@ async function haupt() {
         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;
 }