kimal3 0.3.2 → 0.4.0-durchstich.3

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

@@ -20,11 +20,12 @@ import { WACHE_TEXTE } from "./texte/wache.js";
 import { leseWacheDatei, sitzungJetzt, wacheAusgefallen } from "./wache-schalter.js";
 import { formatiere, heuteAus, skillZustand, sollZeigen, } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
-import { sprache } from "./sprache.js";
+import { merkeBefehlsSprache, sprache } from "./sprache.js";
 import { ALLGEMEIN_TEXTE } from "./texte/allgemein.js";
 import { hilfeText } from "./hilfe.js";
-import { erkenneBefehl } from "./befehlswoerter.js";
+import { BEFEHLSWOERTER, erkenneBefehl } from "./befehlswoerter.js";
 import { arbeitsplatzNeu } from "./befehle/arbeitsplatz.js";
+import { einrichten } from "./befehle/einrichten.js";
 import { werkbankNeu } from "./befehle/werkbank.js";
 import { firmaDaten } from "./befehle/firma-daten.js";
 import { kontextFragen } from "./befehle/kontext-fragen.js";
@@ -484,6 +485,7 @@ async function fuehreAus(name, 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 "einrichten": return einrichten(rest);
         case "arbeitsplatz neu": return arbeitsplatzNeu(rest);
         case "werkbank neu": return werkbankNeu(rest);
         case "kontext runter": return kontextRunter(rest);
@@ -493,7 +495,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")
@@ -537,6 +540,10 @@ async function haupt() {
     // extra` bleibt unbekannt. Der grosse Kommentar zur Nachsicht bei `wache --irgendwas` steht
     // unten an `fuehreAus` und gilt unveraendert.
     const erkannt = erkenneBefehl(argv);
+    // 🌐 `setup` spricht Englisch, `einrichten` Deutsch, solange keine Kontosprache gemerkt ist --
+    // die Anleitung, die den Befehl tippt, liest seine Marken (Begruendung an `startSprache`).
+    if (erkannt?.name === "einrichten")
+        merkeBefehlsSprache(argv[0] === BEFEHLSWOERTER.einrichten.en ? "en" : "de");
     if (erkannt) {
         const code = await fuehreAus(erkannt.name, erkannt.rest);
         if (code !== null)

package/dist/logo-ablegen.js

@@ -0,0 +1,117 @@
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Legt den Plugin-Katalog mit dem Logo-Mod in `~/.kimal3/claude-plugins` ab und setzt dort die
+ * Sprache des Kontos. Claude Code liest den Mod aus genau diesem Ordner (Katalog `kimal3`,
+ * `plugins-mischen.ts`).
+ *
+ * 🔑 Warum ein fester Ordner im Benutzerordner und nicht der Ordner im installierten npm-Paket:
+ * Der hängt am Installationsort von Node.js und wechselt mit ihm -- der Eintrag in Claudes
+ * Einstellungen zeigte dann ins Leere.
+ * 🔑 Der Ordner gehört `kimal3` (seine README sagt es): Jeder Lauf ersetzt ihn ganz (Lage P-11).
+ */
+export function katalogOrdner() {
+    return join(homedir(), ".kimal3", "claude-plugins"); // kein-anzeigetext: Ordnername
+}
+/** Die Zeile im Mod, die die Sprache festlegt -- `check:logo` prüft, dass es sie genau einmal gibt. */
+export const SPRACH_ZEILE = "const SPRACHE: 'de' | 'en' = 'de'"; // kein-anzeigetext: Quelltext des Mods
+/** Reine Rechnung: der Mod-Text in der Sprache des Kontos, oder `null`, wenn die Zeile fehlt. */
+export function mitSprache(quelltext, sprache) {
+    if (quelltext.split(SPRACH_ZEILE).length !== 2)
+        return null;
+    return quelltext.replace(SPRACH_ZEILE, `const SPRACHE: 'de' | 'en' = '${sprache}'`); // kein-anzeigetext: Quelltext des Mods
+}
+/**
+ * 🔴 NIE EIN HALBER ORDNER (Durchsicht-Funde 2 und 9): Claudes Einstellungen zeigen auf `katalogOrdner()`,
+ * und eine laufende Claude-Sitzung hat den Mod daraus geladen. Deshalb:
+ *   1. Sprache setzen, BEVOR irgendetwas angefasst wird -- fehlt die Zeile, bleibt alles, wie es war.
+ *   2. Steht schon genau das da, was entstehen soll: nichts anfassen (Lage P-8). Das ist auch der Normalfall
+ *      eines zweiten Laufs, und so kommt er gar nicht erst in die Nähe der Windows-Sperren unten.
+ *   3. Den neuen Ordner daneben fertig bauen (`….neu`), dann tauschen: alten Ordner wegschieben, neuen an
+ *      seinen Platz, alten löschen.
+ * 🔑 Der weggeschobene Ordner bekommt bei JEDEM Lauf einen frischen Namen (Durchsicht 2, Funde 2 und 4):
+ * Ein Rest, den Windows festhält, blockiert so keinen späteren Lauf, und zurückgeholt wird nur, was
+ * DIESER Lauf weggeschoben hat -- nie ein veralteter Rest von früher.
+ * Lässt sich der alte nicht wegschieben (Claude hält ihn manchmal fest), bleibt er unversehrt stehen und
+ * gilt weiter: ein Erfolg mit `alterStand`, den `kimal3 einrichten` in einer Zeile nennt.
+ */
+export function logoAblegen(sprache) {
+    // `dist/logo-ablegen.js` -> `../claude-plugins` im installierten Paket (`files` in package.json).
+    const quelle = fileURLToPath(new URL("../claude-plugins", import.meta.url));
+    const ziel = katalogOrdner();
+    const neu = `${ziel}.neu`; // kein-anzeigetext: Ordnername
+    const modDatei = (ordner) => join(ordner, "kimal3-logo", "hooks", "register.tsx");
+    try {
+        const text = mitSprache(readFileSync(modDatei(quelle), "utf8"), sprache);
+        if (text === null)
+            return { ok: false, detail: modDatei(quelle) };
+        if (stehtSchonDa(quelle, ziel, text)) {
+            // Auch im Normalfall aufräumen, samt einem halb gebauten `….neu`: sonst blieben Reste für immer (Durchsicht 3/4).
+            rmSync(neu, { recursive: true, force: true });
+            resteWegraeumen(ziel);
+            return { ok: true, ordner: ziel };
+        }
+        rmSync(neu, { recursive: true, force: true });
+        cpSync(quelle, neu, { recursive: true });
+        writeFileSync(modDatei(neu), text, "utf8");
+        if (!existsSync(ziel)) {
+            renameSync(neu, ziel);
+            return { ok: true, ordner: ziel };
+        }
+        const alt = `${ziel}.alt-${Date.now()}`; // kein-anzeigetext: Ordnername
+        try {
+            renameSync(ziel, alt);
+        }
+        catch {
+            rmSync(neu, { recursive: true, force: true });
+            return { ok: true, ordner: ziel, alterStand: true };
+        }
+        try {
+            renameSync(neu, ziel);
+        }
+        catch (e) {
+            renameSync(alt, ziel);
+            return { ok: false, detail: e.message };
+        }
+        resteWegraeumen(ziel);
+        return { ok: true, ordner: ziel };
+    }
+    catch (e) {
+        return { ok: false, detail: e.message };
+    }
+}
+/** Gleiche Dateien, gleicher Inhalt -- der Mod mit der Sprache des Kontos, alles andere wie im Paket. */
+function stehtSchonDa(quelle, ziel, modText) {
+    if (!existsSync(ziel))
+        return false;
+    const dateien = (ordner) => alleDateien(ordner).sort();
+    const soll = dateien(quelle);
+    if (JSON.stringify(soll) !== JSON.stringify(dateien(ziel)))
+        return false;
+    const mod = join("kimal3-logo", "hooks", "register.tsx");
+    return soll.every((d) => (d === mod ? Buffer.from(modText, "utf8") : readFileSync(join(quelle, d))).equals(readFileSync(join(ziel, d))));
+}
+/**
+ * Alle Dateien unter `ordner`, als Pfade relativ dazu. 🔑 Von Hand statt `readdirSync(…, { recursive: true })`: Das kann
+ * Node.js erst ab 20.1, und unter 20.0 fände der Vergleich gar keine Datei -- „gleich“, und das Logo würde nie erneuert
+ * (Durchsicht 3, Fund 7; `engines` erlaubt 20).
+ */
+function alleDateien(ordner, unter = "") {
+    return readdirSync(join(ordner, unter), { withFileTypes: true }).flatMap((e) => e.isDirectory() ? alleDateien(ordner, join(unter, e.name)) : e.isFile() ? [join(unter, e.name)] : []);
+}
+/** Weggeschobene Ordner früherer Läufe (`claude-plugins.alt…`); was Windows noch festhält, bleibt bis zum nächsten Lauf. */
+function resteWegraeumen(ziel) {
+    const name = `${basename(ziel)}.alt`; // kein-anzeigetext: Ordnername
+    for (const eintrag of readdirSync(dirname(ziel))) {
+        if (!eintrag.startsWith(name))
+            continue;
+        try {
+            rmSync(join(dirname(ziel), eintrag), { recursive: true, force: true });
+        }
+        catch {
+            /* festgehalten -- der nächste Lauf versucht es wieder */
+        }
+    }
+}

package/dist/nachricht.js

@@ -259,10 +259,14 @@ export function stempelZeile(version, sprache) {
 }
 /**
  * Die Sprache des LETZTEN Stempels (wie `stempelAus`: ein Beispiel im Text darf nicht gewinnen).
+ *
+ * 🔴 Die Vorabfassung (`0.4.0-durchstich.1`) trägt einen Zusatz hinter den Zahlen -- ohne `(?:-…)?`
+ * fand das Muster bei ihr die Sprache nie, jeder englische Stempel galt als deutsch, und der Login
+ * stellte nichts mehr um (gemessen von `check:cli-live` L1/L6 beim Task 7 des Durchstichs).
  * Ohne Zusatz -- und bei jedem anderen Zusatz als genau `en` -- Deutsch (T4-4).
  */
 export function stempelSpracheAus(inhalt) {
-    const treffer = [...inhalt.matchAll(/kimal3:erzeugt version=[0-9][0-9.]*(?: sprache=([a-z]+))?/g)];
+    const treffer = [...inhalt.matchAll(/kimal3:erzeugt version=[0-9][0-9.]*(?:-[0-9A-Za-z.]+)?(?: sprache=([a-z]+))?/g)];
     return treffer.length > 0 && treffer[treffer.length - 1][1] === "en" ? "en" : "de";
 }
 /**

package/dist/plugins-mischen.js

@@ -0,0 +1,78 @@
+import { istObjekt, leseEinstellungen } from "./einstellungen-mischen.js";
+/**
+ * Traegt superpowers und das KImal3-Logo in Claudes Einstellungen ein -- als Katalog plus
+ * Einschalter, so wie Anthropic Firmen-Mods auf jeden Rechner verteilt (Bauplan 2026-10-15,
+ * „Warum anders als die Spec"). Beim naechsten Start laedt Claude Code beides selbst.
+ *
+ * 🔴 DIESE DATEI FASST KEINE DATEI AN -- dieselbe Bauform wie `einstellungen-mischen.ts`, aus
+ * demselben Grund: In `~/.claude/settings.json` steht der Arbeitsplatz des Menschen.
+ * Geschrieben wird ueber `einstellungen-schreiben.ts` (Sicherung, Zuruecklesen).
+ */
+export const KATALOG = "kimal3"; // kein-anzeigetext: Name des Plugin-Katalogs in Claudes Einstellungen
+export const LOGO = `kimal3-logo@${KATALOG}`; // kein-anzeigetext: Plugin-Kennung
+const OFFIZIELL = "claude-plugins-official"; // kein-anzeigetext: Anthropics Katalog
+export const SUPERPOWERS = `superpowers@${OFFIZIELL}`; // kein-anzeigetext: Plugin-Kennung
+/**
+ * 🔑 Jede Entscheidung des Menschen bleibt stehen (Lagen P-5 bis P-7, P-10):
+ * - Ein Eintrag fuer das Logo -- auch `false` -- heisst: Er hat schon entschieden. Wir setzen
+ *   nur, was fehlt.
+ * - superpowers aus IRGENDEINEM Katalog (`superpowers@…`, an oder aus) heisst: nicht noch eins.
+ *   Zwei superpowers gaeben jede Faehigkeit doppelt.
+ * - Den offiziellen Katalog tragen wir nur ein, wenn er fehlt und wir superpowers einschalten.
+ * Nur der Katalog `kimal3` gehoert uns: Er zeigt immer auf unseren Ordner (P-9, Umzug).
+ * 🔑 `katalogPfad` ist `null`, wenn der Logo-Ordner nicht angelegt werden konnte: Dann bleiben Katalog und
+ * Logo-Eintrag, wie sie sind, und superpowers kommt trotzdem -- es braucht den Ordner nicht (Durchsicht 2, Fund 1).
+ * 🔑 `mitSuperpowers` ist `false`, wenn Git fehlt: Claude Code klont Anthropics Katalog mit Git und scheiterte sonst bei
+ * jedem Start (Durchsicht 3, Fund 5). Was schon drinsteht, bleibt -- auch ein früher eingetragenes superpowers.
+ */
+export function mischePlugins(alt, katalogPfad, mitSuperpowers = true) {
+    const lesen = leseEinstellungen(alt);
+    if (!lesen.ok)
+        return { art: "abgelehnt", grund: lesen.grund };
+    const { objekt, leer } = lesen;
+    const kataloge = objekt.extraKnownMarketplaces ?? {};
+    const plugins = objekt.enabledPlugins ?? {};
+    if (!istObjekt(kataloge) || !istObjekt(plugins))
+        return { art: "abgelehnt", grund: "fremde-form" };
+    // Nur die Quelle gehört uns; was Claude Code selbst in den Eintrag schreibt (`autoUpdate`, wenn
+    // Sabine es unter /plugin umschaltet), bleibt stehen (QA-Fund 7). Zeigt die Quelle schon auf unseren
+    // Ordner, bleibt der Eintrag Zeichen für Zeichen, wie er ist -- auch in anderer Reihenfolge der
+    // Schlüssel; sonst schriebe jeder Lauf die Datei neu (Durchsicht-Fund 6, Lage P-8).
+    const alterEintrag = istObjekt(kataloge[KATALOG]) ? kataloge[KATALOG] : {};
+    const alteQuelle = istObjekt(alterEintrag.source) ? alterEintrag.source : {};
+    const zeigtSchonHin = alteQuelle.source === "directory" && alteQuelle.path === katalogPfad;
+    const neueKataloge = { ...kataloge };
+    const neuePlugins = { ...plugins };
+    if (katalogPfad !== null) {
+        neueKataloge[KATALOG] = zeigtSchonHin ? alterEintrag : { ...alterEintrag, source: { source: "directory", path: katalogPfad } };
+        if (!(LOGO in plugins))
+            neuePlugins[LOGO] = true;
+    }
+    if (mitSuperpowers && !Object.keys(plugins).some((k) => k.startsWith("superpowers@"))) {
+        neuePlugins[SUPERPOWERS] = true;
+        if (!(OFFIZIELL in kataloge)) {
+            neueKataloge[OFFIZIELL] = { source: { source: "github", repo: "anthropics/claude-plugins-official" } };
+        }
+    }
+    const neu = { ...objekt, extraKnownMarketplaces: neueKataloge, enabledPlugins: neuePlugins };
+    // Wie bei der Wache: Wer nichts zu tun hat, fasst die Datei nicht an (P-8).
+    if (!leer && JSON.stringify(neu) === JSON.stringify(objekt))
+        return { art: "unveraendert" };
+    return { art: "geschrieben", inhalt: JSON.stringify(neu, null, 2) + "\n" };
+}
+/**
+ * Was nach dem Eintragen wirklich gilt -- fuer die Zeile `Plugins:`, die Claude der Kundin weitersagt.
+ * 🔑 Aus der Datei gelesen, nicht aus dem, was wir eingetragen haben: Hat sie superpowers selbst
+ * ausgeschaltet, muss die Zeile das sagen, damit die Anleitung sie nicht ins Menue schickt (Durchsicht-Fund 1).
+ */
+export function pluginStand(inhalt) {
+    const lesen = leseEinstellungen(inhalt);
+    const plugins = lesen.ok ? lesen.objekt.enabledPlugins : undefined;
+    if (!istObjekt(plugins))
+        return { superpowers: "fehlt", logo: "fehlt" };
+    const superpowers = Object.entries(plugins).filter(([k]) => k.startsWith("superpowers@")).map(([, v]) => v);
+    return {
+        superpowers: superpowers.includes(true) ? "an" : superpowers.length > 0 ? "aus" : "fehlt",
+        logo: plugins[LOGO] === true ? "an" : LOGO in plugins ? "aus" : "fehlt",
+    };
+}

package/dist/sprache.js

@@ -40,11 +40,21 @@ export function spracheAusSystem(gebiet) {
     return klein === "en" || klein.startsWith("en-") ? "en" : "de";
 }
 /**
- * Die Sprache beim Start (T3-2): Merkzettel -> sonst Deutsch, wenn schon eine Anmeldung liegt
- * (wer von einer aelteren Fassung aktualisiert: Sabine mit englischem Windows sah bisher immer
- * Deutsch) -> sonst das Betriebssystem.
+ * Die Sprache beim Start (T3-2): die Sprache des getippten Befehlsworts, wo es eine traegt ->
+ * sonst der Merkzettel -> sonst Deutsch, wenn schon eine Anmeldung liegt (wer von einer aelteren
+ * Fassung aktualisiert: Sabine mit englischem Windows sah bisher immer Deutsch) -> sonst das
+ * Betriebssystem.
+ *
+ * 🔑 DAS BEFEHLSWORT GANZ VORN (Durchstich, Gesamtpruefung Punkt 3 und Review a73305f, Befund 1):
+ * `kimal3 setup` tippt nur die englische Anleitung, und die wartet auf `Sign-in code:`. Jim mit
+ * englischem Konto und deutschem Windows bekam sonst `Anmelde-Code:`. Auch VOR dem Merkzettel:
+ * Der uebersteht `logout` -- meldet Jim auf Kemals Laptop erst Kemal ab, laege dort Kemals
+ * Deutsch. Gilt nur bis zur ersten Antwort des Servers; ab da die Kontosprache
+ * (`uebernimmKontosprache`).
  */
 export function startSprache(lage) {
+    if (lage.befehlsSprache !== null)
+        return lage.befehlsSprache;
     const gemerkt = alsSprache(lage.merkzettel);
     if (gemerkt !== null)
         return gemerkt;
@@ -78,12 +88,24 @@ function leseMerkzettel() {
 }
 let gemerkt;
 let aktuell = null;
+let befehlsSprache = null;
+/**
+ * Der Verteiler meldet hier die Sprache des getippten Befehlsworts -- nur fuer `einrichten`/`setup`,
+ * den einen Befehl, den eine Anleitung auf einem frischen Rechner aufruft und dessen Ausgabe sie
+ * liest. Er laeuft vor der ersten Ausgabe; `aktuell` wird trotzdem verworfen, damit die Reihenfolge
+ * nicht stillschweigend daran haengt.
+ */
+export function merkeBefehlsSprache(s) {
+    befehlsSprache = s;
+    aktuell = null;
+}
 /** Die Sprache dieses Laufs. */
 export function sprache() {
     if (aktuell === null) {
         gemerkt = leseMerkzettel();
         aktuell = startSprache({
             merkzettel: gemerkt,
+            befehlsSprache,
             angemeldet: leseAnmeldung() !== null,
             systemGebiet: Intl.DateTimeFormat().resolvedOptions().locale,
         });
@@ -97,10 +119,12 @@ export function sprache() {
  */
 export function uebernimmKontosprache(kopf) {
     sprache();
+    // 🔑 `aktuell` folgt dem Kopf auch dann, wenn der Merkzettel schon dieselbe Sprache traegt --
+    // sonst bliebe ein Lauf, der mit dem Befehlswort begann (`setup` bei deutschem Konto), englisch.
+    aktuell = alsSprache(kopf) ?? aktuell;
     const neu = nachAntwort(gemerkt, kopf);
     if (neu === null)
         return;
-    aktuell = neu;
     gemerkt = neu;
     try {
         // ⚠️ `mode: 0o700` wie in anmeldung.ts und gesehen.ts -- wer den Ordner zuerst anlegt, legt

package/dist/texte/einrichten-marken.js

@@ -0,0 +1,9 @@
+/**
+ * Die Zeilenanfaenge, an denen Claude die Ausgabe von `kimal3 einrichten` liest
+ * (Anleitung `/einrichten` und `/setup`, Schritt 3). Eine Stelle fuer beide: Das
+ * Programm druckt sie, die Anleitung nennt sie, `check:kurs` haelt beide gleich.
+ */
+export const EINRICHTEN_MARKEN = {
+    de: { code: "Anmelde-Code:", adresse: "Adresse:", arbeitsplatz: "Arbeitsplatz:", werkbank: "Werkbank:", angemeldet: "Angemeldet als", plugins: "Plugins:" },
+    en: { code: "Sign-in code:", adresse: "Address:", arbeitsplatz: "Workplace:", werkbank: "Workbench:", angemeldet: "Signed in as", plugins: "Plugins:" },
+};

package/dist/texte/einrichten.js

@@ -0,0 +1,60 @@
+import { EINRICHTEN_MARKEN } from "./einrichten-marken.js";
+const M = EINRICHTEN_MARKEN;
+const de = {
+    codeLine: (code) => `\n  ${M.de.code} ${code}`,
+    addressLine: (url) => `  ${M.de.adresse} ${url}`,
+    browserOpened: "  Ich öffne die Seite gerade in deinem Browser. Bestätige dort nur, wenn derselbe Code dasteht.",
+    browserNotOpened: "  Öffne die Adresse oben in deinem Browser. Bestätige dort nur, wenn derselbe Code dasteht.",
+    help: "\n  kimal3 einrichten [--firma \"Name\" | --firma-id \"…\"]\n\n  Meldet dich an (der Browser öffnet sich mit deinem Code), legt deinen\n  KI-Arbeitsplatz in deinem Benutzerordner an, richtet die /k3-Befehle und\n  die Wache ein und hakt die Schritte im Kurs ab. Ein zweiter Lauf ergänzt\n  nur, was fehlt.\n",
+    start: "\nIch richte deinen KI-Arbeitsplatz ein.",
+    filesWritten: (neu, schonDa) => `\n✓ ${neu} Dateien angelegt, ${schonDa} lagen schon da.`,
+    workplaceLine: (pfad) => `  ${M.de.arbeitsplatz} ${pfad}`,
+    workbenchLine: (name) => `  ${M.de.werkbank} ${name}`,
+    courseMarked: "✓ Im Kurs abgehakt.",
+    courseNotMarked: "  Die Haken im Kurs konnte ich gerade nicht setzen — der nächste Lauf holt das nach.",
+    done: "\n✓ Fertig eingerichtet.",
+    unsafeFolder: (name) => `Der Server hat einen Ordnernamen geschickt, den ich nicht anlege: ${name}. Bitte melde das an kimal3.`,
+    noWorkbank: "In der Lieferung steckt keine Werkbank. Bitte melde das an kimal3.",
+    // Plugins (Bauplan 2026-10-15): Claude liest die Zeile und sagt der Kundin, was nach dem Neustart erscheint.
+    logoName: "KImal3-Logo",
+    // `an`: eingeschaltet · `aus`: von ihr selbst ausgeschaltet (bleibt so, die Anleitung schickt sie dann nicht ins Menü)
+    // · `neu`: gerade eingetragen (kommt mit dem Neustart) oder stand schon da (Durchsicht-Funde 1 und 7).
+    pluginsLine: (an, aus, neu) => `  ${M.de.plugins} ${an.length > 0 ? `${an.join(", ")} — ${neu ? "erscheinen, sobald Claude ganz beendet und neu geöffnet ist" : "sind schon eingetragen"}.` : "nichts eingeschaltet."}` +
+        (aus.length > 0 ? ` Selbst ausgeschaltet, bleibt aus: ${aus.join(", ")}.` : ""),
+    pluginsNotWritten: (grund) => `  ${M.de.plugins} nicht eingetragen — ${grund}`,
+    settingsInvalid: "deine Claude-Einstellungen (~/.claude/settings.json) sind kein gültiges JSON. Ich habe sie nicht angefasst.",
+    settingsForeign: "in deinen Claude-Einstellungen (~/.claude/settings.json) steht etwas in einer Form, die ich nicht kenne. Ich habe sie nicht angefasst.",
+    settingsFailed: (ursache) => `deine Claude-Einstellungen (~/.claude/settings.json): ${ursache}.`,
+    // Logo (Durchsicht 2, Funde 1 und 3): Scheitert der Ordner, kommt superpowers trotzdem; hält Claude ihn fest, gilt die alte Fassung.
+    logoNotWritten: (detail) => `  Den Ordner für das KImal3-Logo konnte ich nicht anlegen oder erneuern (${detail}).`,
+    // Ohne Git kein superpowers (Durchsicht 3, Fund 5); die Anleitung zitiert den Anfang dieser Zeile.
+    superpowersNeedsGit: "  superpowers braucht Git — es kommt mit dem nächsten `kimal3 einrichten`, sobald Git da ist.",
+    logoOldVersion: "  Das KImal3-Logo bleibt vorerst in der bisherigen Fassung, weil Claude den Ordner gerade benutzt. Beende Claude ganz und starte danach `kimal3 einrichten` noch einmal.",
+};
+const en = {
+    codeLine: (code) => `\n  ${M.en.code} ${code}`,
+    addressLine: (url) => `  ${M.en.adresse} ${url}`,
+    browserOpened: "  Opening the page in your browser now. Only confirm there if it shows the same code.",
+    browserNotOpened: "  Open the address above in your browser. Only confirm there if it shows the same code.",
+    help: "\n  kimal3 setup [--company \"Name\" | --company-id \"…\"]\n\n  Signs you in (your browser opens with your code), creates your AI Workplace\n  in your user folder, sets up the /k3 commands and the watch, and ticks off\n  the course steps. A second run only adds what is missing.\n",
+    start: "\nSetting up your AI Workplace.",
+    filesWritten: (neu, schonDa) => `\n✓ ${neu} files created, ${schonDa} were already there.`,
+    workplaceLine: (pfad) => `  ${M.en.arbeitsplatz} ${pfad}`,
+    workbenchLine: (name) => `  ${M.en.werkbank} ${name}`,
+    courseMarked: "✓ Ticked off in the course.",
+    courseNotMarked: "  I couldn't tick off the course steps just now — the next run will catch up.",
+    done: "\n✓ All set up.",
+    unsafeFolder: (name) => `The server sent a folder name I won't create: ${name}. Please report this to kimal3.`,
+    noWorkbank: "The delivery contains no workbench. Please report this to kimal3.",
+    logoName: "KImal3 logo",
+    pluginsLine: (an, aus, neu) => `  ${M.en.plugins} ${an.length > 0 ? `${an.join(", ")} — ${neu ? "will appear once Claude is fully quit and reopened" : "already added"}.` : "nothing switched on."}` +
+        (aus.length > 0 ? ` Switched off by you, stays off: ${aus.join(", ")}.` : ""),
+    pluginsNotWritten: (grund) => `  ${M.en.plugins} not added — ${grund}`,
+    settingsInvalid: "your Claude settings (~/.claude/settings.json) are not valid JSON. I left them untouched.",
+    settingsForeign: "your Claude settings (~/.claude/settings.json) contain something in a form I don't know. I left them untouched.",
+    settingsFailed: (ursache) => `your Claude settings (~/.claude/settings.json): ${ursache}.`,
+    logoNotWritten: (detail) => `  I couldn't create or renew the folder for the KImal3 logo (${detail}).`,
+    superpowersNeedsGit: "  superpowers needs Git — it comes with the next `kimal3 setup` once Git is there.",
+    logoOldVersion: "  The KImal3 logo stays on its previous version for now, because Claude is using the folder. Quit Claude completely, then run `kimal3 setup` again.",
+};
+export const EINRICHTEN_TEXTE = { de, en };