kimal3 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# 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
+
+Zwei Befehle, einmal pro Rechner:
+
+```bash
+npx kimal3 login          # diesen Rechner mit deinem Konto verbinden
+npx kimal3 skill install  # Claude beibringen, das Werkzeug zu benutzen
+```
+
+`login` zeigt dir einen achtstelligen Code und öffnet den Browser. Dort bestätigst du
+ihn 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 logout             Verbindung wieder aufheben
+kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
+kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
+kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen
+```
+
+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.
+
+## 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

@@ -0,0 +1,55 @@
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Wo die App wohnt. Ueberschreibbar fuers lokale Entwickeln:
+ *   KIMAL3_URL=http://localhost:3000 npx kimal3 projekt liste
+ */
+export const BASIS_URL = process.env.KIMAL3_URL ?? "https://kimal3-app.vercel.app";
+const ORDNER = join(homedir(), ".kimal3");
+const DATEI = join(ORDNER, "anmeldung.json");
+export function leseAnmeldung() {
+    try {
+        const roh = JSON.parse(readFileSync(DATEI, "utf8"));
+        if (roh && typeof roh === "object" && "schluessel" in roh && "email" in roh) {
+            const a = roh;
+            if (typeof a.schluessel === "string" && typeof a.email === "string") {
+                return { schluessel: a.schluessel, email: a.email };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ⚠️ `chmod 0600` wirkt auf Mac/Linux. Auf Windows ist die Datei durch das
+ * Nutzerprofil geschuetzt, nicht durch diese Zeile — dort ist sie wirkungslos,
+ * aber auch nicht schaedlich. Beides gehoert in den Handtest.
+ *
+ * 🔑 Die Rechte stehen im `mode` der ERZEUGUNG, nicht in einem `chmod`
+ * danach (Review-Befund 2026-08-13): `writeFileSync` legt die Datei sonst mit
+ * 0644 an, und bis der `chmod` greift, ist der Ausweis auf einem
+ * Mehrbenutzer-Linux fuer alle lesbar. Ein Fenster von Millisekunden ist ein
+ * Fenster. Der `chmod` bleibt trotzdem stehen — er greift auch dann, wenn die
+ * Datei schon existierte und der `mode` deshalb ignoriert wird.
+ */
+export function schreibeAnmeldung(a) {
+    mkdirSync(ORDNER, { recursive: true, mode: 0o700 });
+    writeFileSync(DATEI, JSON.stringify(a, null, 2), { encoding: "utf8", mode: 0o600 });
+    try {
+        chmodSync(DATEI, 0o600);
+    }
+    catch { /* Windows */ }
+}
+export function loescheAnmeldung() {
+    try {
+        rmSync(DATEI);
+    }
+    catch { /* war schon weg */ }
+}
+/** Nur fuer Meldungen an den Menschen — damit er weiss, wo die Datei liegt. */
+export function anmeldungsPfad() {
+    return DATEI;
+}

package/dist/api.js

@@ -0,0 +1,51 @@
+import { BASIS_URL, leseAnmeldung } from "./anmeldung.js";
+export class NichtAngemeldet extends Error {
+    constructor() { super("nicht angemeldet"); }
+}
+/**
+ * Ein Aufruf gegen die App. `mitAusweis` haengt den Schluessel an.
+ *
+ * Netzfehler werden NICHT zu einem Status 0 verbogen — sie werfen, und der
+ * Verteiler in kimal3.ts macht daraus Rueckgabewert 3. Ein Netzfehler ist
+ * etwas anderes als eine Absage vom Server, und wer beides gleich behandelt,
+ * schickt Menschen zur falschen Fehlersuche.
+ */
+export async function ruf(pfad, optionen = {}) {
+    const kopf = {};
+    if (optionen.mitAusweis) {
+        const a = leseAnmeldung();
+        if (!a)
+            throw new NichtAngemeldet();
+        kopf.Authorization = `Bearer ${a.schluessel}`;
+    }
+    const methode = optionen.methode ?? "POST";
+    // Content-Type nur, wenn wirklich etwas im Rumpf steht. Ein GET mit
+    // "Content-Type: application/json" und ohne Rumpf ist eine Luege ueber die
+    // eigene Anfrage — manche Server nehmen das uebel.
+    if (methode === "POST")
+        kopf["Content-Type"] = "application/json";
+    const antwort = await fetch(`${BASIS_URL}${pfad}`, {
+        method: methode,
+        headers: kopf,
+        body: methode === "POST" ? JSON.stringify(optionen.koerper ?? {}) : undefined,
+    });
+    return { status: antwort.status, koerper: await antwort.json().catch(() => null) };
+}
+/** Holt ein Textfeld aus einer Antwort, ohne `any`. */
+export function feld(koerper, name) {
+    if (koerper && typeof koerper === "object" && name in koerper) {
+        const w = koerper[name];
+        if (typeof w === "string")
+            return w;
+    }
+    return null;
+}
+/** Dasselbe fuer eine Liste von Texten (fuer `projekt liste`). */
+export function textListe(koerper, name) {
+    if (koerper && typeof koerper === "object" && name in koerper) {
+        const w = koerper[name];
+        if (Array.isArray(w) && w.every((x) => typeof x === "string"))
+            return w;
+    }
+    return null;
+}

package/dist/argumente.js

@@ -0,0 +1,39 @@
+/**
+ * Die Befehlszeile zerlegen — von Hand, weil `cli/` keine fremden
+ * Bibliotheken hat (Entscheidung aus Abschnitt A der Spec).
+ *
+ * Bewusst streng: Eine unbekannte Option ist ein FEHLER, kein stilles
+ * Uebergehen. Wer `--titl` tippt, soll es erfahren, statt ein Projekt ohne
+ * Titel anzulegen.
+ */
+export function zerlege(argv, erlaubt) {
+    const befehl = [];
+    const optionen = {};
+    for (let i = 0; i < argv.length; i++) {
+        const teil = argv[i];
+        if (!teil.startsWith("--")) {
+            if (Object.keys(optionen).length > 0) {
+                return { ok: false, meldung: `Nach Optionen kommt kein Befehlswort mehr: „${teil}".` };
+            }
+            befehl.push(teil);
+            continue;
+        }
+        const gleich = teil.indexOf("=");
+        const name = gleich === -1 ? teil.slice(2) : teil.slice(2, gleich);
+        if (!erlaubt.includes(name)) {
+            return { ok: false, meldung: `Die Option „--${name}" kenne ich nicht.` };
+        }
+        if (gleich !== -1) {
+            optionen[name] = teil.slice(gleich + 1);
+            continue;
+        }
+        const wert = argv[i + 1];
+        // Eine Zahl mit Minus ist ein Wert; "--irgendwas" ist die naechste Option.
+        if (wert === undefined || wert.startsWith("--")) {
+            return { ok: false, meldung: `Der Option „--${name}" fehlt ihr Wert.` };
+        }
+        optionen[name] = wert;
+        i++;
+    }
+    return { ok: true, werte: { befehl, optionen } };
+}

package/dist/befehle/login.js

@@ -0,0 +1,66 @@
+import { hostname } from "node:os";
+import { feld, ruf } from "../api.js";
+import { BASIS_URL, schreibeAnmeldung } from "../anmeldung.js";
+const warte = (ms) => new Promise((f) => setTimeout(f, ms));
+export async function login() {
+    const start = await ruf("/api/cli/login/start", { koerper: { bezeichnung: hostname() } });
+    const nutzerCode = feld(start.koerper, "nutzer_code");
+    const geraeteCode = feld(start.koerper, "geraete_code");
+    if (start.status !== 200 || !nutzerCode || !geraeteCode) {
+        console.error("kimal3 ist gerade nicht erreichbar.");
+        return 3;
+    }
+    console.log(`\n  Öffne ${BASIS_URL}/cli`);
+    console.log(`  und gib diesen Code ein:  ${nutzerCode}\n`);
+    console.log("  Warte auf die Bestätigung … (Abbruch mit Strg+C)");
+    const endeUm = Date.now() + 10 * 60 * 1000;
+    while (Date.now() < endeUm) {
+        await warte(2000);
+        // ⚠️ Diese Schleife laeuft per Definition zehn Minuten ueber ein Netz.
+        // Ein einzelner Aussetzer — Vercel-Kaltstart, kurzes 502, WLAN-Huepfer —
+        // darf die ganze Anmeldung nicht wegwerfen, waehrend der Mensch im
+        // Browser vielleicht gerade bestaetigt. Deshalb: weiterfragen statt
+        // abbrechen. Beendet wird nur bei einer EINDEUTIGEN Antwort.
+        // (Review-Befund 2026-08-13.)
+        let a;
+        try {
+            a = await ruf("/api/cli/login/abholen", { koerper: { geraete_code: geraeteCode } });
+        }
+        catch {
+            continue;
+        }
+        if (a.status === 202)
+            continue;
+        if (a.status >= 500)
+            continue;
+        if (a.status === 410) {
+            console.error("\nDer Anmeldecode ist abgelaufen. Bitte `kimal3 login` noch einmal.");
+            return 2;
+        }
+        // 🔴 Dieser Zweig MUSS hier oben stehen. Ohne ihn faellt eine 402 durch bis
+        // ans Ende und meldet "Das hat nicht geklappt." mit Rueckgabewert 3 --
+        // Genau die nichtssagende Meldung, die diese Schranke vermeiden soll: Der
+        // Mensch erfaehrt nicht, dass ihm ein Konto fehlt, sondern glaubt an einen
+        // Serverfehler.
+        //
+        // 🔑 Und sie kommt hier nur bei einer ECHTEN Absage an: Liess sich der Plan
+        // im Browser gar nicht nachsehen, bleibt der Zettel auf "wartet" — diese
+        // Schleife fragt also einfach weiter, statt aufzugeben. Genau dafuer ist
+        // sie da. (Review-Befund 2026-08-14, s. `src/app/cli/actions.ts`.)
+        if (a.status === 402) {
+            console.error(`\n${feld(a.koerper, "meldung") ?? "Dafür brauchst du ein Pro-Konto."}`);
+            return 4;
+        }
+        const schluessel = feld(a.koerper, "schluessel");
+        const email = feld(a.koerper, "email");
+        if (a.status === 200 && schluessel && email) {
+            schreibeAnmeldung({ schluessel, email });
+            console.log(`\n✓ Angemeldet als ${email}.`);
+            return 0;
+        }
+        console.error("\nDas hat nicht geklappt.");
+        return 3;
+    }
+    console.error("\nDer Anmeldecode ist abgelaufen. Bitte `kimal3 login` noch einmal.");
+    return 2;
+}

package/dist/befehle/logout.js

@@ -0,0 +1,33 @@
+import { leseAnmeldung, loescheAnmeldung } from "../anmeldung.js";
+import { ruf } from "../api.js";
+/**
+ * Abmelden — erst beim Server widerrufen, DANN die Datei loeschen.
+ *
+ * ⚠️ Die Reihenfolge ist der ganze Punkt: Loescht man zuerst, kennt niemand
+ * mehr den Schluessel, den man gerade widerrufen wollte. Er bliebe auf dem
+ * Server gueltig, und nichts wuerde davon berichten.
+ */
+export async function logout() {
+    const a = leseAnmeldung();
+    if (!a) {
+        // Kein Fehler: Der Zielzustand ist bereits erreicht. Deshalb 0.
+        console.log("Auf diesem Rechner war keine Anmeldung.");
+        return 0;
+    }
+    try {
+        const antwort = await ruf("/api/cli/logout", { mitAusweis: true });
+        if (antwort.status !== 200 && antwort.status !== 401) {
+            console.error("kimal3 ist gerade nicht erreichbar. Es wurde nichts geändert.");
+            return 3;
+        }
+        // 401 heisst: Der Schluessel gilt ohnehin nicht mehr (schon widerrufen
+        // oder abgelaufen). Der Zielzustand stimmt also — die Datei darf weg.
+    }
+    catch {
+        console.error("kimal3 ist gerade nicht erreichbar. Es wurde nichts geändert.");
+        return 3;
+    }
+    loescheAnmeldung();
+    console.log(`Abgemeldet. (${a.email})`);
+    return 0;
+}

package/dist/befehle/projekt-liste.js

@@ -0,0 +1,53 @@
+import { feld, ruf, textListe } from "../api.js";
+import { BASIS_URL } from "../anmeldung.js";
+/**
+ * Die eigenen Projekte anzeigen.
+ *
+ * 🔑 Wofuer das da ist: Damit Claude VOR dem Eintragen nachsehen kann. Ohne
+ * diesen Befehl steht dasselbe Projekt irgendwann zweimal auf einer
+ * oeffentlichen Seite mit dem Namen eines Menschen darauf.
+ */
+export async function projektListe() {
+    const antwort = await ruf("/api/cli/projekt", { methode: "GET", mitAusweis: true });
+    if (antwort.status === 200) {
+        const titel = textListe(antwort.koerper, "titel");
+        if (!titel) {
+            console.error("Das hat nicht geklappt.");
+            return 3;
+        }
+        // Eine leere Liste ist KEIN Fehler — sie ist eine gueltige Antwort auf
+        // eine gueltige Frage. Deshalb 0 und ein Satz, kein Fehlertext.
+        if (titel.length === 0) {
+            console.log("Du hast noch keine Projekte eingetragen.");
+            console.log(`  Eintragen: kimal3 projekt neu --titel "…"`);
+            return 0;
+        }
+        console.log(`\n  Deine Projekte (${titel.length} von 12):`);
+        titel.forEach((t, i) => console.log(`    ${i + 1}. ${t}`));
+        console.log(`\n  Ansehen: ${BASIS_URL}/profil\n`);
+        return 0;
+    }
+    const meldung = feld(antwort.koerper, "meldung") ?? "Das hat nicht geklappt.";
+    // 402 vor 401: Beide heissen "kommst hier nicht rein", verlangen aber
+    // Gegenteiliges. Wer sie zusammenwirft, raet dem Menschen `kimal3 login` —
+    // und der meldet sich dann erfolgreich an, ohne dass es etwas aendert.
+    if (antwort.status === 402) {
+        console.error(meldung);
+        return 4;
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
+        return 2;
+    }
+    if (antwort.status === 409 && feld(antwort.koerper, "grund") === "kein-profil") {
+        console.error(`${meldung} Leg es hier an: ${BASIS_URL}/profil`);
+        return 1;
+    }
+    // ⚠️ Hier landet auch die `503` "Konto gerade nicht prüfbar" — und sie MUSS
+    // hier landen, nicht oben bei der 402. Rueckgabewert 3 heisst "nochmal
+    // versuchen kann helfen"; 4 heisst laut SKILL.md ausdruecklich "nicht
+    // wiederholen". Ein Lesefehler an der Pro-Schranke gehoert in den ersten
+    // Topf. (Review-Befund 2026-08-14.)
+    console.error(meldung);
+    return antwort.status >= 500 ? 3 : 1;
+}

package/dist/befehle/projekt-neu.js

@@ -0,0 +1,82 @@
+import { feld, ruf } from "../api.js";
+import { BASIS_URL } from "../anmeldung.js";
+import { zerlege } from "../argumente.js";
+const OPTIONEN = [
+    "titel", "beschreibung", "symbol", "stunden", "ergebnis", "umsatz",
+    "wirkung", "wirkung-label", "link", "live-seit",
+];
+const HILFE = `
+  kimal3 projekt neu --titel "Angebots-Generator" [Optionen]
+
+    --titel          Pflicht. 2–80 Zeichen.
+    --beschreibung   Bis 300 Zeichen.
+    --symbol         Eines der bekannten Symbole, z. B. bot, mail, workflow.
+    --stunden        Zeitersparnis pro Woche, 0–168.
+    --ergebnis       Ergebnis pro Monat in Euro, z. B. 1200 oder 1200,50.
+    --umsatz         Umsatz pro Monat in Euro.
+    --wirkung        Kurz, bis 20 Zeichen, z. B. "-70%".
+    --wirkung-label  Wozu, bis 40 Zeichen, z. B. "Angebotszeit".
+    --link           Vollstaendige Adresse mit http:// oder https://.
+    --live-seit      Datum als JJJJ-MM-TT.
+`;
+export async function projektNeu(argv) {
+    // ⚠️ VOR dem Zerlegen abfragen, nicht danach.
+    // Der Bauplan hatte "help" in der Optionsliste und fragte hinterher. Das
+    // konnte nie greifen: `zerlege` verlangt zu jeder Option einen Wert, also
+    // scheitert `--help` schon dort mit "fehlt ihr Wert". Ein Schalter ist keine
+    // Option mit Wert — er gehoert vor den Zerleger.
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HILFE);
+        return 0;
+    }
+    const z = zerlege(argv, OPTIONEN);
+    if (!z.ok) {
+        console.error(z.meldung);
+        return 1;
+    }
+    const o = z.werte.optionen;
+    if (!o.titel) {
+        console.error("Es fehlt --titel.\n" + HILFE);
+        return 1;
+    }
+    const antwort = await ruf("/api/cli/projekt", {
+        mitAusweis: true,
+        koerper: {
+            titel: o.titel, beschreibung: o.beschreibung ?? "", icon: o.symbol ?? "",
+            wirkung_text: o.wirkung ?? "", wirkung_label: o["wirkung-label"] ?? "",
+            zeitersparnis_std_wo: o.stunden ?? "", ergebnis_monat_eur: o.ergebnis ?? "",
+            umsatz_monat_eur: o.umsatz ?? "", link_url: o.link ?? "",
+            live_seit: o["live-seit"] ?? "",
+        },
+    });
+    if (antwort.status === 201) {
+        const titel = feld(antwort.koerper, "titel") ?? o.titel;
+        const anzahl = antwort.koerper?.anzahl;
+        console.log(`✓ „${titel}" ins Erfolgsprofil eingetragen (Projekt ${anzahl} von 12).`);
+        console.log(`  Ansehen: ${BASIS_URL}/profil`);
+        return 0;
+    }
+    const meldung = feld(antwort.koerper, "meldung") ?? "Das hat nicht geklappt.";
+    // 402 vor 401: Beide heissen "kommst hier nicht rein", verlangen aber
+    // Gegenteiliges. Wer sie zusammenwirft, raet dem Menschen `kimal3 login` —
+    // und der meldet sich dann erfolgreich an, ohne dass es etwas aendert.
+    if (antwort.status === 402) {
+        console.error(meldung);
+        return 4;
+    }
+    if (antwort.status === 401) {
+        console.error(`${meldung} Bitte \`kimal3 login\` ausführen.`);
+        return 2;
+    }
+    if (antwort.status === 409 && feld(antwort.koerper, "grund") === "kein-profil") {
+        console.error(`${meldung} Leg es hier an: ${BASIS_URL}/profil`);
+        return 1;
+    }
+    // ⚠️ Hier landet auch die `503` "Konto gerade nicht prüfbar" — und sie MUSS
+    // hier landen, nicht oben bei der 402. Rueckgabewert 3 heisst "nochmal
+    // versuchen kann helfen"; 4 heisst laut SKILL.md ausdruecklich "nicht
+    // wiederholen". Ein Lesefehler an der Pro-Schranke gehoert in den ersten
+    // Topf. (Review-Befund 2026-08-14.)
+    console.error(meldung);
+    return antwort.status >= 500 ? 3 : 1;
+}

package/dist/befehle/skill-install.js

@@ -0,0 +1,44 @@
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+/**
+ * Legt das Skill GLOBAL ab, damit Claude dieses Werkzeug ueberall kennt.
+ *
+ * Der Pfad zur eigenen Datei kommt ueber `import.meta.url` und NICHT ueber
+ * `process.cwd()` — die Quelle liegt im installierten Paket, das Ziel im
+ * Ordner des Menschen. Wer beides verwechselt, kopiert eine Datei auf sich
+ * selbst.
+ *
+ * `dist/befehle/skill-install.js` -> zwei Ebenen hoch -> `skill/SKILL.md`.
+ */
+export async function skillInstall() {
+    const quelle = fileURLToPath(new URL("../../skill/SKILL.md", import.meta.url));
+    if (!existsSync(quelle)) {
+        console.error("Das Skill liegt nicht im Paket. Bitte kimal3 neu installieren.");
+        return 3;
+    }
+    // 🔑 GLOBAL, nicht projektlokal (Fund von Dennis, 2026-08-13).
+    // Gemessen: In ~/.claude/skills liegen 34 Skills, im Projekt selbst kein
+    // einziges. Inhaltlich stimmt es auch -- "trag ein fertiges Projekt ins
+    // Erfolgsprofil ein" gilt in JEDEM Ordner, nicht in einem. Wer projektlokal
+    // installiert, hat das Werkzeug im naechsten Projekt nicht -- und merkt es
+    // erst, wenn er dort vergeblich "fertig" sagt.
+    const zielOrdner = join(homedir(), ".claude", "skills", "kimal3");
+    const ziel = join(zielOrdner, "SKILL.md");
+    // Vorher merken: "angelegt" und "aktualisiert" sind zwei verschiedene
+    // Wirklichkeiten und bekommen deshalb zwei verschiedene Meldungen.
+    const gabEsSchon = existsSync(ziel);
+    try {
+        mkdirSync(zielOrdner, { recursive: true });
+        copyFileSync(quelle, ziel);
+    }
+    catch (fehler) {
+        console.error(`Das Skill liess sich nicht schreiben: ${String(fehler)}`);
+        return 3;
+    }
+    console.log(gabEsSchon ? "✓ Skill aktualisiert." : "✓ Skill angelegt.");
+    console.log(`  ${ziel}`);
+    console.log("  Claude kennt das Werkzeug ab der nächsten Sitzung.");
+    return 0;
+}

package/dist/kimal3.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Der Einstieg. Jeder Befehl liefert eine Zahl zurueck, und die Zahl ist die
+ * eigentliche Schnittstelle: Claude liest sie, nicht den Text.
+ *
+ * 0 erledigt · 1 Eingabe passt nicht · 2 Anmeldung fehlt ·
+ * 3 Server nicht erreichbar · 4 angemeldet, aber kein Pro-Zugang
+ *
+ * 🔑 Warum die 4 eine eigene Zahl braucht: "nicht angemeldet" (2) und "kein
+ * Zugang" (4) klingen aehnlich, verlangen aber Gegenteiliges — bei 2 hilft
+ * `kimal3 login`, bei 4 hilft genau das nicht. Wer beide auf dieselbe Zahl
+ * legt, laesst Claude den falschen Rat geben.
+ */
+import { leseAnmeldung } from "./anmeldung.js";
+import { NichtAngemeldet } from "./api.js";
+import { login } from "./befehle/login.js";
+import { logout } from "./befehle/logout.js";
+import { projektListe } from "./befehle/projekt-liste.js";
+import { projektNeu } from "./befehle/projekt-neu.js";
+import { skillInstall } from "./befehle/skill-install.js";
+const HILFE = `
+  kimal3 — trag deine KI-Projekte dort ein, wo sie entstehen.
+
+  kimal3 login              Diesen Rechner mit deinem Konto verbinden
+  kimal3 logout             Verbindung wieder aufheben
+  kimal3 projekt neu …      Ein Projekt ins Erfolgsprofil eintragen
+  kimal3 projekt liste      Deine eingetragenen Projekte anzeigen
+  kimal3 skill install      Claude beibringen, dieses Werkzeug zu benutzen
+
+  Mehr zu einem Befehl:  kimal3 projekt neu --help
+`;
+/**
+ * Hilfe plus Zustand.
+ *
+ * ⚠️ Bewusst KEIN automatischer Login (Frage von Dennis, 2026-08-13, am selben
+ * Abend nochmals bestaetigt): Wer `npx kimal3` tippt, um sich das Ding
+ * anzusehen, bekaeme sonst unvermittelt einen Anmelde-Vorgang samt Browser.
+ * Und was taete der zweite Aufruf, wenn man schon angemeldet ist? Es gaebe
+ * zwei Wege zum selben Ergebnis, einer davon unerwartet.
+ * *Ein Befehl darf nicht mehr tun, als sein Name verspricht.*
+ *
+ * ⚠️ Und KEIN Netzaufruf: Wer nur die Hilfe sehen will, soll nicht auf einen
+ * Server warten. Ob die Anmeldung noch gilt, klaert der naechste echte Befehl.
+ */
+function zustandsZeile() {
+    const a = leseAnmeldung();
+    return a
+        ? `  ● Angemeldet als ${a.email}`
+        : "  ● Nicht angemeldet.  →  kimal3 login";
+}
+async function haupt() {
+    const argv = process.argv.slice(2);
+    const wort = argv.join(" ");
+    if (argv.length === 0 || wort === "--help" || wort === "-h") {
+        console.log(HILFE);
+        console.log(zustandsZeile() + "\n");
+        return 0;
+    }
+    if (wort === "login")
+        return login();
+    if (wort === "logout")
+        return logout();
+    if (argv[0] === "projekt" && argv[1] === "neu")
+        return projektNeu(argv.slice(2));
+    if (wort === "projekt liste")
+        return projektListe();
+    if (wort === "skill install")
+        return skillInstall();
+    console.error(`Den Befehl „${wort}" kenne ich nicht.\n${HILFE}`);
+    return 1;
+}
+haupt()
+    .then((code) => process.exit(code))
+    .catch((f) => {
+    if (f instanceof NichtAngemeldet) {
+        console.error("Bitte zuerst `kimal3 login` ausführen.");
+        process.exit(2);
+    }
+    console.error("kimal3 ist gerade nicht erreichbar.");
+    process.exit(3);
+});

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "kimal3",
+  "version": "0.1.0",
+  "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" },
+  "keywords": ["kimal3", "cli"],
+  "homepage": "https://kimal3-app.vercel.app/pro",
+  "license": "SEE LICENSE IN README.md"
+}

package/skill/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: kimal3
+description: Use when the user has finished an AI project and wants it recorded in their kimal3 Erfolgsprofil, or asks to list/add projects there.
+---
+
+# kimal3 — Projekte ins Erfolgsprofil eintragen
+
+## Wann
+Sobald der Mensch sagt, ein Projekt sei fertig, oder ausdrücklich bittet, es einzutragen.
+
+## Erst nachsehen, dann schreiben
+`npx kimal3 projekt liste` — steht es schon da, **nicht** noch einmal eintragen.
+
+## Eintragen
+`npx kimal3 projekt neu --titel "…" [--stunden 6] [--ergebnis 1200] [--symbol bot]`
+Alle Optionen: `npx kimal3 projekt neu --help`
+
+## 🔑 Zahlen nie erfinden
+Zeitersparnis, Umsatz und Ergebnis sind Behauptungen über die Wirklichkeit eines Menschen — und
+sie stehen anschließend **öffentlich** auf einer Seite mit seinem Namen. Ist eine Zahl nicht
+genannt worden: **fragen** oder das Feld weglassen. Niemals schätzen.
+
+## Nicht angemeldet?
+Dem Menschen `npx kimal3 login` zeigen und ihn selbst bestätigen lassen. Die Anmeldung **nie**
+selbst versuchen — sie braucht einen Menschen, der im Browser bestätigt.
+
+## Kein Pro-Zugang (Rückgabewert 4)
+Die Meldung enthält bereits die Adresse. Dem Menschen **die Meldung zeigen** und den Befehl
+**nicht wiederholen** — ein zweiter Versuch ändert nichts und wirkt wie ein Fehler im Werkzeug.
+Auch **nicht** `kimal3 login` vorschlagen: Der Mensch *ist* angemeldet, ihm fehlt das Konto.
+
+## Vorübergehende Störung (Rückgabewert 3)
+Server nicht erreichbar — oder das Konto ließ sich gerade nicht prüfen. Das ist **kein**
+endgültiges Nein: **einmal** wiederholen ist richtig. Klappt es wieder nicht, dem Menschen die
+Meldung zeigen und es dabei belassen.
+
+## Rückgabewerte
+`0` erledigt · `1` Eingabe passt nicht · `2` Anmeldung fehlt · `3` vorübergehende Störung,
+einmal wiederholen · `4` angemeldet, aber kein Pro-Zugang — **nicht** wiederholen