kimal3 0.2.10 → 0.3.1

package/dist/kimal3.js

@@ -16,10 +16,14 @@ import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
 import { gemerkterHinweis, lokalerKontextStandJetzt, NichtAngemeldet } from "./api.js";
 import { leseGesehen, merkeGesehen } from "./gesehen.js";
 import { ausfallMeldung, hinweisAnhaengen } from "./wache-rechnung.js";
+import { WACHE_TEXTE } from "./texte/wache.js";
 import { leseWacheDatei, sitzungJetzt, wacheAusgefallen } from "./wache-schalter.js";
-import { formatiere, heuteAus, skillMeldung, skillZustand, sollZeigen, } from "./nachricht.js";
+import { formatiere, heuteAus, skillZustand, sollZeigen, } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
-import { hilfeText } from "./befehle-katalog.js";
+import { sprache } from "./sprache.js";
+import { ALLGEMEIN_TEXTE } from "./texte/allgemein.js";
+import { hilfeText } from "./hilfe.js";
+import { erkenneBefehl } from "./befehlswoerter.js";
 import { arbeitsplatzNeu } from "./befehle/arbeitsplatz.js";
 import { werkbankNeu } from "./befehle/werkbank.js";
 import { firmaDaten } from "./befehle/firma-daten.js";
@@ -135,7 +139,9 @@ function gegenUnbehandelteKanalfehlerAbsichern(kanal, meldenAuf) {
             return;
         schonGemeldet = true;
         try {
-            meldenAuf.write(`kimal3: Ausgabekanal-Fehler -- ${fehler.message}\n`);
+            // 🌐 Teil 3: die Sprache wird erst JETZT gelesen (zur Schreibzeit); der Empfaenger selbst
+            // bleibt auf Modulebene vor der ersten Zeile angemeldet.
+            meldenAuf.write(ALLGEMEIN_TEXTE[sprache()].outputChannelError(fehler.message));
         }
         catch {
             // Auch der Fehlerkanal kann kaputt sein -- dann bleibt wenigstens der
@@ -149,7 +155,6 @@ gegenUnbehandelteKanalfehlerAbsichern(process.stderr, null);
 // `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
 // Befehl, die andere nicht, und keiner der beiden Orte wuesste davon.
-const HILFE = hilfeText();
 /**
  * Hilfe plus Zustand.
  *
@@ -189,8 +194,9 @@ function versionsZeilen() {
     // 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}`;
+    const t = ALLGEMEIN_TEXTE[sprache()];
+    const version = eigeneVersion() ?? t.versionUnknown;
+    return t.versionLines(version, BASIS_URL);
 }
 /**
  * Welcher Update-Hinweis soll ans Ende -- oder keiner?
@@ -254,12 +260,12 @@ function hinweisText() {
         // verrottet lautlos (Befund der vierten Review-Runde).
         const datei = skillDatei();
         const inhalt = existsSync(datei) ? readFileSync(datei, "utf8") : null;
-        if (skillZustand(inhalt, eigene) === "veraltet") {
+        if (skillZustand(inhalt, eigene, sprache()) === "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 };
+                return { text: WACHE_TEXTE[sprache()].skillOutdated, kennung: "skill-veraltet", tag: heute };
             }
         }
         /*
@@ -281,7 +287,7 @@ function hinweisText() {
             // Auch dieser Hinweis hoechstens einmal am Tag, unter fester Kennung.
             const gesehen = leseGesehen();
             if (gesehen["wache-ausgefallen"] !== heute) {
-                return { text: ausfallMeldung(), kennung: "wache-ausgefallen", tag: heute };
+                return { text: ausfallMeldung(sprache()), kennung: "wache-ausgefallen", tag: heute };
             }
         }
     }
@@ -463,17 +469,61 @@ function endeMitHinweis(code) {
  * nicht mehr Auskunft, sondern **weniger Behauptung**.
  */
 function zustandsZeile() {
+    const t = ALLGEMEIN_TEXTE[sprache()];
     const a = leseAnmeldung();
-    return a
-        ? `  ● Ausweis hinterlegt für ${a.email}\n` +
-            "    (ob er noch gilt, zeigt erst der nächste Befehl)"
-        : "  ● Nicht angemeldet.  →  kimal3 login";
+    return a ? t.credentialsStored(a.email) : t.notSignedIn;
+}
+/** `null` = der Rest passt nicht zu diesem Befehl -> "kenne ich nicht", wie bisher. */
+async function fuehreAus(name, rest) {
+    const allein = rest.length === 0;
+    switch (name) {
+        case "login": return allein ? login() : null;
+        case "logout": return allein ? logout() : null;
+        case "skill install": return allein ? skillInstall() : null;
+        case "projekt neu": return projektNeu(rest);
+        case "projekt liste": return allein ? projektListe() : null;
+        // ⚠️ Rest wird durchgereicht, nicht auf Gleichheit geprueft: `firma daten --firma X` gehoert dazu.
+        case "firma daten": return firmaDaten(rest);
+        case "arbeitsplatz neu": return arbeitsplatzNeu(rest);
+        case "werkbank neu": return werkbankNeu(rest);
+        case "kontext runter": return kontextRunter(rest);
+        case "kontext hoch": return kontextHoch(rest);
+        case "kontext fragen": return kontextFragen(rest);
+        case "wache an": return allein ? wacheSchalten(true) : null;
+        case "wache aus": return allein ? wacheSchalten(false) : null;
+        case "wache":
+            // 🔴 Der Startbefehl aus `~/.claude/settings.json`, den `skill install` eintraegt (T3-5:
+            // eingetragen wird immer `kimal3 wache --hook`; `kimal3 watch --hook` laeuft genauso).
+            // Er verpackt die Meldung anders -- Begruendung an `wache()`.
+            // ⚠️ Ein Mensch tippt das nie; der Katalog nennt ihn deshalb auch nicht.
+            if (rest.length === 1 && rest[0] === "--hook")
+                return wache(true);
+            /*
+              🔴 NACHSICHT GEGENUEBER FLAGGEN, DIE ES HIER NOCH NICHT GIBT.
+              Der Eintrag in `~/.claude/settings.json` ueberlebt jede Neuinstallation --
+              auch eine, die eine AELTERE Fassung bringt. Steht dort eines Tages
+              `wache --irgendwas`, das diese Fassung nicht kennt, faellt der Aufruf ohne
+              diese Zeile in den Unbekannt-Zweig: die volle Hilfe bei JEDEM Claude-Start,
+              Rueckgabewert 1, und `merkeSitzung` wird nie erreicht -- woraufhin
+              `wacheAusgefallen` bei jedem weiteren Befehl einen Rat gibt, der nichts
+              behebt. Aus einem fehlenden Zusatz wird so ein lauter Dauerschaden.
+              🔑 Warum die MENSCHEN-Form die richtige Rueckfallebene ist: Sie endet
+              normal mit 0, ihre Meldung kommt also an. Die JSON-Form waere fuer einen
+              Menschen, der aus Neugier eine Flagge tippt, nur Kauderwelsch.
+              ⚠️ Fuer bereits veroeffentlichte Fassungen ist das nicht mehr zu retten --
+              `0.2.3` kennt `--hook` nicht. Diese Zeile sorgt dafuer, dass die naechste
+              Flagge die Falle nicht erneut stellt. (Befund der Durchsicht, 2026-09-09.)
+            */
+            if (rest.every((a) => a.startsWith("--")))
+                return wache(false);
+            return null;
+    }
 }
 async function haupt() {
     const argv = process.argv.slice(2);
     const wort = argv.join(" ");
     if (argv.length === 0 || wort === "--help" || wort === "-h") {
-        console.log(HILFE);
+        console.log(hilfeText(sprache()));
         console.log(zustandsZeile() + "\n");
         return 0;
     }
@@ -482,61 +532,17 @@ async function haupt() {
         console.log(zustandsZeile() + "\n");
         return 0;
     }
-    if (wort === "login")
-        return login();
-    if (wort === "logout")
-        return logout();
-    if (argv[0] === "projekt" && argv[1] === "neu")
-        return projektNeu(argv.slice(2));
-    if (wort === "projekt liste")
-        return projektListe();
-    // ⚠️ Praefix-Vergleich wie bei `projekt neu` und NICHT `wort === "firma daten"`:
-    // `wort` enthaelt die Optionen mit, `firma daten --firma X` fiele bei einem
-    // Gleichheits-Vergleich durch und meldete "Den Befehl kenne ich nicht".
-    if (argv[0] === "firma" && argv[1] === "daten")
-        return firmaDaten(argv.slice(2));
-    if (wort === "skill install")
-        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));
-    if (wort === "wache")
-        return wache(false);
-    // 🔴 Der Startbefehl aus `~/.claude/settings.json`, den `skill install`
-    // eintraegt. Er verpackt die Meldung anders -- Begruendung an `wache()`.
-    // ⚠️ Ein Mensch tippt das nie; der Katalog nennt ihn deshalb auch nicht.
-    if (wort === "wache --hook")
-        return wache(true);
-    if (wort === "wache aus")
-        return wacheSchalten(false);
-    if (wort === "wache an")
-        return wacheSchalten(true);
-    /*
-      🔴 NACHSICHT GEGENUEBER FLAGGEN, DIE ES HIER NOCH NICHT GIBT.
-      Der Eintrag in `~/.claude/settings.json` ueberlebt jede Neuinstallation --
-      auch eine, die eine AELTERE Fassung bringt. Steht dort eines Tages
-      `wache --irgendwas`, das diese Fassung nicht kennt, faellt der Aufruf ohne
-      diese Zeile in den Unbekannt-Zweig: die volle Hilfe bei JEDEM Claude-Start,
-      Rueckgabewert 1, und `merkeSitzung` wird nie erreicht -- woraufhin
-      `wacheAusgefallen` bei jedem weiteren Befehl einen Rat gibt, der nichts
-      behebt. Aus einem fehlenden Zusatz wird so ein lauter Dauerschaden.
-      🔑 Warum die MENSCHEN-Form die richtige Rueckfallebene ist: Sie endet
-      normal mit 0, ihre Meldung kommt also an. Die JSON-Form waere fuer einen
-      Menschen, der aus Neugier eine Flagge tippt, nur Kauderwelsch.
-      ⚠️ Fuer bereits veroeffentlichte Fassungen ist das nicht mehr zu retten --
-      `0.2.3` kennt `--hook` nicht. Diese Zeile sorgt dafuer, dass die naechste
-      Flagge die Falle nicht erneut stellt. (Befund der Durchsicht, 2026-09-09.)
-    */
-    if (argv[0] === "wache" && argv.slice(1).every((a) => a.startsWith("--")))
-        return wache(false);
-    console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);
+    // 🌐 Teil 3 (T3-3): ein Verteiler fuer beide Sprachen. Was heute nur ALLEIN gilt
+    // (`login`, `projekt liste`, `wache an` …), gilt auch weiterhin nur allein -- `kimal3 login
+    // extra` bleibt unbekannt. Der grosse Kommentar zur Nachsicht bei `wache --irgendwas` steht
+    // unten an `fuehreAus` und gilt unveraendert.
+    const erkannt = erkenneBefehl(argv);
+    if (erkannt) {
+        const code = await fuehreAus(erkannt.name, erkannt.rest);
+        if (code !== null)
+            return code;
+    }
+    console.error(`${ALLGEMEIN_TEXTE[sprache()].unknownCommand(wort)}${hilfeText(sprache())}`);
     return 1;
 }
 haupt()
@@ -564,10 +570,10 @@ haupt()
     // Node laeuft aus, sobald die Kanaele leer sind.
     .catch((f) => {
     if (f instanceof NichtAngemeldet) {
-        console.error("Bitte zuerst `kimal3 login` ausführen.");
+        console.error(ALLGEMEIN_TEXTE[sprache()].signInFirst);
         process.exitCode = 2;
         return;
     }
-    console.error("kimal3 ist gerade nicht erreichbar.");
+    console.error(ALLGEMEIN_TEXTE[sprache()].unreachable);
     process.exitCode = 3;
 });

package/dist/kontext-dateien.js

@@ -1,7 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { istUnsichererPfad } from "./arbeitsplatz-dateien.js";
-import { MERKZETTEL_PFAD, VERWALTETE_DATEIEN, arbeitsplatzAus, leseMerkzettel, schreibeMerkzettel, sicherungsZiel, } from "./kontext-stand.js";
+import { sprache as menschSprache } from "./sprache.js";
+import { KONTEXT_TEXTE } from "./texte/kontext.js";
+import { MERKZETTEL_PFAD, verwalteteDateien, arbeitsplatzAus, ORDNER_NAMEN, leseMerkzettel, schreibeMerkzettel, sicherungsZiel, } from "./kontext-stand.js";
 /**
  * Das Dateisystem hinter `kimal3 kontext runter` -- Ordner finden, die
  * verwalteten Dateien lesen, sichern, schreiben, den Merkzettel lesen und
@@ -23,13 +25,17 @@ import { MERKZETTEL_PFAD, VERWALTETE_DATEIEN, arbeitsplatzAus, leseMerkzettel, s
  * hier nie helfen kann. Ein Schreibfehler (Platte voll, `EACCES`) gibt
  * deshalb `1` zurueck, nicht `3`.
  */
-/** Ist `pfad` (relativ zu `wurzel`) ein lesbarer ORDNER? Unlesbar zaehlt als "nein". */
-function istLesbarerOrdner(pfad) {
+/**
+ * Die Namen der Eintraege (ohne Unterordner) in `pfad`. Fehlt der Ordner oder
+ * ist er unlesbar -> leere Liste: Ein Ordner, in den ich nicht hineinsehe,
+ * zaehlt wie einer ohne unsere Dateien (`arbeitsplatzAus`, Final-Review Fund 1).
+ */
+function namenIn(pfad) {
     try {
-        return existsSync(pfad) && statSync(pfad).isDirectory();
+        return readdirSync(pfad, { withFileTypes: true }).filter((e) => !e.isDirectory()).map((e) => e.name);
     }
     catch {
-        return false;
+        return [];
     }
 }
 /** Ist `pfad` (relativ zu `wurzel`) eine lesbare DATEI? Unlesbar zaehlt als "nein". */
@@ -59,8 +65,9 @@ export function findeArbeitsplatz(start) {
     for (let i = 0; i < 200; i++) {
         kandidaten.push({
             pfad: aktuell,
-            hatKontext: istLesbarerOrdner(join(aktuell, "kontext")),
-            hatClaude: istLesbareDatei(join(aktuell, "CLAUDE.md")),
+            kontextNamen: namenIn(join(aktuell, ORDNER_NAMEN.de.kontext)),
+            contextNamen: namenIn(join(aktuell, ORDNER_NAMEN.en.kontext)),
+            hatClaude: istLesbareDatei(join(aktuell, "CLAUDE.md")), // kein-anzeigetext: Dateiname
         });
         const eltern = dirname(aktuell);
         if (eltern === aktuell)
@@ -81,7 +88,7 @@ export function leseEineDatei(ordner, pfad) {
         if (!statSync(ort).isFile()) {
             return {
                 ok: false,
-                meldung: `„${pfad}" existiert, ist aber keine Datei -- ich fasse das nicht an. Bitte pruefen.`,
+                meldung: KONTEXT_TEXTE[menschSprache()].notAFile(pfad),
             };
         }
         return { ok: true, inhalt: readFileSync(ort, "utf8") };
@@ -89,8 +96,7 @@ export function leseEineDatei(ordner, pfad) {
     catch (fehler) {
         return {
             ok: false,
-            meldung: `Ich komme an „${pfad}" nicht heran: ${fehler instanceof Error ? fehler.message : String(fehler)}. ` +
-                "Das liegt an diesem Rechner, nicht am Server -- Rechte pruefen.",
+            meldung: KONTEXT_TEXTE[menschSprache()].cannotReach(pfad, fehler instanceof Error ? fehler.message : String(fehler)),
         };
     }
 }
@@ -120,7 +126,7 @@ export function schreibeMerkzettelDatei(ordner, m) {
     catch (fehler) {
         return {
             ok: false,
-            meldung: `Der Merkzettel liess sich nicht schreiben: ${fehler instanceof Error ? fehler.message : String(fehler)}. Das liegt an diesem Rechner, nicht am Server -- Platz und Rechte pruefen.`,
+            meldung: KONTEXT_TEXTE[menschSprache()].trackingFailed(fehler instanceof Error ? fehler.message : String(fehler)),
         };
     }
 }
@@ -180,7 +186,8 @@ function nummeriertesZiel(basisZielRel, nummer) {
     return [...teile, `${name}-${nummer}${endung}`].join("/");
 }
 /**
- * Die lokale Fassung von `pfad` nach `kontext/vorher-<datum>/` sichern --
+ * Die lokale Fassung von `pfad` nach `kontext/vorher-<datum>/` (englisch
+ * `context/before-<datum>/`) sichern --
  * FLACH, mit dem Basisnamen (`sicherungsZiel`), oder -- ist der schon belegt
  * -- unter einem durchnummerierten Namen DANEBEN (`naechstesFreiesSicherungsziel`,
  * Ruling T8-2).
@@ -194,8 +201,8 @@ function nummeriertesZiel(basisZielRel, nummer) {
  * Ausgabe unterscheiden (§8: kein Fehlerfall traegt den Namen eines
  * Erfolgsfalls, und hier sind es zwei verschiedene ECHTE Erfolgsfaelle).
  */
-export function sichereDatei(ordner, pfad, inhalt, datum) {
-    const basisZielRel = sicherungsZiel(datum, pfad);
+export function sichereDatei(ordner, pfad, inhalt, datum, sprache) {
+    const basisZielRel = sicherungsZiel(sprache, datum, pfad);
     const istBelegt = (zielRel) => existsSync(join(ordner, ...zielRel.split("/")));
     const zielRel = naechstesFreiesSicherungsziel(basisZielRel, istBelegt);
     const ort = join(ordner, ...zielRel.split("/"));
@@ -207,7 +214,7 @@ export function sichereDatei(ordner, pfad, inhalt, datum) {
     catch (fehler) {
         return {
             ok: false,
-            meldung: `Sichern von „${pfad}" ist fehlgeschlagen: ${fehler instanceof Error ? fehler.message : String(fehler)}. Das liegt an diesem Rechner, nicht am Server -- Platz und Rechte pruefen.`,
+            meldung: KONTEXT_TEXTE[menschSprache()].backupFailed(pfad, fehler instanceof Error ? fehler.message : String(fehler)),
         };
     }
 }
@@ -215,9 +222,9 @@ export function sichereDatei(ordner, pfad, inhalt, datum) {
  * Eine der verwalteten Dateien schreiben.
  *
  * 🔴 **Positivliste, keine Verbotsliste** (Auflage aus dem Brief): `pfad` muss
- * WOERTLICH einer der Eintraege aus `VERWALTETE_DATEIEN` sein, sonst wird
+ * WOERTLICH einer der Eintraege aus `verwalteteDateien(sprache)` sein, sonst wird
  * NICHTS geschrieben. Diese Funktion bekommt `pfad` im echten Ablauf immer aus
- * der eigenen Iteration ueber `VERWALTETE_DATEIEN` (nie roh aus der Server-
+ * der eigenen Iteration ueber `verwalteteDateien(sprache)` (nie roh aus der Server-
  * Antwort) -- die Pruefung hier ist trotzdem ausdruecklich verlangt und bleibt
  * als zweites Netz stehen, falls sich der Aufrufer einmal aendert.
  *
@@ -226,12 +233,12 @@ export function sichereDatei(ordner, pfad, inhalt, datum) {
  * einer Server-Antwort, und eine Pruefung, die nur dort gilt, wo man sie
  * gerade braucht, ist keine Pruefung dieser Funktion.
  */
-export function schreibeVerwalteteDatei(ordner, pfad, inhalt) {
-    if (!VERWALTETE_DATEIEN.includes(pfad)) {
-        return { ok: false, meldung: `„${pfad}" ist keine verwaltete Datei -- wird nicht geschrieben. Bitte melden.` };
+export function schreibeVerwalteteDatei(ordner, pfad, inhalt, sprache) {
+    if (!verwalteteDateien(sprache).includes(pfad)) {
+        return { ok: false, meldung: KONTEXT_TEXTE[menschSprache()].notManaged(pfad) };
     }
     if (istUnsichererPfad(pfad)) {
-        return { ok: false, meldung: `„${pfad}" ist kein sicherer Pfad -- wird nicht geschrieben. Bitte melden.` };
+        return { ok: false, meldung: KONTEXT_TEXTE[menschSprache()].notSafePath(pfad) };
     }
     const ort = join(ordner, ...pfad.split("/"));
     try {
@@ -242,7 +249,7 @@ export function schreibeVerwalteteDatei(ordner, pfad, inhalt) {
     catch (fehler) {
         return {
             ok: false,
-            meldung: `Schreiben von „${pfad}" ist fehlgeschlagen: ${fehler instanceof Error ? fehler.message : String(fehler)}. Das liegt an diesem Rechner, nicht am Server -- Platz und Rechte pruefen.`,
+            meldung: KONTEXT_TEXTE[menschSprache()].writeFailed(pfad, fehler instanceof Error ? fehler.message : String(fehler)),
         };
     }
 }

package/dist/kontext-hoch-zeile.js

@@ -1,11 +1,13 @@
+import { KONTEXT_HOCH_TEXTE } from "./texte/kontext-hoch.js";
 /**
  * Die Erfolgszeile von `kimal3 kontext hoch` -- als reine Rechnung, damit
  * `check:cli` sie prueft. Sie nennt, was sich BEI DER FIRMA geaendert hat,
  * nicht, was gesendet wurde (B-e, 29.08.: fuenf Dateien genannt, zwei
  * geaendert, eine davon ohne Zutun des Menschen).
  */
-export function hochZeile(uebernommen) {
+export function hochZeile(uebernommen, s) {
+    const t = KONTEXT_HOCH_TEXTE[s];
     if (uebernommen.length === 0)
-        return "✓ nichts geändert — alles war schon so";
-    return `✓ geändert bei der Firma: ${uebernommen.join(", ")}`;
+        return t.nothingChanged;
+    return t.changedAtCompany(uebernommen.join(", "));
 }

package/dist/kontext-rat.js

@@ -0,0 +1,151 @@
+import { befehlIn } from "./befehlswoerter.js";
+import { KONTEXT_TEXTE } from "./texte/kontext.js";
+import { FIRMEN_CLAUDE_MD, ORDNER_NAMEN, firmenTexte, verwalteteDateien } from "./kontext-stand.js";
+/*
+  Der Rat nach `kimal3 kontext runter`, wenn Dateien in Ruhe gelassen wurden (Teil 3, Task 10).
+
+  🔑 **Umgezogen aus `kontext-stand.ts`.** Diese Datei hat die Sätze des Rats verlassen -- sie
+  gehören jetzt in `texte/kontext.ts`, in beiden Sprachen --, und `kontext-stand.ts` darf nichts
+  importieren (die App liest sie über den Bundler). Was die Logik angeht, ist alles geblieben:
+  welche Art Rat eine Datei bekommt, in welcher Reihenfolge, und dass jede verwaltete Datei einen
+  bekommt. Die Kommentare darunter stammen unverändert von dort.
+
+  🔴 **ZWEI Sprachen, zwei Pflichtwerte** (Messung h): `ordner` bestimmt die PFADE im Rat
+  (`context/profile.md` heißt so, weil der Ordner so heißt), `sprache` bestimmt die SÄTZE und die
+  Befehlswörter darin. Bis Teil 3 war der Rat immer deutsch -- im englischen Ordner mit englischen
+  Pfaden --, weil das Programm nur Deutsch sprach; die Sprache des Menschen kennt er erst seit
+  jetzt. Beide Werte sind Pflicht, kein Vorgabewert: Wer nur einen nennt, bekommt die zweite
+  Sprache nicht still dazu.
+*/
+/**
+ * Die ARTEN von Rat, die es gibt -- **in der Reihenfolge, in der sie im
+ * Terminal stehen.**
+ *
+ * 🔑 Diese Liste ist zugleich die Quelle des Typs {@link RatArt}. Wer eine
+ * dritte Art erfindet, muss sie hier eintragen -- und bekommt danach vom
+ * Compiler gesagt, dass {@link RAT_TEXT} noch keinen Text dafuer hat. *Eine
+ * Reihenfolge, die nebenher den Typ traegt, kann nicht unvollstaendig sein.*
+ *
+ * ⚠️ Die Reihenfolge ist nicht Geschmack: `kimal3 kontext runter` druckt seit
+ * Befund F-3 erst den Rat fuer die Firmen-Texte und darunter den fuer unsere
+ * Vorlage. Wer sie dreht, dreht die Ausgabe beim Kunden.
+ */
+const RAT_REIHENFOLGE = ["hochschickbar", "nicht-hochschickbar"];
+/**
+ * 🔴 **PUNKT A-7 (2026-08-26): DIESE TABELLE IST DIE ABSICHERUNG, NICHT NUR
+ * EINE AUFRAEUMAKTION.**
+ *
+ * Bis hierher zaehlte {@link ratNachUnberuehrt} ihre Faelle auf: ein `if` fuer
+ * „irgendetwas aus den Firmen-Texten" und ein zweites fuer den woertlichen
+ * Dateinamen `"CLAUDE.md"`. {@link verwalteteDateien} hat aber SECHS
+ * Eintraege, und eine kuenftige SIEBTE waere durch beide `if`s gefallen --
+ * ohne Fehler, ohne Meldung, ohne Rat. *Der Mensch haette gelesen, dass seine
+ * Datei in Ruhe gelassen wurde, und nirgends, was er jetzt tun soll.*
+ *
+ * 🔑 **Teil 2 (2026-10-01): aus der Tabelle `RAT_ART_JE_DATEI` wurde diese
+ * Funktion.** Die Tabelle hatte als Schluessel die sechs deutschen Pfade --
+ * mit `context/company.md` daneben haette sie zwei Saetze Schluessel
+ * gebraucht, die nur gemeinsam stimmen. Die Regel dahinter war immer nur eine:
+ * Die Firmen-`CLAUDE.md` traegt `kontext hoch` nicht, alles andere schon.
+ *
+ * ⚠️ **Was dabei verloren ging, ehrlich:** Der `Record` war eine Absicherung
+ * des Compilers -- eine siebte verwaltete Datei haette ihm einen Schluessel
+ * zu wenig gegeben. Jetzt bekommt eine siebte Datei still den Rat
+ * `hochschickbar`. Das ist nie „kein Rat" (der Fall, gegen den A-7 gebaut
+ * war), aber es waere der falsche, wenn die siebte Datei ebenfalls nicht
+ * hochgeschickt werden kann. Halten tut das jetzt allein die Pruefung in
+ * `check:kontext` unten.
+ *
+ * ⚠️ **Sie sagt dasselbe wie {@link firmenTexte}, und das ist eine
+ * Doppelung** -- gehalten wird sie von einer Pruefung in `check:kontext`
+ * („der `hoch`-Rat geht an genau die Dateien, die `kontext hoch` wirklich
+ * traegt"). Die konnte vor A-7 gar nicht rot werden, weil der Rat SELBST aus
+ * der Liste der Firmen-Texte entstand; jetzt sind es zwei Quellen, und ihr
+ * Auseinanderlaufen ist messbar.
+ */
+function ratArt(pfad) {
+    return pfad === FIRMEN_CLAUDE_MD ? "nicht-hochschickbar" : "hochschickbar";
+}
+/**
+ * Der Wortlaut je Art und Rolle.
+ *
+ * 🔑 Die Saetze selbst stehen seit Teil 3 in `texte/kontext.ts` (mit echten Umlauten -- das
+ * liest ein Kunde).
+ *
+ * 🔑 `wer` ist die fertige Anrede (` an Lena` oder ` an euren Firmen-Admin`, englisch ` to Lena`),
+ * damit der Rueckfall auf den Sammelbegriff an EINER Stelle steht und nicht in
+ * jedem Zweig neu. Ruling T7-1: nie `null` im Klartext.
+ */
+const RAT_TEXT = {
+    hochschickbar: (rolle, wer, _namen, t, b) => (rolle === "admin" ? t.adviceUploadAdmin(b.hoch) : t.adviceUploadMember(wer, b.hoch)),
+    /*
+      🔴 **Auch dieser Zweig kennt die ROLLE -- Punkt A-5, 2026-08-26.** Er tat
+      es bis dahin nicht und riet jedem dasselbe: „Aendere sie dort", also im
+      Formular unter Firma → Kontext. Ein MITGLIED kann das nicht. `kimal3
+      kontext hoch` weist es ab, und den Firmenkontext der Firma darf es in der
+      App nicht schreiben. *Ein Rat, der die Lage nicht aendern kann, ist keiner*
+      -- er schickt einen Menschen an eine Tuer, vor der er keinen Schluessel
+      hat, und laesst ihn den Fehler bei sich suchen.
+  
+      🔑 Was das Mitglied stattdessen liest: WAS es weitergeben soll (die drei
+      Saetze aus `kontext/kurzprofil.md`) und AN WEN -- genau die Form, die der
+      Zweig fuer die fuenf `kontext/`-Dateien oben schon hat.
+    */
+    "nicht-hochschickbar": (rolle, wer, namen, t, b) => rolle === "admin"
+        ? t.adviceFileAdmin(namen.kontext, namen.kurzprofil, b.hoch, b.runter)
+        : t.adviceFileMember(namen.kontext, namen.kurzprofil, wer, b.hoch),
+};
+/**
+ * Was ein Mensch lesen soll, wenn `kimal3 kontext runter` Dateien in Ruhe
+ * laesst, weil er sie lokal geaendert hat -- je nach Rolle und je nach DATEI.
+ *
+ * 🔴 **DAS IST FUND F, ZUM ZWEITEN MAL -- und diesmal die echte Fassung
+ * (Review-Befund F-3, 2026-08-25).** Der Rat lautete fuer die ganze Liste auf
+ * einmal: „Deine Fassung ist die neuere? Dann schick sie hoch: kimal3 kontext
+ * hoch". Fuer `CLAUDE.md` ist dieser Satz eine Sackgasse: Sie steht in
+ * {@link verwalteteDateien} und landet deshalb in der Liste -- aber
+ * `kontext hoch` liest ausschliesslich die fuenf Dateien aus
+ * {@link firmenTexte} und meldet danach Erfolg, ohne sie. *Der Mensch tippt
+ * den geratenen Befehl, sieht einen Haken, und seine Aenderung steht weiter
+ * allein auf seiner Platte.*
+ *
+ * 🔑 Die ausgelieferte `CLAUDE.md` laedt diese Bearbeitung foermlich ein: Sie
+ * sagt selbst, aendern muesse man sie nur, wenn sich die Firma aendert.
+ *
+ * 🔴 **Der Rat wohnt hier und nicht im Befehl, damit ihn eine Wache sehen
+ * kann.** Die spurious Fassung desselben Fehlers (`merkzettelNachHoch`) war
+ * behoben, die echte lag vier Runden lang offen -- *ein Satz ueber das
+ * Verhalten eines Befehls wohnte im Befehl selbst, wo keine Vorlagen-Wache je
+ * hinsieht.* `check:kontext` prueft jetzt genau diese Zuordnung.
+ *
+ * 🔴 **PUNKT A-7 (2026-08-26): DER RAT WIRD ERZEUGT, NICHT AUFGEZAEHLT.** Diese
+ * Funktion hatte zwei `if`s -- eines fuer „irgendetwas aus
+ * {@link firmenTexte}", eines fuer den woertlichen Namen `"CLAUDE.md"`. Eine
+ * siebte verwaltete Datei waere durch beide gefallen und haette schweigend gar
+ * keinen Rat bekommen. Jetzt laeuft die Schleife ueber
+ * {@link verwalteteDateien} selbst und fragt {@link ratArt} nach der Art --
+ * jede Datei bekommt einen Rat.
+ *
+ * ⚠️ **Eine ART, ein Satz -- auch wenn drei ihrer Dateien betroffen sind.** Das
+ * war vorher so (ein `if` feuerte einmal) und bleibt so: Der Rat spricht ueber
+ * den Weg, nicht ueber die einzelne Datei; dreimal derselbe Absatz waere
+ * Laerm.
+ */
+export function ratNachUnberuehrt(unberuehrt, rolle, adminName, ordner, sprache) {
+    const t = KONTEXT_TEXTE[sprache];
+    // Ruling T7-1: kein `null` im Klartext, sondern der Sammelbegriff.
+    const wer = adminName ? t.toPerson(adminName) : t.toCompanyAdmin;
+    // Befehlswoerter in der Sprache des Satzes (befehlIn), nicht in der des Ordners.
+    const befehle = { hoch: befehlIn("kontext hoch", sprache), runter: befehlIn("kontext runter", sprache) }; // kein-anzeigetext: Befehlsschlüssel
+    const betroffeneArten = new Set();
+    for (const pfad of verwalteteDateien(ordner)) {
+        if (unberuehrt.includes(pfad))
+            betroffeneArten.add(ratArt(pfad));
+    }
+    // 🔑 Die Reihenfolge kommt aus RAT_REIHENFOLGE, NICHT aus der Einfuegereihen-
+    // folge des `Set` -- sonst haenge die Ausgabe beim Kunden davon ab, in
+    // welcher Reihenfolge verwalteteDateien(ordner) zufaellig steht.
+    // Die PFADE im Rat heissen so, wie sie in DIESEM Ordner heissen (L-19) -- die SAETZE folgen dem Menschen.
+    const namen = { kontext: ORDNER_NAMEN[ordner].kontext, kurzprofil: firmenTexte(ordner)[0].pfad };
+    return RAT_REIHENFOLGE.filter((art) => betroffeneArten.has(art)).map((art) => RAT_TEXT[art](rolle, wer, namen, t, befehle));
+}