kimal3 0.4.0-durchstich.1 → 0.4.0-durchstich.3

package/claude-plugins/.claude-plugin/marketplace.json

@@ -0,0 +1,8 @@
+{
+  "name": "kimal3",
+  "owner": { "name": "KImal3", "url": "https://kimal3.de" },
+  "description": "Eingetragen vom Programm kimal3 · Added by the kimal3 program",
+  "plugins": [
+    { "name": "kimal3-logo", "source": "./kimal3-logo", "description": "KImal3-Logo über dem Eingabefeld · KImal3 logo above the prompt" }
+  ]
+}

package/claude-plugins/README.md

@@ -0,0 +1,7 @@
+# kimal3 — Plugins für Claude Code / Plugins for Claude Code
+
+Diesen Ordner legt `kimal3 einrichten` an und ersetzt ihn bei jedem Lauf. Eigene Änderungen hier gehen dabei verloren.
+Das Logo abschalten: in Claude unter **Plugins** `kimal3-logo` ausschalten — `kimal3` schaltet es danach nicht wieder ein.
+
+`kimal3 setup` creates this folder and replaces it on every run; your own changes here are lost.
+To turn the logo off: switch off `kimal3-logo` under **Plugins** in Claude — `kimal3` won't switch it back on.

package/claude-plugins/kimal3-logo/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "kimal3-logo",
+  "version": "0.2.0",
+  "description": "KImal3-Logo über dem Eingabefeld · KImal3 logo above the prompt",
+  "author": { "name": "KImal3", "url": "https://kimal3.de" }
+}

package/claude-plugins/kimal3-logo/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/claude-plugins/kimal3-logo/hooks/register.tsx

@@ -0,0 +1,80 @@
+import type { Register } from 'claude-code'
+
+// Die Sprache des Kontos. `kimal3 einrichten` setzt diese Zeile beim Ablegen in `~/.kimal3/claude-plugins` und prüft
+// danach, dass sie gesetzt ist (`cli/src/logo-ablegen.ts`) — der Mod selbst kann keine Datei lesen.
+const SPRACHE: 'de' | 'en' = 'de'
+
+// Icon: docs/design/kimal3-icon-animated.svg, unverändert bis auf die viewBox:
+// Sie schneidet den leeren Rand um die drei Dreiecke weg (Original: 0 0 80 80).
+const ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="20 19 40 36" width="24" height="22">
+  <style>
+    /* color-scheme: sonst malt der Browser hinter die Grafik eine eigene Fläche, wenn hell/dunkel nicht zur App passt */
+    :root { background: transparent; color-scheme: light dark; }
+    .icon { opacity: 0.8; }
+    .tri  { fill: none; stroke: hsl(194 100% 51%); stroke-width: 2.8; stroke-linejoin: round; opacity: 0.7; }
+    .t1 { animation: trianglePulse 3s ease-in-out infinite; }
+    .t2 { animation: trianglePulse 3.5s ease-in-out infinite; animation-delay: .4s; }
+    .t3 { animation: trianglePulse 4s ease-in-out infinite; animation-delay: .8s; }
+    @keyframes trianglePulse { 0%,100% { opacity: .5; } 50% { opacity: 1; } }
+  </style>
+  <g class="icon">
+    <polygon class="tri t1" points="33.28,21.6 22.08,41.0 44.48,41.0" />
+    <polygon class="tri t2" points="46.72,21.6 35.52,41.0 57.92,41.0" />
+    <polygon class="tri t3" points="40.00,33.36 28.80,52.76 51.20,52.76" />
+  </g>
+</svg>`
+
+// Das Cyan der Marke (kimal3.de, --brand in der App)
+const MARKEN_CYAN = '#00C3FF'
+// Der Kurs, für alle (Dennis, 15.10.: „mach alle auf den Kurs“). Abgemeldete schickt die App von dort zum Login.
+// Fest auf `/firma` zeigte der Link Kostenlosen ohne Firma eine leere Seite (Spec L-51). Im Terminal: Strg+Klick; Claude Code hängt dort die Adresse
+// grau dahinter, wenn es dem Terminal keine Links zutraut — FORCE_HYPERLINK hilft nicht.
+const APP = 'https://app.kimal3.de/kurs'
+
+// Vor und nach der Wortmarke. Englisch: „AI Workplace“, nie „workspace“ (Spec, Global Constraints).
+const TEXT = {
+  de: { vor: 'Dein ', nach: '-Arbeitsplatz', alt: 'KImal3-Logo' },
+  en: { vor: 'Your ', nach: ' AI Workplace', alt: 'KImal3 logo' },
+}[SPRACHE]
+
+export const register: Register = on => {
+  on('ui.render', { component: 'AbovePrompt' }, ($, e, next) => {
+    if (e.props.hasSurvey) {
+      return next(e)
+    }
+
+    // Im Terminal gibt es kein Svg: drei Dreiecke als Zeichen, die Wortmarke wie auf kimal3.de
+    // („KI" in Schriftfarbe, „mal3" im Marken-Cyan). Das Cyan steht als Farbwert, nicht als „cyan" —
+    // das Terminal-Cyan ist je nach Farbschema ein anderes, oft ein blasses Türkis.
+    if (e.surface === 'terminal') {
+      const { Box, Link, Text } = $.ui.resolve(e)
+      return (
+        <Box flexDirection="row" gap={1}>
+          <Text color={MARKEN_CYAN} bold>{'▲▲▲'}</Text>
+          <Text bold>
+            {TEXT.vor}
+            <Link href={APP}>
+              {'KI'}
+              <Text color={MARKEN_CYAN}>{'mal3'}</Text>
+              {TEXT.nach}
+            </Link>
+            {'.'}
+          </Text>
+        </Box>
+      )
+    }
+
+    // isInteractive: erst damit spielt die Leiste die CSS-Animation ab, sonst steht das Icon still.
+    const { Box, Link, Svg, Text } = $.ui.resolve(e)
+    return (
+      <Box flexDirection="row" alignItems="center" gap={1}>
+        <Svg source={ICON} alt={TEXT.alt} width={24} height={22} isInteractive />
+        <Text bold>
+          {TEXT.vor}
+          <Link href={APP}>{`KImal3${TEXT.nach}`}</Link>
+          {'.'}
+        </Text>
+      </Box>
+    )
+  })
+}

package/dist/befehle/einrichten.js

@@ -1,7 +1,11 @@
 import { spawnSync } from "node:child_process";
-import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import { leseAnmeldung } from "../anmeldung.js";
+import { tragePluginsEin } from "../einstellungen-schreiben.js";
+import { logoAblegen } from "../logo-ablegen.js";
+import { pluginStand } from "../plugins-mischen.js";
 import { ruf } from "../api.js";
 import { FIRMEN_OPTIONEN, fehlendeDateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
 import { zerlege } from "../argumente.js";
@@ -9,7 +13,8 @@ import { sprache } from "../sprache.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
 import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
 import { anmeldenMitBrowser } from "./login.js";
-import { skillInstall } from "./skill-install.js";
+import { SKILL_TEXTE } from "../texte/skill.js";
+import { skillInstall, ursacheDes } from "./skill-install.js";
 /**
  * `kimal3 einrichten` / `kimal3 setup` -- der eine Befehl, den Claude beim Einstieg mit Leitung
  * aufruft (Spec 2026-10-11, Abschnitt 0, S-1, S-2, S-7). Er verbindet, was es schon gibt:
@@ -20,8 +25,10 @@ import { skillInstall } from "./skill-install.js";
  * steht -- die Sitzung ohne Ordner ist ein Wegwerf-Ordner der App (M-L2).
  * 🔑 Nichts wird überschrieben: Ein zweiter Lauf ergänzt nur Fehlendes (`fehlendeDateienSchreiben`).
  *
- * 📌 Durchstich-Fassung: ohne Coach, Logo und Suche nach einem vorhandenen Arbeitsplatz an
- * anderer Stelle (S-8) -- das kommt mit dem zweiten Bauplan, nach dem echten Lauf.
+ * 🔑 superpowers und das Logo trägt er seit Bauplan 2026-10-15 selbst in Claudes Einstellungen ein
+ * (`pluginsEinrichten`) -- Claude installiert dafür nichts mehr per Befehlszeile oder Menü.
+ *
+ * 📌 Noch ohne Coach und ohne Suche nach einem vorhandenen Arbeitsplatz an anderer Stelle (S-8).
  */
 export async function einrichten(argv) {
     const s = sprache();
@@ -73,16 +80,70 @@ export async function einrichten(argv) {
     console.log(t.filesWritten(geschrieben.neu, geschrieben.schonDa));
     console.log(t.workplaceLine(ziel));
     console.log(t.workbenchLine(werkbank));
+    // Plugins VOR der Wache: So hält ihre Sicherungskopie Sabines unveränderte Einstellungen (QA-Fund 9).
+    const git = gitAntwortet();
+    pluginsEinrichten(git);
     const befehle = await skillInstall();
-    await kursAbhaken(gitAntwortet() ? ["beat2-werkzeuge", "beat2-kimal3", "beat2-arbeitsplatz"] : ["beat2-kimal3", "beat2-arbeitsplatz"]);
+    await kursAbhaken(git ? ["beat2-werkzeuge", "beat2-kimal3", "beat2-arbeitsplatz"] : ["beat2-kimal3", "beat2-arbeitsplatz"]);
     if (befehle !== 0)
         return befehle;
     console.log(t.done);
     return 0;
 }
-/** Git ist da, wenn `git --version` antwortet -- Node.js ist es, sonst liefe dieses Programm nicht. */
+/**
+ * superpowers und das Logo: Ordner ablegen, in Claudes Einstellungen eintragen, eine Zeile `Plugins:`.
+ * 🔑 Scheitert etwas, bricht die Einrichtung NICHT ab (Lage P-3): Arbeitsplatz, Befehle und Wache
+ * stehen ja -- die Zeile sagt, was fehlt, und Claude nimmt dann den Menü-Weg für superpowers.
+ * 🔑 Ohne Git trägt er superpowers NICHT ein (Durchsicht 3, Fund 5): Claude Code klont Anthropics Katalog mit Git und
+ * scheiterte sonst bei jedem Start. Eine Zeile sagt es; der nächste Lauf mit Git holt es nach (Mac-Weg ohne Adminrechte).
+ */
+function pluginsEinrichten(git) {
+    const s = sprache();
+    const t = EINRICHTEN_TEXTE[s];
+    const ablage = logoAblegen(s);
+    // Ohne Logo-Ordner kommt superpowers trotzdem (Durchsicht 2, Fund 1): eine Zeile zum Logo, dann weiter.
+    if (!ablage.ok)
+        console.log(t.logoNotWritten(ablage.detail));
+    if (ablage.ok && ablage.alterStand)
+        console.log(t.logoOldVersion);
+    // Schrägstriche vorwärts: So steht der Pfad in Claudes Einstellungen auf jedem System gleich (P-13).
+    const eintrag = tragePluginsEin(ablage.ok ? ablage.ordner.replace(/\\/g, "/") : null, git);
+    if (eintrag.art === "abgelehnt") {
+        console.log(t.pluginsNotWritten(eintrag.grund === "kein-gueltiges-json" ? t.settingsInvalid : t.settingsForeign));
+        return;
+    }
+    if (eintrag.art === "gescheitert") {
+        // Den Schritt in Sabines Sprache, nie das interne Wort (Durchsicht-Fund 3) -- derselbe Satz wie bei der Wache.
+        console.log(t.pluginsNotWritten(t.settingsFailed(ursacheDes(eintrag, SKILL_TEXTE[s]))));
+        return;
+    }
+    const stand = pluginStand(eintrag.inhalt);
+    const namen = { superpowers: "superpowers", logo: t.logoName };
+    const mit = (wert) => ["superpowers", "logo"].filter((p) => stand[p] === wert).map((p) => namen[p]);
+    console.log(t.pluginsLine(mit("an"), mit("aus"), eintrag.art === "eingetragen"));
+    // Auch wenn superpowers schon von früher drinsteht: ohne Git lädt es nicht (Durchsicht 4, Fund 3).
+    if (!git && stand.superpowers !== "aus")
+        console.log(t.superpowersNeedsGit);
+}
+/**
+ * Ist Git da? Node.js ist es, sonst liefe dieses Programm nicht.
+ * 🔴 AUF DEM MAC NIE BLIND `git --version` (Durchsicht 3, Fund 1): Ohne Entwickler-Tools ist `/usr/bin/git` nur ein
+ * Platzhalter, der das Installationsfenster öffnet -- auf einem Standardkonto samt Frage nach einem Admin-Passwort,
+ * mitten in der Einrichtung. Dort zählt Git nur, wenn die Entwickler-Tools da sind (`xcode-select -p`) oder ein Git
+ * außerhalb von `/usr/bin` im Pfad liegt (Homebrew) -- und dann wird genau DAS gefragt, nicht das erste im Pfad.
+ * Dieselbe Regel steht in der Anleitung, Schritt 1.
+ */
 function gitAntwortet() {
-    return spawnSync("git", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+    const antwortet = (befehl) => spawnSync(befehl, ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+    if (platform() !== "darwin")
+        return antwortet("git");
+    if (spawnSync("xcode-select", ["-p"], { stdio: "ignore" }).status === 0)
+        return antwortet("git");
+    // Nur absolute Ordner: Ein leerer Eintrag oder `.` ergäbe den bloßen Namen `git`, und der fände wieder den
+    // Platzhalter in `/usr/bin` (Durchsicht 4, Fund 2).
+    const eigenes = (process.env.PATH ?? "").split(":").filter((ordner) => ordner.startsWith("/") && ordner !== "/usr/bin")
+        .map((ordner) => join(ordner, "git")).find((datei) => existsSync(datei));
+    return eigenes !== undefined && antwortet(eigenes);
 }
 /**
  * Die Haken sind eine Zugabe: Scheitern sie, ist der Arbeitsplatz trotzdem da -- eine Zeile,

package/dist/befehle/skill-install.js

@@ -3,7 +3,7 @@ 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";
@@ -286,8 +286,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);

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

@@ -495,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")

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/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/texte/einrichten-marken.js

@@ -4,6 +4,6 @@
  * 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" },
-    en: { code: "Sign-in code:", adresse: "Address:", arbeitsplatz: "Workplace:", werkbank: "Workbench:", angemeldet: "Signed in as" },
+    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

@@ -15,6 +15,21 @@ const de = {
     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}`,
@@ -31,5 +46,15 @@ const en = {
     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 };

package/dist/wache-schalter.js

@@ -32,6 +32,8 @@ export function leseWacheDatei() {
         if (Array.isArray(inhalt.sitzungen)) {
             raus.sitzungen = inhalt.sitzungen.filter((s) => typeof s === "string");
         }
+        if (typeof inhalt.eingerichtet === "string")
+            raus.eingerichtet = inhalt.eingerichtet;
         return raus;
     }
     catch {
@@ -116,6 +118,22 @@ export function merkeSitzung(sitzung) {
         return;
     schreibeWacheDatei(mitSitzung(leseWacheDatei() ?? {}, sitzung));
 }
+/**
+ * Merken, in welcher Claude-Sitzung die Wache gerade eingetragen wurde. Wirft nie.
+ *
+ * 🔴 NICHT `merkeSitzung` (Sandbox-Lauf 14.10., Befund S-3): Der Eintrag greift erst beim
+ * naechsten Start -- ohne Merkzettel meldete der naechste Befehl in derselben Sitzung sofort
+ * "hat nicht nachgesehen". Bis 0.4.0-durchstich.1 stempelte `skill install` deshalb die
+ * Sitzung als NACHGESEHEN. Das hielt den Fehlalarm still, aber auch die Wache selbst: Wer im
+ * selben Gespraech weitermacht, hoerte sie am ersten Tag nie (gemessen: das Pro-Angebot lag
+ * bereit, `cli_nachrichten_gezeigt` blieb leer). Ein eigenes Feld trennt beides --
+ * `wacheAusgefallen` liest es, `schonFuerDieseSitzung` nicht.
+ */
+export function merkeEinrichtung(sitzung) {
+    if (sitzung === null)
+        return;
+    schreibeWacheDatei({ ...(leseWacheDatei() ?? {}), eingerichtet: sitzung });
+}
 /** Wie viele Sitzungen der Merkzettel sich merkt -- genug fuer mehrere Fenster ueber Tage. */
 const MERKE_SITZUNGEN = 20;
 /**
@@ -171,7 +189,10 @@ function gesehen(inhalt, jetzt) {
  * Terminalfenster tippt, will die Antwort jetzt -- ein Merkzettel von gestern
  * darf ihn nicht zum Schweigen bringen.
  */
-export function schonFuerDieseSitzung(inhalt, jetzt) {
+export function schonFuerDieseSitzung(
+// `eingerichtet` steht im Typ, damit der ganze Merkzettel hereinpasst -- gelesen wird es
+// hier ABSICHTLICH nicht: Eingerichtet heisst nicht nachgesehen (S-3, `merkeEinrichtung`).
+inhalt, jetzt) {
     return jetzt !== null && inhalt !== null && gesehen(inhalt, jetzt);
 }
 /**
@@ -186,9 +207,13 @@ export function schonFuerDieseSitzung(inhalt, jetzt) {
  * dann aus wie an einem guten Tag. *Eine Wache, die still stirbt, ist
  * schlimmer als keine: Sie kauft Vertrauen und deckt nichts mehr.*
  *
- * 🔴 DREI MAL SCHWEIGEN, EINMAL SPRECHEN:
+ * 🔴 FUENF MAL SCHWEIGEN, EINMAL SPRECHEN:
  *   - Keine Sitzungsnummer -> der Mensch sitzt im Terminalfenster, die Wache
  *     hatte nie einen Anlass zu laufen. "Nicht gelaufen" heisst hier nichts.
+ *   - Kein Merkzettel -> die Wache war nie eingerichtet; `skill install` legt ihn an.
+ *     Bis 0.4.0-durchstich.1 meldete das hier -- die allererste Ausgabe einer neuen
+ *     Kundin war ein Fehlalarm (Sandbox-Lauf 14.10., Befund S-2).
+ *   - In dieser Sitzung eingerichtet -> sie greift erst beim naechsten Start (S-3).
  *   - Abgeschaltet -> wer `kimal3 wache aus` getippt hat, will nicht taeglich
  *     daran erinnert werden. Sonst waere der Ausschalter keiner.
  *   - Dieselbe Nummer -> sie hat fuer diese Sitzung nachgesehen.
@@ -201,9 +226,9 @@ export function wacheAusgefallen(
 // Fassung traegt genau das und sonst nichts, und dieser Fall gehoert
 // geprueft. Ein Typ, der ihn verbietet, verbietet auch seine Pruefung.
 inhalt, jetzt) {
-    if (jetzt === null)
+    if (jetzt === null || inhalt === null)
         return false;
-    if (inhalt !== null && inhalt.aus === true)
+    if (inhalt.aus === true)
         return false;
-    return inhalt === null || !gesehen(inhalt, jetzt);
+    return !gesehen(inhalt, jetzt) && inhalt.eingerichtet !== jetzt;
 }

package/package.json

@@ -1,27 +1,28 @@
-{
-  "name": "kimal3",
-  "version": "0.4.0-durchstich.1",
-  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
-  "type": "module",
-  "bin": {
-    "kimal3": "dist/kimal3.js"
-  },
-  "files": [
-    "dist",
-    "skill",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "kimal3",
-    "cli"
-  ],
-  "homepage": "https://app.kimal3.de/pro",
-  "license": "SEE LICENSE IN README.md"
-}
+{
+  "name": "kimal3",
+  "version": "0.4.0-durchstich.3",
+  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
+  "type": "module",
+  "bin": {
+    "kimal3": "dist/kimal3.js"
+  },
+  "files": [
+    "dist",
+    "skill",
+    "claude-plugins",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "kimal3",
+    "cli"
+  ],
+  "homepage": "https://app.kimal3.de/pro",
+  "license": "SEE LICENSE IN README.md"
+}