kimal3 0.2.2 → 0.2.3

package/dist/einstellungen-schreiben.js

@@ -0,0 +1,88 @@
+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";
+export function einstellungenDatei() {
+    return join(homedir(), ".claude", "settings.json");
+}
+export function sicherungsDatei() {
+    return einstellungenDatei() + ".kimal3-sicherung";
+}
+export function trageWacheEin() {
+    const datei = einstellungenDatei();
+    const gabEsSchon = existsSync(datei);
+    // --- Schritt 1: lesen ---
+    let alt = null;
+    if (gabEsSchon) {
+        try {
+            alt = readFileSync(datei, "utf8");
+        }
+        catch (e) {
+            /*
+              🔴 NICHT als "keine Datei" behandeln. Eine Datei, die es gibt und die
+              wir nicht lesen koennen, ist etwas anderes als eine, die es nicht gibt
+              -- wer beide gleich behandelt, legt eine neue an und der Mensch
+              verliert alles, was drinstand.
+            */
+            return { art: "gescheitert", grund: `nicht lesbar (${e.message})` };
+        }
+    }
+    const ergebnis = mischeEinstellungen(alt, WACHE_BEFEHL);
+    if (ergebnis.art === "abgelehnt")
+        return { art: "abgelehnt", grund: ergebnis.grund };
+    if (ergebnis.art === "unveraendert")
+        return { art: "stand-schon" };
+    // --- Schritt 2: Sicherungskopie ---
+    if (gabEsSchon) {
+        try {
+            copyFileSync(datei, sicherungsDatei());
+        }
+        catch (e) {
+            /*
+              🔴 OHNE SICHERUNG WIRD NICHT GESCHRIEBEN. Der ganze Sinn von Schritt 4
+              ist, im Fehlerfall zurueckzukoennen -- ohne Kopie gibt es kein Zurueck,
+              und dann ist Schreiben die schlechtere Wahl als Nichtstun.
+            */
+            return { art: "gescheitert", grund: `keine Sicherungskopie moeglich (${e.message})` };
+        }
+    }
+    // --- Schritt 3: schreiben ---
+    try {
+        mkdirSync(join(homedir(), ".claude"), { recursive: true });
+        writeFileSync(datei, ergebnis.inhalt, "utf8");
+    }
+    catch (e) {
+        zurueck(gabEsSchon);
+        return { art: "gescheitert", grund: `nicht schreibbar (${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) {
+            throw new Error("unser Eintrag steht nicht in der zurueckgelesenen Datei");
+        }
+    }
+    catch (e) {
+        zurueck(gabEsSchon);
+        return { art: "gescheitert", grund: `Kontrolle nach dem Schreiben fehlgeschlagen (${e.message})` };
+    }
+    return { art: "eingetragen" };
+}
+/**
+ * Die Sicherung zurueckspielen.
+ *
+ * ⚠️ Gab es vorher KEINE Datei, gibt es auch nichts zurueckzuspielen -- dann
+ * bleibt die halb geschriebene stehen. Das ist die harmlose Seite: Sie
+ * enthielt vorher nichts, was jemandem gehoerte.
+ */
+function zurueck(gabEsSchon) {
+    if (!gabEsSchon)
+        return;
+    try {
+        copyFileSync(sicherungsDatei(), einstellungenDatei());
+    }
+    catch {
+        /* Mehr koennen wir nicht tun -- der Grund steht in der Meldung oben. */
+    }
+}

package/dist/kimal3.js

@@ -15,6 +15,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
 import { gemerkterHinweis, lokalerKontextStandJetzt, NichtAngemeldet } from "./api.js";
 import { leseGesehen, merkeGesehen } from "./gesehen.js";
+import { ausfallMeldung, hinweisAnhaengen } from "./wache-rechnung.js";
+import { leseWacheDatei, sitzungJetzt, wacheAusgefallen } from "./wache-schalter.js";
 import { formatiere, heuteAus, skillMeldung, skillZustand, sollZeigen, } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
 import { hilfeText } from "./befehle-katalog.js";
@@ -29,6 +31,7 @@ import { logout } from "./befehle/logout.js";
 import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { skillDatei, skillInstall } from "./befehle/skill-install.js";
+import { wache, wacheSchalten } from "./befehle/wache.js";
 // 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
 // `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
 // Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten
@@ -146,6 +149,28 @@ function hinweisText() {
                 return { text: skillMeldung(), kennung: "skill-veraltet", tag: heute };
             }
         }
+        /*
+          Weg 3: hat die Wache fuer diese Claude-Sitzung ueberhaupt nachgesehen?
+    
+          🔴 WARUM DAS DER LETZTE WEG IST, nicht der erste: Die beiden
+          oberen nennen etwas, das JETZT zu tun ist -- eine Nachricht von uns, ein
+          veralteter Befehlssatz. Dies hier ist eine Aussage ueber das Werkzeug
+          selbst. Es steht deshalb hinten und erscheint an den meisten Tagen als
+          Einziges, weil sonst nichts anliegt.
+    
+          WARUM ES DAS UEBERHAUPT GIBT: Ein Startbefehl, dessen Programm fehlt
+          oder abstuerzt, laermt nicht -- gemessen mit Gegenprobe (M-0). Ohne
+          diese Zeilen sieht ein Tag mit toter Wache genauso aus wie einer, an dem
+          alles in Ordnung ist. *Eine Wache, die still stirbt, kauft Vertrauen und
+          deckt nichts mehr.*
+        */
+        if (wacheAusgefallen(leseWacheDatei(), sitzungJetzt())) {
+            // Auch dieser Hinweis hoechstens einmal am Tag, unter fester Kennung.
+            const gesehen = leseGesehen();
+            if (gesehen["wache-ausgefallen"] !== heute) {
+                return { text: ausfallMeldung(), kennung: "wache-ausgefallen", tag: heute };
+            }
+        }
     }
     catch {
         /* Ein Nebenschauplatz darf den Befehl nicht umwerfen. */
@@ -182,7 +207,10 @@ function endeMitHinweis(code) {
           verbrauchte den EINEN Platz des Tages. Wer sich vertippt und danach
           richtig tippt, saehe die Nachricht dann heute gar nicht mehr.
         */
-        const raus = code === 0 ? hinweisText() : null;
+        // 🔴 `hinweisAnhaengen` entscheidet, ob dieser Befehl den allgemeinen
+        // Kanal ueberhaupt bekommt -- `kimal3 wache` bekommt ihn nicht, weil
+        // sie ihre Zeilen selbst und in der richtigen Schreibweise sagt.
+        const raus = code === 0 && hinweisAnhaengen(process.argv.slice(2)) ? hinweisText() : null;
         /*
           🔴 BEIDE KANAELE LEEREN, NICHT NUR STDERR. Die erste Fassung dieser
           Funktion sicherte stderr -- und liess den haeufigeren Weg (kein Hinweis)
@@ -306,6 +334,12 @@ async function haupt() {
         return kontextHoch(argv.slice(2));
     if (argv[0] === "kontext" && argv[1] === "fragen")
         return kontextFragen(argv.slice(2));
+    if (wort === "wache")
+        return wache();
+    if (wort === "wache aus")
+        return wacheSchalten(false);
+    if (wort === "wache an")
+        return wacheSchalten(true);
     console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);
     return 1;
 }

package/dist/wache-rechnung.js

@@ -0,0 +1,139 @@
+import { istAelter, istVersionsstand } from "./nachricht.js";
+import { BEFEHLE } from "./befehle-katalog.js";
+/**
+ * Den Befehl in der Schreibweise holen, in der man ihn dort eintippt, wo man
+ * ihn liest -- die Wache spricht immer durch Claude Code, also mit `!`.
+ *
+ * 🔴 KEIN ERSATZWERT AUS DER LUFT. Steht der Befehl nicht im Katalog, ist das
+ * ein Fehler beim Bauen und keiner, den der Kunde ausbaden soll; check:wache
+ * faengt ihn, weil die Zeile dann den erwarteten Text nicht enthaelt.
+ */
+function tippen(befehl) {
+    const eintrag = BEFEHLE.find((b) => b.befehl === befehl);
+    return eintrag ? eintrag.tippen : befehl;
+}
+export function wacheZeilen(lage) {
+    // 🔴 Ausgeloggt: NUR diese eine Zeile. Die anderen beiden waeren durchaus
+    // beantwortbar (npm fragt ohne Anmeldung, der Skill-Stempel liegt auf der
+    // Platte) -- sie werden trotzdem unterdrueckt. Wer ausgeloggt ist, hat genau
+    // eine Aufgabe; zwei weitere Ratschlaege daneben begraben sie.
+    if (!lage.zugangGilt) {
+        return [
+            "Dein Zugang ist abgelaufen — das passiert nach längerer Pause. " +
+                `Neu anmelden:  ${tippen("kimal3 login")}`,
+        ];
+    }
+    const zeilen = [];
+    if (lage.nachricht !== null) {
+        zeilen.push(`Nachricht von kimal3: „${lage.nachricht}“`);
+    }
+    // Beide Nummern muessen da UND gueltig sein. Fehlt eine, wird geschwiegen --
+    // nicht geraten.
+    if (lage.eigeneVersion !== null && lage.neuesteVersion !== null &&
+        istVersionsstand(lage.eigeneVersion) && istVersionsstand(lage.neuesteVersion) &&
+        istAelter(lage.eigeneVersion, lage.neuesteVersion)) {
+        zeilen.push(`Es gibt eine neuere Version: ${lage.neuesteVersion} (du hast ${lage.eigeneVersion}). ` +
+            `Holen mit:  ! npm install -g kimal3@${lage.neuesteVersion}`);
+    }
+    if (lage.skillVeraltet) {
+        zeilen.push("Deine /k3-Befehle in Claude sind aus einer älteren Version. " +
+            `Auffrischen:  ${tippen("kimal3 skill install")}`);
+    }
+    return zeilen;
+}
+/**
+ * Zieht den Hinweis aus der Antwort von `/api/cli/wache` -- unter dem Feld
+ * `nachricht`, nicht `hinweis` wie beim allgemeinen Update-Kanal in `api.ts`.
+ *
+ * 🔑 WARUM EIN EIGENES FELD UND KEINE ZWEITVERWENDUNG VON `hinweisAusAntwort`:
+ * Die Wache ist ein EIGENER, zweiter Kanal (US-1 der Wache-Spec) -- ihre
+ * Antwort traegt die Nachricht deshalb absichtlich unter einem anderen
+ * Namen als der Kanal, den `ruf()` bei jedem anderen Befehl mitliest. Zwei
+ * Kanaele, die zufaellig denselben Feldnamen teilten, koennten sich sonst
+ * gegenseitig fuellen.
+ */
+export function nachrichtAusAntwort(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const roh = koerper.nachricht;
+    if (!roh || typeof roh !== "object")
+        return null;
+    const h = roh;
+    if (typeof h.id !== "string" || typeof h.text !== "string")
+        return null;
+    return {
+        id: h.id,
+        text: h.text,
+        gilt_unter_version: typeof h.gilt_unter_version === "string" ? h.gilt_unter_version : null,
+    };
+}
+/**
+ * Was der HTTP-Status von `/api/cli/wache` bedeutet -- getrennt von allem,
+ * was Netz oder Zeitgrenze braucht, damit sich die drei Faelle ohne Warten
+ * oder Verbiegen pruefen lassen: gilt, widerrufen, Serverfehler.
+ *
+ * 🔴 NUR `401` HEISST "WIDERRUFEN". Jeder andere Nicht-Erfolg (`500`, ein
+ * verstuemmeltes JSON, ein Feld, das fehlt) heisst "wir wissen es nicht" und
+ * bekommt deshalb `zugangGilt: true` -- dieselbe Regel wie bei `istAelter`:
+ * Im Zweifel schweigen ist bei einem Nebenschauplatz die richtige Vorgabe.
+ * Wuerde stattdessen `false` zurueckkommen, zeigte ein simpler Aussetzer des
+ * EIGENEN Servers dieselbe Zeile wie ein wirklich widerrufener Ausweis --
+ * und `wacheZeilen` wuerde dabei zusaetzlich die Fassungs- und Skill-Zeile
+ * mit unterdruecken, die von diesem Ausfall gar nicht betroffen sind.
+ */
+export function wacheAntwortAusHttp(status, koerper) {
+    if (status === 401)
+        return { zugangGilt: false, hinweis: null };
+    if (status !== 200)
+        return { zugangGilt: true, hinweis: null };
+    return { zugangGilt: true, hinweis: nachrichtAusAntwort(koerper) };
+}
+/**
+ * Die Zeile, die erscheint, wenn die Wache fuer diese Claude-Sitzung nicht
+ * nachgesehen hat.
+ *
+ * 🔴 SIE NENNT BEIDE WEGE -- den zurueck UND den hinaus. Eine Meldung, die
+ * man nicht abstellen kann, wird nach der dritten Wiederholung zur Wand, und
+ * dann liest niemand mehr die, auf die es ankommt.
+ *
+ * 🔑 MIT AUSRUFEZEICHEN: Diese Zeile erscheint ausschliesslich in Claude --
+ * sie wird ja nur gezeigt, wenn eine Sitzungsnummer da ist. Wer sie liest,
+ * sitzt in dem Fenster, in dem `!` der richtige Anfang ist.
+ */
+export function ausfallMeldung() {
+    return ("Die tägliche kimal3-Prüfung hat für diese Claude-Sitzung nicht nachgesehen. " +
+        `Neu eintragen:  ${tippen("kimal3 skill install")}` +
+        /*
+          🔴 `kimal3 wache aus` steht NICHT im Katalog -- dort steht nur
+          `kimal3 wache`. `tippen()` gibt bei einem unbekannten Befehl den Text
+          unveraendert zurueck, also OHNE das Ausrufezeichen: Der Mensch tippt in
+          Claude etwas ab, das dort nicht laeuft. Gefunden am 2026-09-08 in der
+          Live-Messung, NICHT von der Pruefung -- die fragte nur, ob irgendwo ein
+          `! kimal3` vorkommt, und das stimmte wegen der Zeile darueber.
+          Deshalb: die Schreibweise vom Katalog holen, das Wort `aus` anhaengen.
+        */
+        `  ·  Dauerhaft abstellen:  ${tippen("kimal3 wache")} aus`);
+}
+/**
+ * Soll der allgemeine Update-Hinweis an diesen Befehl angehaengt werden?
+ *
+ * 🔴 BEI `kimal3 wache` NICHT -- gefunden in der Live-Messung am 2026-09-08,
+ * nachdem die Route live ging. Die Wache sagt bei abgelaufenem Zugang
+ * absichtlich GENAU EINE Zeile ("wer ausgeloggt ist, hat genau eine Aufgabe;
+ * zwei weitere Ratschlaege daneben begraben sie"). Der allgemeine Kanal haengt
+ * trotzdem seine eigene Zeile darunter -- und macht damit genau das kaputt,
+ * wofuer die Beschraenkung gebaut wurde.
+ *
+ * ⚠️ UND ER SCHREIBT SIE IN DER FALSCHEN FORM. Der allgemeine Hinweis ist fuer
+ * ein Terminalfenster gedacht und nennt `kimal3 skill install` ohne
+ * Ausrufezeichen. Die Wache laeuft aber ausschliesslich in Claude, wo dieselbe
+ * Zeile `! kimal3 skill install` heissen muss. *Der Mensch haette etwas
+ * abgetippt, das dort nicht laeuft.*
+ *
+ * 🔑 Und es geht nichts verloren: Die beiden Faelle des allgemeinen Kanals --
+ * neue Fassung, veralteter Skill -- sagt die Wache ohnehin selbst, in der
+ * richtigen Schreibweise und mit besserem Wortlaut.
+ */
+export function hinweisAnhaengen(argv) {
+    return argv[0] !== "wache";
+}

package/dist/wache-schalter.js

@@ -0,0 +1,149 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Der Ausschalter und der Tages-Merkzettel der Wache: "aus" (fuer immer
+ * schweigen) und "zuletzt" (heute schon gelaufen) wohnen in DERSELBEN Datei.
+ *
+ * 🔑 WARUM BEIDES ZUSAMMEN: Beides sind reine Zustandsfragen ueber denselben
+ * Merkzettel -- eine zweite Datei wuerde nur eine zweite Stelle schaffen, an
+ * der beide synchron bleiben muessten.
+ *
+ * 🔴 ALLE VIER FUNKTIONEN MIT DATEIZUGRIFF WERFEN NIE (Vorbild: gesehen.ts).
+ * Ein kaputter, fehlender oder schreibgeschuetzter Merkzettel darf keinen
+ * Claude-Start umwerfen.
+ */
+const ORDNER = join(homedir(), ".kimal3");
+const DATEI = join(ORDNER, "wache.json");
+/** Der rohe Inhalt des Merkzettels, oder null. Wirft nie. */
+export function leseWacheDatei() {
+    try {
+        const roh = JSON.parse(readFileSync(DATEI, "utf8"));
+        if (!roh || typeof roh !== "object" || Array.isArray(roh))
+            return null;
+        const inhalt = roh;
+        const raus = {};
+        if (typeof inhalt.aus === "boolean")
+            raus.aus = inhalt.aus;
+        if (typeof inhalt.zuletzt === "string")
+            raus.zuletzt = inhalt.zuletzt;
+        if (typeof inhalt.sitzung === "string")
+            raus.sitzung = inhalt.sitzung;
+        return raus;
+    }
+    catch {
+        return null;
+    }
+}
+function schreibeWacheDatei(inhalt) {
+    try {
+        // ⚠️ `mode: 0o700` wie in gesehen.ts -- `mkdirSync` mit `recursive: true`
+        // aendert die Rechte eines schon bestehenden Ordners NICHT. Wer diesen
+        // Ordner zuerst anlegt, legt seine Rechte fuer immer fest.
+        mkdirSync(ORDNER, { recursive: true, mode: 0o700 });
+        writeFileSync(DATEI, JSON.stringify(inhalt, null, 2), "utf8");
+    }
+    catch {
+        /* Merkzettel nicht schreibbar -- der Befehl laeuft trotzdem durch. */
+    }
+}
+/** Ist die Wache dauerhaft abgeschaltet? Wirft nie. */
+export function wacheIstAus() {
+    return leseWacheDatei()?.aus === true;
+}
+/** Wache an- oder abschalten. Der Tages-Merkzettel ("zuletzt") bleibt erhalten. */
+export function setzeWache(an) {
+    const bisher = leseWacheDatei() ?? {};
+    schreibeWacheDatei({ ...bisher, aus: !an });
+}
+/** Ist die Wache heute schon gelaufen? Wirft nie. */
+export function schonGelaufenAm(heute) {
+    return leseWacheDatei()?.zuletzt === heute;
+}
+/** Merken, dass die Wache heute gelaufen ist. Der Ausschalter bleibt erhalten. */
+export function merkeLauf(heute) {
+    const bisher = leseWacheDatei() ?? {};
+    schreibeWacheDatei({ ...bisher, zuletzt: heute });
+}
+/**
+ * Laeuft die Wache heute?
+ *
+ * 🔴 REIN und ohne Dateisystem, damit sie geprueft werden kann -- "heute schon
+ * gelaufen" und "abgeschaltet" gibt es in der echten Welt nur durch Warten
+ * oder Verbiegen.
+ *
+ * 🔴 Bei Muell im Merkzettel lautet die Antwort JA. Der umgekehrte Fehler
+ * waere teurer: Eine Wache, die wegen einer kaputten Datei fuer immer
+ * schweigt, sieht genauso aus wie eine, bei der alles in Ordnung ist.
+ */
+export function sollHeuteLaufen(inhalt, heute) {
+    if (inhalt !== null && inhalt.aus === true)
+        return false;
+    if (inhalt !== null && typeof inhalt.zuletzt === "string" && inhalt.zuletzt === heute) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Die Nummer der Claude-Sitzung, in der dieser Aufruf gerade laeuft -- oder
+ * `null`, wenn kein Claude im Spiel ist.
+ *
+ * 🔑 WOFUER: Claude gibt jeder Sitzung eine eigene Nummer und reicht sie an
+ * jedes Programm weiter, das es startet. Damit laesst sich exakt beantworten,
+ * ob die Wache FUER DIESE SITZUNG nachgesehen hat. Ohne sie muesste man den
+ * TAG vergleichen -- und "zuletzt vor drei Tagen" hat zwei Ursachen: Die
+ * Wache ist kaputt, oder der Mensch hat einfach nichts gemacht. *Ein Wert,
+ * der zwei Wirklichkeiten traegt, ist genau die Krankheit, gegen die die
+ * Wache gebaut ist.*
+ *
+ * 📌 Gemessen am 2026-09-08 (docs/qa/2026-09-08-wache-messungen.md, M-0b):
+ * Der Startbefehl sieht dieselbe Nummer wie die laufende Sitzung, eine zweite
+ * Sitzung bekommt eine andere, und der getippte Weg mit `!` sieht sie auch.
+ * ⚠️ Gemessen auf einem Rechner, in einer Claude-Fassung. Fehlt sie beim
+ * Kunden, ist die Antwort `null` -- und dann schweigt die Erkennung, statt zu
+ * raten. Die harmlose Seite.
+ */
+export function sitzungJetzt() {
+    const roh = process.env.CLAUDE_CODE_SESSION_ID;
+    return typeof roh === "string" && roh.trim() !== "" ? roh : null;
+}
+/** Merken, fuer welche Claude-Sitzung zuletzt nachgesehen wurde. Wirft nie. */
+export function merkeSitzung(sitzung) {
+    if (sitzung === null)
+        return;
+    const bisher = leseWacheDatei() ?? {};
+    schreibeWacheDatei({ ...bisher, sitzung });
+}
+/**
+ * Ist die Wache fuer diese Claude-Sitzung ausgefallen?
+ *
+ * 🔴 REIN und ohne Umgebung, damit sie geprueft werden kann -- "eine andere
+ * Sitzung hat zuletzt nachgesehen" gibt es in der Wirklichkeit nur durch
+ * Claude-Neustarts.
+ *
+ * WARUM ES DIESE FRAGE UEBERHAUPT GIBT: Ein Startbefehl, dessen Programm
+ * fehlt oder abstuerzt, laermt nicht (gemessen, M-0). Der Bildschirm sieht
+ * 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:
+ *   - Keine Sitzungsnummer -> der Mensch sitzt im Terminalfenster, die Wache
+ *     hatte nie einen Anlass zu laufen. "Nicht gelaufen" heisst hier nichts.
+ *   - 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.
+ * Nur wenn eine Sitzung laeuft, die Wache angeschaltet ist und trotzdem
+ * niemand fuer sie nachgesehen hat, ist wirklich etwas kaputt.
+ */
+export function wacheAusgefallen(
+// Der GANZE Merkzettel, nicht nur die zwei Felder, die diese Rechnung liest.
+// `zuletzt` interessiert sie nicht -- aber ein Merkzettel aus einer aelteren
+// 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)
+        return false;
+    if (inhalt !== null && inhalt.aus === true)
+        return false;
+    return inhalt === null || inhalt.sitzung !== jetzt;
+}

package/package.json

@@ -1,27 +1,27 @@
-{
-  "name": "kimal3",
-  "version": "0.2.2",
-  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.",
-  "type": "module",
-  "bin": {
-    "kimal3": "dist/kimal3.js"
-  },
-  "files": [
-    "dist",
-    "skill",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "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.2.3",
+  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.",
+  "type": "module",
+  "bin": {
+    "kimal3": "dist/kimal3.js"
+  },
+  "files": [
+    "dist",
+    "skill",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "kimal3",
+    "cli"
+  ],
+  "homepage": "https://app.kimal3.de/pro",
+  "license": "SEE LICENSE IN README.md"
+}