kimal3 0.4.0-durchstich.1 → 0.4.0

package/dist/befehle/login.js

@@ -5,6 +5,7 @@ import { sprache } from "../sprache.js";
 import { anmeldeAdresse, oeffneImBrowser } from "../browser.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
 import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
+import { frischeCoachAuf } from "../coach-ablegen.js";
 import { stelleSkillUm } from "./skill-tausch.js";
 const warte = (ms) => new Promise((f) => setTimeout(f, ms));
 // 🌐 Die Sprache wird bei JEDER Ausgabe neu gelesen: Die Abhol-Antwort nennt die Kontosprache
@@ -27,7 +28,13 @@ export async function login() {
     console.log(t().loginOpen(BASIS_URL));
     console.log(t().loginEnterCode(start.nutzerCode));
     console.log(t().loginWaiting);
-    return warteAufBestaetigung(start.geraeteCode);
+    const code = await warteAufBestaetigung(start.geraeteCode);
+    // Der Coach zieht mit der Kontosprache mit -- nur beim BEFEHL `kimal3 login`, nicht in der geteilten Warteschleife:
+    // `einrichten` meldet anschließend seinen eigenen Coach, eine zweite Zeile wäre doppelt (Gesamt-Durchsicht, Fund 4;
+    // dasselbe Muster wie `skillInstallBefehl`). Frischt nur auf, legt nie an (Spec C-13b).
+    if (code === 0)
+        frischeCoachAuf(sprache());
+    return code;
 }
 /**
  * Die Anmeldung für `kimal3 einrichten` (Spec 2026-10-11, S-2): Code und Adresse auf eigenen

package/dist/befehle/skill-install.js

@@ -3,12 +3,13 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 import { einstellungenDatei, trageWacheEin } from "../einstellungen-schreiben.js";
-import { merkeSitzung, sitzungJetzt } from "../wache-schalter.js";
+import { merkeEinrichtung, sitzungJetzt } from "../wache-schalter.js";
 import { stempelZeile } from "../nachricht.js";
 import { eigeneVersion } from "../version.js";
 import { sprache } from "../sprache.js";
 import { andereSpracheZuRaeumen, skillQuelle } from "../slash-befehle.js";
 import { SKILL_TEXTE } from "../texte/skill.js";
+import { frischeCoachAuf } from "../coach-ablegen.js";
 export const VERALTETE_BEFEHLE = [
     /*
       🔴 **Der ERSTE Eintrag ueberhaupt** (2026-08-28). `/k3firma` heisst jetzt
@@ -286,8 +287,10 @@ export async function skillInstall() {
           taegliche Pruefung laeuft nicht" -- ausgerechnet in dem Augenblick, in
           dem er sie gerade eingerichtet hat. *Der erste Eindruck waere ein
           Fehlalarm.*
+          ⚠️ Als EINRICHTUNG, nicht als "nachgesehen" -- sonst schweigt die Wache in
+          dieser Sitzung auch beim Neustart (Sandbox-Lauf 14.10., S-3; `merkeEinrichtung`).
         */
-        merkeSitzung(sitzungJetzt());
+        merkeEinrichtung(sitzungJetzt());
     }
     if (wache.art === "eingetragen") {
         console.log(t.watchSetUp);
@@ -318,6 +321,17 @@ export async function skillInstall() {
     }
     return 0;
 }
+/**
+ * Der Befehl `kimal3 skill install`: die Anleitung ablegen und einen VORHANDENEN Coach mitziehen (Update, Sprachwechsel;
+ * angelegt wird keiner). Bewusst hier und nicht in `skillInstall()`: `einrichten` ruft das auch, hat seinen Coach aber
+ * schon selbst abgelegt und gemeldet -- ein zweites Auffrischen druckte dessen Zeile noch einmal (bei fehlender
+ * Trenn-Marke auch die Ersatzdatei ein zweites Mal).
+ */
+export async function skillInstallBefehl() {
+    const code = await skillInstall();
+    frischeCoachAuf(sprache());
+    return code;
+}
 /**
  * Kopiert die Slash-Befehle nach `~/.claude/commands/`.
  *

package/dist/befehle-katalog-en.js

@@ -118,6 +118,18 @@ export const BEFEHLE_EN = {
             "What it's really for: Claude looks here BEFORE adding a project. Without that check, the same project would sooner or later appear twice on a public page that carries your name.",
         ],
     },
+    "kimal3 kurs": {
+        stempel: "3a5c7600",
+        befehl: "kimal3 course",
+        tippen: "/k3course",
+        terminal: "kimal3 course",
+        beschreibung: "Show where you are in the mini-course",
+        rhythmusOderSatz: "where am I in the course",
+        details: [
+            "Shows which parts you have finished, what is next and what is still open — and for each step whether you tick it off or Claude sets it.",
+            "Claude reads this when you come back to the course and picks up exactly where you left off.",
+        ],
+    },
     "kimal3 firma daten": {
         stempel: "3195364c",
         befehl: "kimal3 company data",

package/dist/befehle-katalog.js

@@ -167,6 +167,18 @@ export const BEFEHLE = [
             "Wofür es wirklich da ist: Claude schaut hier VOR dem Eintragen nach. Ohne diesen Blick stünde dasselbe Projekt irgendwann zweimal auf einer öffentlichen Seite, die deinen Namen trägt.",
         ],
     },
+    {
+        befehl: "kimal3 kurs",
+        beschreibung: "Zeigen, wo du im Mini-Kurs stehst",
+        wer: "claude",
+        ausloeser: "wo stehe ich im Kurs",
+        tippen: "/k3kurs",
+        terminal: "kimal3 kurs",
+        details: [
+            "Zeigt, welche Beats du fertig hast, was als Nächstes dran ist und was noch offen ist — und bei jedem Schritt, ob du ihn abhakst oder Claude ihn setzt.",
+            "Claude liest das, wenn du in den Kurs zurückkehrst, und macht genau dort weiter, wo du aufgehört hast.",
+        ],
+    },
     {
         befehl: "kimal3 firma daten",
         beschreibung: "Die Daten deiner Firma holen, damit Claude sie auswerten kann",

package/dist/befehlswoerter.js

@@ -11,6 +11,7 @@ export const BEFEHLSWOERTER = {
     "projekt neu": { de: "projekt neu", en: "project new" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "projekt liste": { de: "projekt liste", en: "project list" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "firma daten": { de: "firma daten", en: "company data" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
+    kurs: { de: "kurs", en: "course" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     wache: { de: "wache", en: "watch" },
     "wache an": { de: "wache an", en: "watch on" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     "wache aus": { de: "wache aus", en: "watch off" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
@@ -56,6 +57,9 @@ export const SCHALTER_EN = {
     impact: "wirkung",
     "impact-label": "wirkung-label",
     "live-since": "live-seit",
+    // `kimal3 einrichten` / `setup` (Spec 2026-10-16, Bauform 6)
+    workplace: "arbeitsplatz",
+    workbench: "werkbank",
 };
 /** `company` -> `firma`; ein deutscher (oder unbekannter) Name bleibt, wie er ist. */
 export function deutscherSchalter(getippt) {

package/dist/coach-ablegen.js

@@ -0,0 +1,130 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { coachNachher } from "./coach-rechnung.js";
+import { COACH_TEXTE } from "./texte/coach.js";
+/**
+ * Der Coach im Regel-Ordner (Spec 2026-10-16): Claude Code lädt jede Datei in `~/.claude/rules/` bei jedem Start mit,
+ * in jedem Ordner -- dort wirkt er, ohne dass `~/.claude/CLAUDE.md` angefasst wird (die gehört dem Menschen).
+ * Was in der Datei steht, rechnet `coach-rechnung.ts` (rein, bewacht von `check:wache`); hier wird nur gelesen und
+ * geschrieben. Gemessen am gebauten Programm von `check:cli-live`.
+ */
+export const coachPfad = () => join(homedir(), ".claude", "rules", "kimal3-coach.md"); // kein-anzeigetext: Dateiname
+/** Fehlt die Trenn-Marke, landet die neue Fassung HIER -- außerhalb des Regel-Ordners, sonst lüden zwei Coaches (UX-10). */
+export const coachErsatzPfad = () => join(homedir(), ".kimal3", "kimal3-coach-neu.md"); // kein-anzeigetext: Dateiname
+/** Der Coach aus dem alten Mini-Kurs, und wohin Claude ihn nach einem Ja verschiebt (S-14) -- `kimal3` schreibt ihn nie. */
+export const alterKursCoachPfad = () => join(homedir(), ".claude", "CLAUDE.md"); // kein-anzeigetext: Dateiname
+export const alterKursCoachAblage = () => join(homedir(), ".kimal3", "alter-kurs-coach.md"); // kein-anzeigetext: Dateiname
+/**
+ * Legt den Coach ab oder frischt ihn auf. `null` = es liegt keiner da, und dieser Aufruf darf keinen anlegen
+ * (nur `einrichten` darf das; `skill install` und `login` frischen nur auf).
+ * 🔑 Wirft nie: Jeder Lese- oder Schreibfehler wird `gescheitert` mit der Meldung des Systems -- die Einrichtung läuft
+ * weiter (C-10), und der Mensch erfährt den Grund statt einer Stapelspur.
+ */
+export function legeCoachAb(s, darfAnlegen) {
+    const pfad = coachPfad();
+    try {
+        const da = statSync(pfad, { throwIfNoEntry: false });
+        // Ein Ordner unter dem Namen gehört nicht uns -- nichts anfassen, wie bei einer fremden Datei (C-11).
+        if (da !== undefined && !da.isFile())
+            return { art: "fremd", pfad, spracheGewechselt: false };
+        if (da === undefined && !darfAnlegen)
+            return null;
+        // Die Vorlage erst NACH dem `null`: Wer keinen Coach hat, soll von `login` und `skill install` auch dann nichts hören,
+        // wenn die Vorlage im Paket fehlt (Gesamt-Durchsicht, Fund 6).
+        // `dist/coach-ablegen.js` -> `../coach/<sprache>/…` im installierten Paket (`files` in package.json).
+        const vorlage = readFileSync(fileURLToPath(new URL(`../coach/${s}/kimal3-coach.md`, import.meta.url)), "utf8"); // kein-anzeigetext: Paketpfad
+        const ergebnis = coachNachher(da === undefined ? null : readFileSync(pfad, "utf8"), vorlage);
+        switch (ergebnis.art) {
+            case "neu":
+                mkdirSync(dirname(pfad), { recursive: true });
+                tauscheEin(pfad, ergebnis.inhalt);
+                return { art: "angelegt", pfad, spracheGewechselt: false };
+            case "aktualisiert":
+                tauscheEin(pfad, ergebnis.inhalt);
+                return { art: "aktualisiert", pfad, spracheGewechselt: ergebnis.spracheVorher !== null && ergebnis.spracheVorher !== s };
+            case "ohne-trenner": {
+                // Das Original bleibt Byte für Byte (C-8): Ohne Trenn-Marke wüssten wir nicht, wo seine Regeln anfangen.
+                const ersatz = coachErsatzPfad();
+                mkdirSync(dirname(ersatz), { recursive: true });
+                writeFileSync(ersatz, ergebnis.inhalt, "utf8");
+                return { art: "ohne-trenner", pfad, ersatz };
+            }
+            case "vorlage-ohne-trenner":
+                return { art: "gescheitert", pfad, grund: COACH_TEXTE[s].templateWithoutSeparator };
+            default:
+                return { art: ergebnis.art, pfad, spracheGewechselt: false };
+        }
+    }
+    catch (e) {
+        return { art: "gescheitert", pfad, grund: e.message };
+    }
+}
+/**
+ * Erst in eine Nebendatei, dann tauschen (Durchsicht Aufgabe 5, Fund 1): `writeFileSync` leert die Datei, BEVOR es
+ * schreibt -- bei voller Platte wären die gelernten Regeln weg, und der nächste Lauf hielte den leeren Rest für fremd.
+ * 🔑 `kimal3-coach.md.neu` endet nicht auf `.md`: Claude lädt sie nie als zweiten Coach, auch wenn sie liegen bliebe.
+ * Scheitert ein Schritt, kommt die Nebendatei weg (ein Ordner unter dem Namen ist nicht unserer und bleibt), und der
+ * Fehler geht an `legeCoachAb`, das ihn zu `gescheitert` macht.
+ */
+function tauscheEin(pfad, inhalt) {
+    const neben = `${pfad}.neu`; // kein-anzeigetext: Dateiname
+    try {
+        writeFileSync(neben, inhalt, "utf8");
+        renameSync(neben, pfad);
+    }
+    catch (e) {
+        try {
+            rmSync(neben);
+        }
+        catch {
+            // Lag nie da, oder es ist ein Ordner -- dann nichts anfassen.
+        }
+        throw e;
+    }
+}
+/** Liegt unter dem Coach-Pfad eine DATEI (unsere oder eine fremde)? Daran hängt `beat2-coach` (E-5, E-9). Wirft nie. */
+export function coachDateiLiegt() {
+    try {
+        return statSync(coachPfad(), { throwIfNoEntry: false })?.isFile() === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Die eine Zeile zu einer Ablage, in der Sprache des Laufs -- für `einrichten` (Task 5), `skill install` und `login`.
+ * `sprachwechselSagen`: Nur `login` und `skill install` sagen einen Sprachwechsel mit eigenem Satz (Spec 2.6) -- er
+ * sagt, was der Mensch dort sonst nicht merkt: dass seine Regeln den Wechsel überlebt haben. `einrichten` bleibt bei der
+ * Zeile mit `Coach:`, an der die Anleitung liest. Welche Fälle ein Aufruf verschweigt (`gleich`, `fremd` beim
+ * Auffrischen), entscheidet der Aufrufer.
+ */
+export function meldeCoach(ablage, s, sprachwechselSagen = false) {
+    if (ablage === null)
+        return;
+    const t = COACH_TEXTE[s];
+    if (ablage.art === "angelegt")
+        console.log(t.setUp(ablage.pfad));
+    else if (ablage.art === "gleich")
+        console.log(t.upToDate);
+    else if (ablage.art === "aktualisiert")
+        console.log(sprachwechselSagen && ablage.spracheGewechselt ? t.languageSwitched : t.updated);
+    else if (ablage.art === "fremd")
+        console.log(t.foreign(ablage.pfad));
+    else if (ablage.art === "ohne-trenner")
+        console.log(t.noSeparator(ablage.pfad, ablage.ersatz));
+    else if (ablage.art === "gescheitert")
+        console.log(t.failed(ablage.grund));
+}
+/**
+ * Für `skill install` und `login`: einen VORHANDENEN Coach auffrischen (Update, Sprachwechsel), nie einen anlegen --
+ * das darf nur `einrichten` (Spec C-13b: Auffrischen ist kein Anlegen). Schweigt, wenn nichts zu sagen ist: kein Coach,
+ * ein fremder, ein schon aktueller. Ein Sprachwechsel bekommt seinen eigenen Satz (Spec 2.6).
+ */
+export function frischeCoachAuf(s) {
+    const ablage = legeCoachAb(s, false);
+    if (ablage === null || ablage.art === "gleich" || ablage.art === "fremd")
+        return;
+    meldeCoach(ablage, s, true);
+}

package/dist/coach-rechnung.js

@@ -0,0 +1,40 @@
+// Ein BOM (U+FEFF) vor der ersten Zeile setzen manche Windows-Editoren; er gehört nicht zur Marke.
+const KOPF = /^\uFEFF?<!-- kimal3:coach/;
+const KOPF_SPRACHE = /^\uFEFF?<!-- kimal3:coach sprache=(de|en)(?![A-Za-z])/;
+// Nur am ZEILENANFANG, ohne Einrückung: Die Kopfzeile nennt die Trenn-Marke im Fließtext, und eine gelernte Regel darf
+// es auch. 🔑 Exportiert, weil `check:cli` die Vorlagen mit GENAU diesem Ausdruck prüft -- eine eigene, nachsichtigere
+// Erkennung dort ließe eine eingerückte Marke grün durch, die diese Rechnung nicht findet (Gesamt-Durchsicht, Fund 3).
+export const TRENNER = /^<!-- kimal3:gelernte-regeln/m;
+const ALTER_KURS_COACH = /^\uFEFF?# CLAUDE\.md — (Dein Claude-Coach|Your Claude coach)/;
+export const istUnserCoach = (inhalt) => KOPF.test(inhalt);
+export function coachSprache(inhalt) {
+    const treffer = KOPF_SPRACHE.exec(inhalt);
+    return treffer ? treffer[1] : null;
+}
+// Der Kurs-Coach von früher (Beat 2 des Mini-Kurses) beginnt mit dieser Überschrift, deutsch wie englisch.
+export const istAlterKursCoach = (inhalt) => ALTER_KURS_COACH.test(inhalt);
+// Alles bis einschließlich des Zeilenendes der ersten Trenn-Zeile (\n oder \r\n -- das \r steht vor dem \n und
+// gehört damit zur Zeile). Ohne Zeilenende danach reicht die Zeile bis zum Dateiende. -1 = keine Trenn-Zeile.
+function obenBis(text) {
+    const treffer = TRENNER.exec(text);
+    if (!treffer)
+        return -1;
+    const umbruch = text.indexOf("\n", treffer.index);
+    return umbruch === -1 ? text.length : umbruch + 1;
+}
+export function coachNachher(vorher, vorlage) {
+    const vorlageEnde = obenBis(vorlage);
+    if (vorlageEnde === -1)
+        return { art: "vorlage-ohne-trenner" };
+    if (vorher === null)
+        return { art: "neu", inhalt: vorlage };
+    if (!istUnserCoach(vorher))
+        return { art: "fremd" };
+    const altEnde = obenBis(vorher);
+    if (altEnde === -1)
+        return { art: "ohne-trenner", inhalt: vorlage };
+    const neu = vorlage.slice(0, vorlageEnde) + vorher.slice(altEnde);
+    if (neu === vorher)
+        return { art: "gleich" };
+    return { art: "aktualisiert", inhalt: neu, spracheVorher: coachSprache(vorher) };
+}

package/dist/einstellungen-mischen.js

@@ -18,6 +18,8 @@ export const WACHE_MARKE = "kimal3 wache"; // kein-anzeigetext: Startbefehl in C
  * Der Befehl, der in die Einstellungen eingetragen wird.
  *
  * 🔴 NUR EIN BEFEHL, keine Kommandozeilen-Zeichen -- kein `||`, kein `2>/dev/null`.
+ * 📌 Die eine Ausnahme seit dem 15.10.: Auf Mac und Linux steht `PATH="…" ` davor (`wacheBefehl` unten). Dort
+ * startet Claude Code Startbefehle immer über `sh -c`, und `sh` kennt diese Form; unter Windows bleibt er bloß.
  * Das sind Bash-Zeichen, und ob auf dem Kundenrechner eine Bash laeuft, wissen
  * wir nicht. Die Fehlerbehandlung gehoert ins Programm, nicht in die Zeile.
  * *Ein Befehl, der beim Erbauer laeuft, ist keine Aussage ueber den Rechner
@@ -38,6 +40,31 @@ export const WACHE_MARKE = "kimal3 wache"; // kein-anzeigetext: Startbefehl in C
  * AUCH BEI RUECKGABEWERT 127 gelesen (ebenfalls gemessen).
  */
 export const WACHE_BEFEHL = `${WACHE_MARKE} --hook`; // kein-anzeigetext: Startbefehl in Claudes Einstellungen, bleibt deutsch (T3-5)
+/**
+ * Der Startbefehl, wie er auf DIESEM Rechner eingetragen wird. Auf Mac und Linux stehen die Ordner davor, in denen
+ * `kimal3` und Node.js liegen (`ordner`, doppelte nur einmal).
+ * 🔑 Warum beide: `kimal3` liegt dort, wo npm Programme ablegt -- beim Mac-Weg `~/.kimal3/node/bin`, bei Homebrew
+ * `/opt/homebrew/bin`; Node.js selbst liegt bei Homebrew im versionierten Ordner darunter. Ein `kimal3` in einem
+ * eigenen npm-Ordner braucht zusätzlich den Ordner von Node.js für seine erste Zeile (`#!/usr/bin/env node`).
+ *
+ * 🔑 WARUM: Startbefehle laufen mit Claudes eigener Umgebung über `sh -c` und lesen weder `~/.zprofile`
+ * noch `~/.zshrc` (code.claude.com/docs/en/hooks, gelesen 15.10.). Liegt Node.js im Benutzerordner
+ * (`~/.kimal3/node`, der Mac-Weg ohne Adminrechte) und wurde Claude aus dem Dock gestartet, fände `sh`
+ * weder `kimal3` noch das `node` aus dessen erster Zeile -- und die Wache schwiege, ohne dass es jemand merkt.
+ * Unter Windows bleibt es beim bloßen Befehl: Dort steht Node.js im Pfad des Systems, und die Wache läuft
+ * dort seit Wochen so.
+ * 🔴 Nur Zeichen aus einer kurzen Liste kommen in den Befehl (messen-und-pruefen §23); alles andere
+ * -- ein Anführungszeichen, ein `$` -- gäbe einen Befehl, den `sh` anders liest. Ein solcher Ordner fällt weg; bleibt
+ * keiner übrig, steht der bloße Befehl da.
+ */
+export function wacheBefehl(system, ordner) {
+    // Ein Wegwerf-Ort fällt weg (Durchsicht 4, Fund 4): `npx kimal3 …` startet aus einem Zwischenspeicher, der bald
+    // verschwindet, ein Start aus einem Projektordner aus dessen `node_modules`.
+    const sicher = [...new Set(ordner)].filter((o) => /^\/[A-Za-z0-9 ._@+\/-]*$/.test(o) && !/\/(node_modules|_npx)\//.test(`${o}/`));
+    if (system === "win32" || sicher.length === 0)
+        return WACHE_BEFEHL;
+    return `PATH="${sicher.join(":")}:$PATH" ${WACHE_BEFEHL}`; // kein-anzeigetext: Startbefehl in Claudes Einstellungen
+}
 /**
  * Wie lange Claude auf die Wache wartet, in Sekunden.
  *
@@ -48,9 +75,45 @@ export const WACHE_BEFEHL = `${WACHE_MARKE} --hook`; // kein-anzeigetext: Startb
  * seiner Arbeit ab -- und ausgerechnet unserer soll ihm helfen.*
  */
 export const WACHE_ZEITGRENZE = 10;
-function istObjekt(wert) {
+export function istObjekt(wert) {
     return typeof wert === "object" && wert !== null && !Array.isArray(wert);
 }
+/**
+ * Die Einstellungsdatei als Objekt -- oder die Absage. Gemeinsam fuer die Wache und die Plugins
+ * (`plugins-mischen.ts`), damit beide eine kaputte Datei gleich behandeln: nicht anfassen.
+ */
+export function leseEinstellungen(alt) {
+    /*
+      Eine fehlende und eine leere Datei sind dasselbe: Es gibt nichts zu
+      bewahren, also legen wir an. `null` kommt vom Aufrufer, wenn die Datei gar
+      nicht existiert; ein leerer Text entsteht, wenn ein frueherer Lauf sie
+      angelegt, aber nicht mehr befuellt hat.
+    */
+    const leer = alt === null || alt.trim() === "";
+    if (leer)
+        return { ok: true, objekt: {}, leer };
+    let gelesen;
+    try {
+        // Eine unsichtbare Kennung am Anfang (UTF-8-BOM, z. B. von PowerShell 5.1 geschrieben) macht die
+        // Datei nicht kaputt -- `JSON.parse` stolpert aber darüber (QA-Fund 3 zum Bauplan 2026-10-15).
+        gelesen = JSON.parse(alt.replace(/^\uFEFF/, ""));
+    }
+    catch {
+        /*
+          🔴 HIER WIRD NICHTS GESCHRIEBEN. Wer eine unlesbare Einstellungsdatei
+          ueberschreibt, wirft weg, was der Mensch dort stehen hat -- und
+          ausgerechnet der Fall, in dem sie schon beschaedigt ist, ist der, in
+          dem er sie am dringendsten braucht. Die Absage geht nach oben, der
+          Mensch erfaehrt sie.
+        */
+        return { ok: false, grund: "kein-gueltiges-json" };
+    }
+    // Eine Liste oder eine blosse Zahl ist gueltiges JSON, aber keine
+    // Einstellungsdatei. Das ist ein DRITTER Fall, nicht der zweite.
+    if (!istObjekt(gelesen))
+        return { ok: false, grund: "fremde-form" };
+    return { ok: true, objekt: gelesen, leer };
+}
 /**
  * Ist das ein Eintrag, den WIR frueher einmal geschrieben haben?
  *
@@ -75,33 +138,10 @@ function istUnserer(eintrag) {
     return typeof eintrag.command === "string" && eintrag.command.includes(WACHE_MARKE);
 }
 export function mischeEinstellungen(alt, befehl) {
-    /*
-      Eine fehlende und eine leere Datei sind dasselbe: Es gibt nichts zu
-      bewahren, also legen wir an. `null` kommt vom Aufrufer, wenn die Datei gar
-      nicht existiert; ein leerer Text entsteht, wenn ein frueherer Lauf sie
-      angelegt, aber nicht mehr befuellt hat.
-    */
-    const leer = alt === null || alt.trim() === "";
-    let gelesen = {};
-    if (!leer) {
-        try {
-            gelesen = JSON.parse(alt);
-        }
-        catch {
-            /*
-              🔴 HIER WIRD NICHTS GESCHRIEBEN. Wer eine unlesbare Einstellungsdatei
-              ueberschreibt, wirft weg, was der Mensch dort stehen hat -- und
-              ausgerechnet der Fall, in dem sie schon beschaedigt ist, ist der, in
-              dem er sie am dringendsten braucht. Die Absage geht nach oben, der
-              Mensch erfaehrt sie.
-            */
-            return { art: "abgelehnt", grund: "kein-gueltiges-json" };
-        }
-    }
-    // Eine Liste oder eine blosse Zahl ist gueltiges JSON, aber keine
-    // Einstellungsdatei. Das ist ein DRITTER Fall, nicht der zweite.
-    if (!istObjekt(gelesen))
-        return { art: "abgelehnt", grund: "fremde-form" };
+    const lesen = leseEinstellungen(alt);
+    if (!lesen.ok)
+        return { art: "abgelehnt", grund: lesen.grund };
+    const { objekt: gelesen, leer } = lesen;
     const vorher = JSON.stringify(gelesen);
     const hooks = gelesen.hooks === undefined ? {} : gelesen.hooks;
     if (!istObjekt(hooks))

package/dist/einstellungen-schreiben.js

@@ -1,7 +1,8 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { WACHE_BEFEHL, mischeEinstellungen } from "./einstellungen-mischen.js";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { mischeEinstellungen, wacheBefehl } from "./einstellungen-mischen.js";
+import { KATALOG, mischePlugins, pluginStand } from "./plugins-mischen.js";
 /** Die Kontrolle nach dem Schreiben fand unseren Eintrag nicht -- eigener Fall, damit `detail` `null` sein kann. */
 class EintragFehlt extends Error {
 }
@@ -12,6 +13,41 @@ export function sicherungsDatei() {
     return einstellungenDatei() + ".kimal3-sicherung";
 }
 export function trageWacheEin() {
+    // Vor den Befehl kommen der Ordner, aus dem `kimal3` gerade gestartet wurde (dort legt npm es ab; bei Homebrew liegt
+    // dort auch `node`), und der Ordner des laufenden Node.js (für ein `kimal3` in einem eigenen npm-Ordner) -- Durchsicht 3, Fund 2.
+    const befehl = wacheBefehl(platform(), [dirname(process.argv[1] ?? ""), dirname(process.execPath)]);
+    return trageEin((alt) => mischeEinstellungen(alt, befehl), (text) => text.includes(JSON.stringify(befehl)), sicherungsDatei());
+}
+/**
+ * Die Kopie, die die Plugins vor dem Schreiben anlegen. Eine eigene, weil `kimal3 einrichten` die Plugins
+ * VOR der Wache einträgt: So hält diese Kopie Sabines unveränderte Datei (Prüfer-Fund 9 zum Bauplan 2026-10-15).
+ */
+export function pluginSicherungsDatei() {
+    return einstellungenDatei() + ".kimal3-sicherung-plugins";
+}
+/**
+ * superpowers und das Logo eintragen (`plugins-mischen.ts`); `katalogPfad` mit Schrägstrichen vorwärts,
+ * `null` ohne Logo-Ordner. 🔑 Die Kontrolle liest die Einschalter selbst, nicht nur Katalogname und Pfad:
+ * Fehlte ein Einschalter, meldete die Zeile `Plugins:` sonst „eingetragen“ für etwas, das nie lädt
+ * (Durchsicht 2, Fund 7). „Von Sabine ausgeschaltet“ zählt als da -- es steht ja drin.
+ */
+export function tragePluginsEin(katalogPfad, mitSuperpowers) {
+    return trageEin((alt) => mischePlugins(alt, katalogPfad, mitSuperpowers), (text) => {
+        const stand = pluginStand(text);
+        if (mitSuperpowers && stand.superpowers === "fehlt")
+            return false;
+        return katalogPfad === null || (stand.logo !== "fehlt" && text.includes(`"${KATALOG}"`) && text.includes(JSON.stringify(katalogPfad)));
+    }, pluginSicherungsDatei());
+}
+/**
+ * Der Vier-Schritte-Weg fuer jeden Eintrag in Claudes Einstellungen -- die Wache und die Plugins
+ * (`plugins-mischen.ts`) gehen denselben, damit keiner von beiden ohne Sicherung schreibt.
+ * `kontrolle` bekommt den zurueckgelesenen Text und sagt, ob unser Eintrag drinsteht.
+ */
+export function trageEin(mische, kontrolle, 
+// 🔑 Je Schreiber eine eigene Kopie: Schrieben Wache und Plugins in dieselbe, überschriebe die zweite
+// Sabines Originaldatei mit dem Stand nach dem ersten Eintrag (QA-Fund 9).
+sicherung) {
     const datei = einstellungenDatei();
     const gabEsSchon = existsSync(datei);
     // --- Schritt 1: lesen ---
@@ -30,15 +66,15 @@ export function trageWacheEin() {
             return { art: "gescheitert", schritt: "lesen", detail: e.message };
         }
     }
-    const ergebnis = mischeEinstellungen(alt, WACHE_BEFEHL);
+    const ergebnis = mische(alt);
     if (ergebnis.art === "abgelehnt")
         return { art: "abgelehnt", grund: ergebnis.grund };
     if (ergebnis.art === "unveraendert")
-        return { art: "stand-schon" };
+        return { art: "stand-schon", inhalt: alt ?? "" };
     // --- Schritt 2: Sicherungskopie ---
     if (gabEsSchon) {
         try {
-            copyFileSync(datei, sicherungsDatei());
+            copyFileSync(datei, sicherung);
         }
         catch (e) {
             /*
@@ -55,22 +91,22 @@ export function trageWacheEin() {
         writeFileSync(datei, ergebnis.inhalt, "utf8");
     }
     catch (e) {
-        zurueck(gabEsSchon);
+        zurueck(gabEsSchon, sicherung);
         return { art: "gescheitert", schritt: "schreiben", detail: e.message };
     }
     // --- Schritt 4: zuruecklesen und erneut pruefen ---
     try {
         const zurueckgelesen = readFileSync(datei, "utf8");
         const geparst = JSON.parse(zurueckgelesen);
-        if (!zurueckgelesen.includes(WACHE_BEFEHL) || geparst === null) {
+        if (!kontrolle(zurueckgelesen) || geparst === null) {
             throw new EintragFehlt();
         }
     }
     catch (e) {
-        zurueck(gabEsSchon);
+        zurueck(gabEsSchon, sicherung);
         return { art: "gescheitert", schritt: "kontrolle", detail: e instanceof EintragFehlt ? null : e.message };
     }
-    return { art: "eingetragen" };
+    return { art: "eingetragen", inhalt: ergebnis.inhalt };
 }
 /**
  * Die Sicherung zurueckspielen.
@@ -79,11 +115,11 @@ export function trageWacheEin() {
  * bleibt die halb geschriebene stehen. Das ist die harmlose Seite: Sie
  * enthielt vorher nichts, was jemandem gehoerte.
  */
-function zurueck(gabEsSchon) {
+function zurueck(gabEsSchon, sicherung) {
     if (!gabEsSchon)
         return;
     try {
-        copyFileSync(sicherungsDatei(), einstellungenDatei());
+        copyFileSync(sicherung, einstellungenDatei());
     }
     catch {
         /* Mehr koennen wir nicht tun -- der Grund steht in der Meldung oben. */

package/dist/kimal3.js

@@ -33,9 +33,10 @@ 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 { kurs } from "./befehle/kurs.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
-import { skillDatei, skillInstall } from "./befehle/skill-install.js";
+import { skillDatei, skillInstallBefehl } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
 /** Eine Meldung pro Programmlauf -- s. "Einmal-Riegel" im Block darunter. */
 let schonGemeldet = false;
@@ -480,9 +481,10 @@ async function fuehreAus(name, rest) {
     switch (name) {
         case "login": return allein ? login() : null;
         case "logout": return allein ? logout() : null;
-        case "skill install": return allein ? skillInstall() : null;
+        case "skill install": return allein ? skillInstallBefehl() : null;
         case "projekt neu": return projektNeu(rest);
         case "projekt liste": return allein ? projektListe() : null;
+        case "kurs": return allein ? kurs() : null;
         // ⚠️ Rest wird durchgereicht, nicht auf Gleichheit geprueft: `firma daten --firma X` gehoert dazu.
         case "firma daten": return firmaDaten(rest);
         case "einrichten": return einrichten(rest);
@@ -495,7 +497,8 @@ async function fuehreAus(name, rest) {
         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).
+            // eingetragen wird immer `kimal3 wache --hook`, auf Mac/Linux mit `PATH="…"` davor -- `wacheBefehl`;
+            // `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")