kimal3 0.2.1 → 0.2.3

package/README.md

@@ -1,102 +1,134 @@
-# kimal3
-
-**Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.**
-
-Wer mit Claude Code arbeitet, baut echte Dinge — und dokumentiert sie hinterher nicht,
-weil das ein zweiter Arbeitsschritt in einem anderen Fenster wäre. `kimal3` schließt
-diese Lücke: Am Ende einer Sitzung trägt Claude das fertige Projekt selbst in dein
-KImal3-Erfolgsprofil ein. Du gibst es dort nur noch frei.
-
-> **Voraussetzung: ein KImal3-Konto mit Pro.**
-> Ohne Pro meldet sich dieses Werkzeug ab, ohne etwas zu tun.
-> Was Pro enthält und wie du es bekommst: **https://kimal3-app.vercel.app/pro**
-
-## Loslegen
-
-Einmal pro Rechner:
-
-```bash
-npm install -g kimal3   # das Werkzeug installieren (setzt Node.js voraus)
-kimal3 login            # diesen Rechner mit deinem Konto verbinden
-kimal3 skill install    # Claude beibringen, das Werkzeug zu benutzen
-```
-
-> **In Claude Code?** Dann lass es einrichten, statt es zu tippen — der Satz zum Kopieren steht
-> auf **https://kimal3-app.vercel.app/pro**. Nur `kimal3 login` tippst du selbst (dort mit `!`
-> davor), weil die Bestätigung im Browser einen Menschen braucht.
-
-`login` zeigt dir eine Adresse und einen achtstelligen Code. Die Adresse rufst du selbst
-auf und bestätigst den Code dort in deinem eingeloggten Konto — so wie bei `gh auth login`.
-**Es wird kein Passwort ins Terminal getippt.**
-
-## Befehle
-
-```
-kimal3                    Zeigt, ob dieser Rechner angemeldet ist
-kimal3 login              Diesen Rechner mit deinem Konto verbinden
-kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen — und dir die /k3-Befehle geben
-kimal3 arbeitsplatz neu   Den ganzen KI-Arbeitsplatz anlegen — Firmenebene und Werkbank
-kimal3 werkbank neu       Nur eine eigene Werkbank in einer bestehenden Firma anlegen
-kimal3 kontext runter     Den Firmenkontext holen — CLAUDE.md und die fünf Dateien in kontext/
-kimal3 kontext fragen     Zeigen, welche Fragen über deine Firma noch unbeantwortet sind
-kimal3 kontext hoch       Deine lokalen Änderungen an den fünf Kontext-Dateien hochschicken
-kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
-kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
-kimal3 firma daten        Die Daten deiner Firma holen, damit Claude sie auswerten kann
-kimal3 logout             Verbindung wieder aufheben
-```
-
-Mehr zu einem Befehl: `kimal3 projekt neu --help`
-
-## Was eingetragen wird
-
-Nur, was du eingibst — Titel, Beschreibung, optional ein Link. **Dein Code wird nicht
-gelesen, nicht hochgeladen und nicht analysiert.** Das Werkzeug schreibt ausschließlich
-über die KImal3-App und hat keinen eigenen Datenbankzugang.
-
-Eingetragene Projekte sind zunächst **nicht öffentlich**. Sie erscheinen in deinem
-Erfolgsprofil, und du entscheidest dort, was sichtbar wird.
-
-## Rückgabewerte
-
-Für Skripte und für Claude selbst:
-
-| Wert | Bedeutung | Hilft |
-|---|---|---|
-| `0` | hat geklappt | — |
-| `1` | Eingabe unvollständig oder nichts gefunden | Eingabe prüfen |
-| `2` | nicht angemeldet | `kimal3 login` |
-| `3` | gerade nicht erreichbar | später noch einmal |
-| `4` | kein Pro-Konto | erneutes Versuchen hilft **nicht** |
-
-Der Unterschied zwischen `3` und `4` ist Absicht: Bei `3` lohnt ein zweiter Versuch,
-bei `4` nie.
-
-## Update-Hinweise
-
-Steht eine neuere Fassung bereit, schreibt `kimal3` nach dem Befehl eine eingerückte
-Zeile — höchstens **einmal am Tag**:
-
-```
-  →  kimal3 0.2.0 ist da.  npm i -g kimal3@latest && kimal3 skill install
-```
-
-Sie geht auf **stderr**, nicht auf stdout: `kimal3 firma daten > firma.json` bleibt
-damit sauberes JSON. Sie **ändert den Rückgabewert nicht** — eine `0` bleibt eine `0`.
-Und `kimal3` **installiert nichts von selbst**; der Befehl steht in der Zeile, ausführen
-tust du ihn.
-
-Dasselbe gilt für die Skill-Dateien: Sind die in `~/.claude/skills/kimal3/` älter als
-das installierte Werkzeug, sagt `kimal3` es — dafür braucht es kein Netz.
-
-## Voraussetzungen
-
-Node.js 20 oder neuer. Sonst nichts — das Werkzeug bringt **keine fremden Bibliotheken**
-mit.
-
-## Lizenz
-
-Proprietär. Die Nutzung ist Inhabern eines gültigen KImal3-Pro-Kontos gestattet;
-Weitergabe, Veränderung und Weiterverwendung des Codes sind nicht erlaubt.
-
-© KImal3 · https://kimal3.de
+# kimal3
+
+**Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.**
+
+Wer mit Claude Code arbeitet, baut echte Dinge — und dokumentiert sie hinterher nicht,
+weil das ein zweiter Arbeitsschritt in einem anderen Fenster wäre. `kimal3` schließt
+diese Lücke: Am Ende einer Sitzung trägt Claude das fertige Projekt selbst in dein
+KImal3-Erfolgsprofil ein. Du gibst es dort nur noch frei.
+
+> **Voraussetzung: ein KImal3-Konto mit Pro.**
+> Ohne Pro meldet sich dieses Werkzeug ab, ohne etwas zu tun.
+> Was Pro enthält und wie du es bekommst: **https://app.kimal3.de/pro**
+
+## Loslegen
+
+Einmal pro Rechner:
+
+```bash
+npm install -g kimal3   # das Werkzeug installieren (setzt Node.js voraus)
+kimal3 login            # diesen Rechner mit deinem Konto verbinden
+kimal3 skill install    # Claude beibringen, das Werkzeug zu benutzen
+```
+
+> **In Claude Code?** Dann lass es einrichten, statt es zu tippen — der Satz zum Kopieren steht
+> auf **https://app.kimal3.de/pro**. Nur `kimal3 login` tippst du selbst (dort mit `!`
+> davor), weil die Bestätigung im Browser einen Menschen braucht.
+
+`login` zeigt dir eine Adresse und einen achtstelligen Code. Die Adresse rufst du selbst
+auf und bestätigst den Code dort in deinem eingeloggten Konto — so wie bei `gh auth login`.
+**Es wird kein Passwort ins Terminal getippt.**
+
+## Befehle
+
+```
+kimal3                    Zeigt, ob dieser Rechner angemeldet ist
+kimal3 login              Diesen Rechner mit deinem Konto verbinden
+kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen — und dir die /k3-Befehle geben
+kimal3 arbeitsplatz neu   Den ganzen KI-Arbeitsplatz anlegen — Firmenebene und Werkbank
+kimal3 werkbank neu       Nur eine eigene Werkbank in einer bestehenden Firma anlegen
+kimal3 kontext runter     Den Firmenkontext holen — CLAUDE.md und die fünf Dateien in kontext/
+kimal3 kontext fragen     Zeigen, welche Fragen über deine Firma noch unbeantwortet sind
+kimal3 kontext hoch       Deine lokalen Änderungen an den fünf Kontext-Dateien hochschicken
+kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
+kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
+kimal3 firma daten        Die Daten deiner Firma holen, damit Claude sie auswerten kann
+kimal3 wache              Läuft von selbst, einmal am Tag: prüft Zugang, Nachricht, Version, Skill
+kimal3 wache aus          Die tägliche Prüfung abschalten — sie sagt dann nichts mehr
+kimal3 wache an           Sie wieder einschalten
+kimal3 logout             Verbindung wieder aufheben
+```
+
+Mehr zu einem Befehl: `kimal3 projekt neu --help`
+
+## Was eingetragen wird
+
+Nur, was du eingibst — Titel, Beschreibung, optional ein Link. **Dein Code wird nicht
+gelesen, nicht hochgeladen und nicht analysiert.** Das Werkzeug schreibt ausschließlich
+über die KImal3-App und hat keinen eigenen Datenbankzugang.
+
+Eingetragene Projekte sind zunächst **nicht öffentlich**. Sie erscheinen in deinem
+Erfolgsprofil, und du entscheidest dort, was sichtbar wird.
+
+## Rückgabewerte
+
+Für Skripte und für Claude selbst:
+
+| Wert | Bedeutung | Hilft |
+|---|---|---|
+| `0` | hat geklappt | — |
+| `1` | Eingabe unvollständig, nichts gefunden — oder deine Claude-Einstellungen sind nicht lesbar | die Meldung lesen, sie nennt den Fall |
+| `2` | nicht angemeldet | `kimal3 login` |
+| `3` | gerade nicht erreichbar | später noch einmal |
+| `4` | kein Pro-Konto | erneutes Versuchen hilft **nicht** |
+
+Der Unterschied zwischen `3` und `4` ist Absicht: Bei `3` lohnt ein zweiter Versuch,
+bei `4` nie.
+
+## Update-Hinweise
+
+Steht eine neuere Fassung bereit, schreibt `kimal3` nach dem Befehl eine eingerückte
+Zeile — höchstens **einmal am Tag**:
+
+```
+  →  kimal3 0.2.0 ist da.  npm i -g kimal3@latest && kimal3 skill install
+```
+
+Sie geht auf **stderr**, nicht auf stdout: `kimal3 firma daten > firma.json` bleibt
+damit sauberes JSON. Sie **ändert den Rückgabewert nicht** — eine `0` bleibt eine `0`.
+Und `kimal3` **installiert nichts von selbst**; der Befehl steht in der Zeile, ausführen
+tust du ihn.
+
+Dasselbe gilt für die Skill-Dateien: Sind die in `~/.claude/skills/kimal3/` älter als
+das installierte Werkzeug, sagt `kimal3` es — dafür braucht es kein Netz.
+
+## Die tägliche Prüfung — und wie du sie abstellst
+
+`kimal3 skill install` trägt eine Zeile in deine Claude-Einstellungen ein
+(`~/.claude/settings.json`). Sie sorgt dafür, dass beim Start von Claude einmal am Tag
+`kimal3 wache` läuft. Die Prüfung sieht nach, ob dein Zugang noch gilt, ob eine neuere
+Fassung bereitsteht, ob deine `/k3`-Befehle veraltet sind und ob eine Nachricht von uns
+anliegt.
+
+**Sie meldet sich nur, wenn wirklich etwas ansteht.** Ist alles in Ordnung, sagt sie nichts.
+
+Willst du sie nicht:
+
+```
+kimal3 wache aus     # ab jetzt still
+kimal3 wache an      # doch wieder
+```
+
+Nach `kimal3 wache aus` wird **nichts mehr an unseren Server geschickt** — die Prüfung
+steigt aus, bevor sie irgendetwas fragt. Gemessen: mit Prüfung rund 0,9 Sekunden, ohne
+rund 0,19 Sekunden, und in den 0,19 Sekunden verlässt kein Byte deinen Rechner.
+
+Die Zeile in den Einstellungen bleibt dabei stehen, damit `kimal3 wache an` sofort wirkt
+und wir deine Einstellungsdatei nicht noch einmal anfassen müssen. Es startet also weiter
+ein kleines Programm von uns, das nach rund 0,19 Sekunden wieder aufhört.
+
+**Soll auch das nicht mehr passieren**, nimm die Zeile selbst heraus: In
+`~/.claude/settings.json` steht unter `hooks` → `SessionStart` ein Eintrag mit dem Befehl
+`kimal3 wache`. Lösch diesen einen Eintrag — den Rest der Datei lass, wie er ist.
+
+## Voraussetzungen
+
+Node.js 20 oder neuer. Sonst nichts — das Werkzeug bringt **keine fremden Bibliotheken**
+mit.
+
+## Lizenz
+
+Proprietär. Die Nutzung ist Inhabern eines gültigen KImal3-Pro-Kontos gestattet;
+Weitergabe, Veränderung und Weiterverwendung des Codes sind nicht erlaubt.
+
+© KImal3 · https://kimal3.de

package/dist/anmeldung.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
  * Wo die App wohnt. Ueberschreibbar fuers lokale Entwickeln:
  *   KIMAL3_URL=http://localhost:3000 kimal3 projekt liste
  */
-export const BASIS_URL = process.env.KIMAL3_URL ?? "https://kimal3-app.vercel.app";
+export const BASIS_URL = process.env.KIMAL3_URL ?? "https://app.kimal3.de";
 const ORDNER = join(homedir(), ".kimal3");
 const DATEI = join(ORDNER, "anmeldung.json");
 export function leseAnmeldung() {

package/dist/befehle/skill-install.js

@@ -2,6 +2,8 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync,
 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 { STEMPEL_MARKE } from "../nachricht.js";
 import { eigeneVersion } from "../version.js";
 export const VERALTETE_BEFEHLE = [
@@ -255,6 +257,54 @@ export async function skillInstall() {
       *Ein Hinweis auf etwas, das es nicht gibt, sieht aus wie ein Fehler des
       Menschen.*
     */
+    /*
+      Die Wache in die Claude-Einstellungen eintragen.
+  
+      🔑 WARUM HIER UND NICHT IN EINEM EIGENEN BEFEHL: Der Mensch tippt
+      `kimal3 skill install` ohnehin -- nach dem Kauf, nach jedem Update. Ein
+      zweiter Befehl waere ein zweiter Schritt, den man vergisst, und die Wache
+      ist genau fuer die Menschen gebaut, die nicht daran denken.
+  
+      🔴 EIN FEHLSCHLAG HIER DARF DEN LAUF NICHT ALS ERFOLG ENDEN LASSEN.
+      Das Skill steht dann zwar -- aber die taegliche Pruefung laeuft nicht, und
+      ein stiller Ausfall genau dort ist der teuerste Fall dieser Scheibe.
+    */
+    const wache = trageWacheEin();
+    if (wache.art === "eingetragen" || wache.art === "stand-schon") {
+        /*
+          🔴 WARUM DAS HIER STEHEN MUSS: Der Eintrag greift erst beim
+          NAECHSTEN Start von Claude -- in der laufenden Sitzung hat die Wache
+          also noch nie nachgesehen, voellig zu Recht. Ohne diesen Stempel
+          bekaeme der Mensch unmittelbar nach dem Einrichten die Meldung "deine
+          taegliche Pruefung laeuft nicht" -- ausgerechnet in dem Augenblick, in
+          dem er sie gerade eingerichtet hat. *Der erste Eindruck waere ein
+          Fehlalarm.*
+        */
+        merkeSitzung(sitzungJetzt());
+    }
+    if (wache.art === "eingetragen") {
+        console.log("  Die taegliche kimal3-Pruefung ist eingetragen. Sie meldet sich nur, wenn etwas ansteht.");
+    }
+    else if (wache.art === "stand-schon") {
+        console.log("  Die taegliche kimal3-Pruefung steht schon in deinen Einstellungen.");
+    }
+    else if (wache.art === "abgelehnt") {
+        console.error("");
+        console.error("  Die taegliche kimal3-Pruefung konnte NICHT eingetragen werden.");
+        console.error(`  Deine Claude-Einstellungen sind nicht lesbar: ${einstellungenDatei()}`);
+        console.error(wache.grund === "kein-gueltiges-json"
+            ? "  Die Datei ist kein gueltiges JSON. Sie wurde NICHT angefasst."
+            : "  Die Datei hat eine Form, die wir nicht verstehen. Sie wurde NICHT angefasst.");
+        console.error("  Wiederholen hilft nicht -- erst die Datei in Ordnung bringen.");
+        return 1;
+    }
+    else if (wache.art === "gescheitert") {
+        console.error("");
+        console.error("  Die taegliche kimal3-Pruefung konnte NICHT eingetragen werden.");
+        console.error(`  ${einstellungenDatei()}: ${wache.grund}`);
+        console.error("  Deine bisherigen Einstellungen sind unveraendert.");
+        return 1;
+    }
     if (geschrieben.includes("k3")) {
         console.log("  Tipp /k3 in Claude Code. (Taucht nichts auf, einmal neu starten.)");
     }

package/dist/befehle/wache.js

@@ -0,0 +1,185 @@
+import { existsSync, readFileSync } from "node:fs";
+import { BASIS_URL, leseAnmeldung } from "../anmeldung.js";
+import { lokalerKontextStandJetzt } from "../api.js";
+import { leseGesehen, merkeGesehen } from "../gesehen.js";
+import { heuteAus, sollZeigen, skillZustand } from "../nachricht.js";
+import { eigeneVersion } from "../version.js";
+import { leseWacheDatei, merkeLauf, merkeSitzung, setzeWache, sitzungJetzt, sollHeuteLaufen, } from "../wache-schalter.js";
+import { wacheAntwortAusHttp, wacheZeilen } from "../wache-rechnung.js";
+import { skillDatei } from "./skill-install.js";
+/**
+ * 🔴 BEWUSSTE VORGABE, KEINE MESSUNG (Aufgabe 0b ist vertagt). Der bestehende
+ * Update-Kanal (`api.ts`) nimmt zwei Sekunden -- die Wache laeuft aber bei
+ * JEDEM Claude-Start mit, nicht bei einem bewusst getippten Befehl, und
+ * zweimal 2000 ms parallel waeren dort schon eher spuerbar. 1500 ms ist ein
+ * Bauchwert; die echte Zahl gehoert in eine spaetere Messung.
+ *
+ * Dieselbe Zahl gilt fuer BEIDE Anrufe (npm und unser Server) -- die Wache
+ * darf beim Start von Claude in Summe nicht laenger haengen als ein Anruf.
+ */
+const ZEITGRENZE_MS = 1500;
+/**
+ * Die neueste Fassung -- von der oeffentlichen npm-Registry, nicht von uns.
+ *
+ * 🔑 ZWEI GRUENDE, WARUM SIE NICHT UEBER UNSEREN SERVER GEHT: Sie stimmt
+ * immer, ohne dass wir sie pflegen -- und sie funktioniert auch dann, wenn
+ * unser eigener Server gerade nicht erreichbar ist.
+ *
+ * 🔴 `null` heisst "npm hat nicht geantwortet", NICHT "es gibt nichts Neues".
+ * Der Aufrufer schweigt dann.
+ */
+async function neuesteVonNpm(zeitgrenzeMs) {
+    try {
+        const antwort = await fetch("https://registry.npmjs.org/kimal3/latest", {
+            signal: AbortSignal.timeout(zeitgrenzeMs),
+        });
+        if (!antwort.ok)
+            return null;
+        const koerper = await antwort.json();
+        if (koerper && typeof koerper === "object" && "version" in koerper) {
+            const v = koerper.version;
+            if (typeof v === "string")
+                return v;
+        }
+    }
+    catch {
+        // Kein Netz, Zeitgrenze, Muell -- alles dasselbe: wir wissen es nicht.
+    }
+    return null;
+}
+/**
+ * Sind die Skill-Dateien aelter als die installierte CLI? Braucht kein Netz --
+ * `skillZustand` ist bereits gebaut (Aufgabe 3) und von `check:nachrichten`
+ * gedeckt, hier wird nur der Stempel von der Platte gelesen und hindurch-
+ * gereicht.
+ *
+ * ⚠️ Ohne eigene Versionsnummer laesst sich nichts vergleichen -- dann lieber
+ * schweigen (`false`) als eine Vermutung anzuzeigen.
+ */
+function skillIstVeraltet() {
+    const eigene = eigeneVersion();
+    if (eigene === null)
+        return false;
+    const datei = skillDatei();
+    const inhalt = existsSync(datei) ? readFileSync(datei, "utf8") : null;
+    return skillZustand(inhalt, eigene) === "veraltet";
+}
+/**
+ * Der eine Anruf beim eigenen Server -- Zugang pruefen, Nachricht abholen.
+ *
+ * 🔑 KEINE gemeinsame Anrufhilfe aus `api.ts`: Die Wache ist ein EIGENER,
+ * zweiter Kanal (Spec US-1) und soll nicht an den Nebeneffekten haengen, die
+ * jene Hilfsfunktion fuer die interaktiven Befehle mitbringt (den
+ * Kontext-Stand-Kopf lesen, den modul-globalen Update-Hinweis setzen). Ein
+ * eigener, kleiner Aufruf mit eigener Zeitgrenze ist hier klarer als ein
+ * Werkzeug fuer einen anderen Weg zweitzuverwenden.
+ *
+ * 🔴 DIE FILTERUNG GEHOERT HIERHIN, NICHT IN `wacheZeilen`: Die Route gibt die
+ * Nachricht immer VOLLSTAENDIG zurueck (`id`, `text`, `gilt_unter_version`).
+ * Ob sie ueberhaupt gezeigt wird, entscheidet `sollZeigen` -- ohne sie saehe
+ * jeder Kunde jede Nachricht, auch der auf der neuesten Fassung.
+ *
+ * `merkeGesehen` wird bewusst NICHT hier aufgerufen, sondern erst in `wache()`,
+ * nachdem die Zeile wirklich gedruckt wurde -- dieselbe Reihenfolge wie beim
+ * bestehenden Update-Kanal in `kimal3.ts` ("erst schreiben, dann vermerken").
+ */
+async function frageServer(schluessel, heute) {
+    try {
+        const antwort = await fetch(`${BASIS_URL}/api/cli/wache`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${schluessel}` },
+            signal: AbortSignal.timeout(ZEITGRENZE_MS),
+        });
+        const koerper = await antwort.json().catch(() => null);
+        const { zugangGilt, hinweis } = wacheAntwortAusHttp(antwort.status, koerper);
+        if (!hinweis)
+            return { zugangGilt, hinweis: null };
+        const eigene = eigeneVersion();
+        if (eigene === null)
+            return { zugangGilt, hinweis: null };
+        const standJetzt = lokalerKontextStandJetzt();
+        if (!sollZeigen(hinweis, eigene, leseGesehen(), heute, standJetzt)) {
+            return { zugangGilt, hinweis: null };
+        }
+        return { zugangGilt, hinweis };
+    }
+    catch {
+        // Kein Netz, Zeitgrenze, Muell -- wie beim Server-Aussetzer: im Zweifel
+        // gilt der Zugang, und es liegt keine Nachricht an.
+        return { zugangGilt: true, hinweis: null };
+    }
+}
+/**
+ * 🔴 GIBT IMMER 0 ZURUECK, auch im Fehlerfall. Ein Nebenschauplatz darf den
+ * Start von Claude nicht umwerfen -- dieselbe Regel wie bei der
+ * Abhaengigkeits-Wache.
+ *
+ * 🔴 REIHENFOLGE DER AUSSTIEGE, jede spart die naechste ein:
+ *   1. abgeschaltet          -> still, kein Netz
+ *   2. keine Anmeldedatei    -> still, KEIN NETZAUFRUF (US-5)
+ *   3. heute schon gelaufen  -> still, kein Netz
+ * Erst danach wird ueberhaupt telefoniert.
+ */
+export async function wache() {
+    try {
+        const heute = heuteAus(new Date());
+        /*
+          🔴 GANZ VORNE, VOR JEDEM AUSSTIEG. Dieser Stempel beantwortet
+          nicht "war heute etwas zu melden", sondern "hat ueberhaupt jemand fuer
+          diese Claude-Sitzung nachgesehen" -- und genau das ist auch dann wahr,
+          wenn die Wache gleich still aussteigt, weil sie heute schon lief.
+    
+          Ohne diese Zeile bekaeme die ZWEITE Claude-Sitzung eines Tages die
+          Meldung "deine Pruefung laeuft nicht", obwohl sie tadellos laeuft: Die
+          Wache steigt dort bei "heute schon gelaufen" aus, und der Merkzettel
+          truege noch die Nummer der ersten Sitzung. *Ein Fehlalarm an genau der
+          Stelle, an der die Meldung Vertrauen braucht.*
+        */
+        merkeSitzung(sitzungJetzt());
+        if (!sollHeuteLaufen(leseWacheDatei(), heute))
+            return 0;
+        const anmeldung = leseAnmeldung();
+        if (anmeldung === null)
+            return 0;
+        const [vomServer, vonNpm] = await Promise.all([
+            frageServer(anmeldung.schluessel, heute),
+            neuesteVonNpm(ZEITGRENZE_MS),
+        ]);
+        const zeilen = wacheZeilen({
+            zugangGilt: vomServer.zugangGilt,
+            nachricht: vomServer.hinweis?.text ?? null,
+            eigeneVersion: eigeneVersion(),
+            neuesteVersion: vonNpm,
+            skillVeraltet: skillIstVeraltet(),
+        });
+        // 🔴 VOR der Ausgabe -- sonst spricht die Wache bei einem Fehler in der
+        // Ausgabe morgen wieder und uebermorgen wieder.
+        merkeLauf(heute);
+        if (zeilen.length === 0)
+            return 0; // 🔴 Stille heisst WIRKLICH nichts --
+        // auch keine leere Kopfzeile.
+        console.log("🔑 kimal3");
+        for (const z of zeilen)
+            console.log(`• ${z}`);
+        // Erst NACH dem Drucken vermerken, dass die Nachricht heute schon lief --
+        // dieselbe Reihenfolge wie beim Update-Kanal in kimal3.ts.
+        if (vomServer.hinweis)
+            merkeGesehen(vomServer.hinweis.id, heute);
+        return 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Der Schalter: `kimal3 wache aus` / `kimal3 wache an`.
+ *
+ * 🔑 EIGENE, DRUCKENDE HUELLE UM `setzeWache`: Die reine Datei-Rechnung in
+ * `wache-schalter.ts` gibt weder eine Zahl zurueck noch sagt sie dem
+ * Menschen etwas -- der Verteiler in `kimal3.ts` braucht beides.
+ */
+export function wacheSchalten(an) {
+    setzeWache(an);
+    console.log(an ? "✓ Wache eingeschaltet." : "✓ Wache ausgeschaltet.");
+    return 0;
+}

package/dist/befehle-katalog.js

@@ -177,6 +177,26 @@ export const BEFEHLE = [
             "⚠️ Es sind personenbezogene Daten von Kolleginnen und Kollegen. Für den Einsatz in einer echten Firma braucht es ein kommerzielles Claude-Konto mit Auftragsverarbeitungsvertrag; werden Leistungen von Beschäftigten ausgewertet, ist das in Deutschland mitbestimmungspflichtig.",
         ],
     },
+    /*
+      🔴 Dieser Eintrag steht bewusst NICHT im "Weg, den ein Mensch geht" --
+      niemand muss ihn selbst tippen. Er wird beim Start von Claude Code einmal
+      am Tag von selbst aufgerufen (Aufgabe 8) und steht hier trotzdem, weil
+      `tippen()` in `wache-rechnung.ts` seine `!`-Schreibweise braucht, wenn die
+      Wache selbst einmal auf ihren eigenen Befehl verweisen muss.
+    */
+    {
+        befehl: "kimal3 wache",
+        beschreibung: "Nachsehen, ob dein Zugang gilt und ob etwas anliegt",
+        wer: "du",
+        rhythmus: "einmal am Tag, von selbst",
+        tippen: "! kimal3 wache",
+        terminal: "kimal3 wache",
+        details: [
+            "Läuft von selbst, einmal am Tag beim Start von Claude Code — du musst ihn nicht selbst aufrufen.",
+            "Bleibt sie still, ist alles in Ordnung: keine Zeile heißt kein Problem. Sie meldet sich nur, wenn dein Zugang abgelaufen ist, eine Nachricht anliegt, eine neue Version bereitsteht oder deine Skill-Dateien veraltet sind.",
+            "Erreicht sie unseren Server nicht, schweigt sie zu Zugang und Nachricht — meldet aber trotzdem eine neue Version, falls npm eine kennt. Die beiden Fragen hängen nicht aneinander.",
+        ],
+    },
     {
         befehl: "kimal3 logout",
         beschreibung: "Verbindung wieder aufheben",

package/dist/einstellungen-mischen.js

@@ -0,0 +1,124 @@
+/**
+ * Traegt die Wache in die Claude-Einstellungen eines Kunden ein -- ohne
+ * kaputtzumachen, was dort sonst steht.
+ *
+ * 🔴 DIESE DATEI FASST KEINE DATEI AN. Sie nimmt Text und gibt Text zurueck.
+ * Nur so laesst sie sich pruefen: In `~/.claude/settings.json` stehen die
+ * Startbefehle des Menschen, sein Statusbalken, seine Berechtigungen und seine
+ * Modellwahl -- ein Pruefgeraet, das man kaputt machen kann, ist der
+ * Arbeitsplatz des Menschen. Das Lesen und Schreiben wohnt in
+ * `befehle/skill-install.ts`, samt Sicherungskopie und Zurueckkontrolle.
+ */
+/**
+ * Der Befehl, der in die Einstellungen eingetragen wird.
+ *
+ * 🔴 NUR EIN BEFEHL, keine Kommandozeilen-Zeichen -- kein `||`, kein `2>/dev/null`.
+ * 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
+ * des Kunden.*
+ */
+export const WACHE_BEFEHL = "kimal3 wache";
+/**
+ * Wie lange Claude auf die Wache wartet, in Sekunden.
+ *
+ * 🔑 Die Wache fragt mit 1,5 Sekunden Zeitgrenze bei uns und bei npm nach --
+ * zehn Sekunden sind also weit jenseits des Normalfalls und trotzdem eine
+ * harte Obergrenze. *Ein Startbefehl, der haengt, haelt den Menschen von
+ * seiner Arbeit ab -- und ausgerechnet unserer soll ihm helfen.*
+ */
+export const WACHE_ZEITGRENZE = 10;
+function istObjekt(wert) {
+    return typeof wert === "object" && wert !== null && !Array.isArray(wert);
+}
+/**
+ * Ist das ein Eintrag, den WIR frueher einmal geschrieben haben?
+ *
+ * 🔴 WARUM DAS NOETIG IST: Aendert sich der Befehlstext spaeter (ein Argument
+ * kommt dazu, der Name wird laenger), wuerde ein blosses Anhaengen den alten
+ * Eintrag stehen lassen. Der Kunde riefe dann bei jedem Claude-Start zwei
+ * Wachen auf, und die alte zeigte auf etwas, das es nicht mehr gibt. Weder
+ * Compiler noch Waechter faenden das -- es sieht ja aus wie ein fremder
+ * Eintrag, den man hoeflich in Ruhe laesst.
+ */
+function istUnserer(eintrag) {
+    if (!istObjekt(eintrag))
+        return false;
+    return typeof eintrag.command === "string" && eintrag.command.includes(WACHE_BEFEHL);
+}
+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 vorher = JSON.stringify(gelesen);
+    const hooks = gelesen.hooks === undefined ? {} : gelesen.hooks;
+    if (!istObjekt(hooks))
+        return { art: "abgelehnt", grund: "fremde-form" };
+    const bisher = hooks.SessionStart === undefined ? [] : hooks.SessionStart;
+    if (!Array.isArray(bisher))
+        return { art: "abgelehnt", grund: "fremde-form" };
+    /*
+      🔴 GEFILTERT WIRD AUF DER INNEREN EBENE, nicht auf der aeusseren.
+      Ein Eintrag unter `SessionStart` ist eine Gruppe, die MEHRERE Befehle
+      tragen kann. Wer die ganze Gruppe wegwirft, weil ein Befehl darin unserer
+      ist, loescht die fremden Befehle daneben gleich mit -- und nichts sagt es
+      dem Menschen. Uebrig bleibt die Gruppe nur, wenn nach dem Filtern noch
+      etwas darin steht.
+    */
+    const fremde = [];
+    for (const gruppe of bisher) {
+        if (!istObjekt(gruppe) || !Array.isArray(gruppe.hooks)) {
+            // Etwas, das wir nicht verstehen, bleibt unveraendert stehen.
+            fremde.push(gruppe);
+            continue;
+        }
+        const behalten = gruppe.hooks.filter((h) => !istUnserer(h));
+        if (behalten.length === 0)
+            continue;
+        fremde.push({ ...gruppe, hooks: behalten });
+    }
+    const neu = {
+        ...gelesen,
+        hooks: {
+            ...hooks,
+            SessionStart: [
+                ...fremde,
+                { hooks: [{ type: "command", command: befehl, timeout: WACHE_ZEITGRENZE }] },
+            ],
+        },
+    };
+    /*
+      Steht danach genau dasselbe da wie vorher, gibt es nichts zu schreiben.
+      🔑 Warum das mehr ist als Sparsamkeit: Jedes Schreiben ist eine Gelegenheit,
+      die Datei zu beschaedigen. Ein Lauf, der nichts zu tun hat, soll sie auch
+      nicht anfassen.
+    */
+    const nachher = JSON.stringify(neu);
+    if (!leer && nachher === vorher)
+        return { art: "unveraendert" };
+    return { art: "geschrieben", inhalt: JSON.stringify(neu, null, 2) + "\n" };
+}