kimal3 0.6.4 → 0.7.0

package/dist/befehle/plan-melde.js

@@ -0,0 +1,105 @@
+import { schalterOhneWert } from "../argumente.js";
+import { sprache } from "../sprache.js";
+import { MELDUNGEN_TEXTE } from "../texte/meldungen.js";
+import { merke, meldungFehler, sitzungFuerMeldung } from "../meldungen-speicher.js";
+import { ladeSpecText, sendeUmschlaege } from "./plan-senden.js";
+import { projektDesOrdners } from "./projekt-verbinden.js";
+/*
+  `kimal3 plan melde` -- Claude meldet der Projektseite EINE Aenderung (oder eine Liste), statt die ganze Datei
+  hochzuladen (Board in Echtzeit, Spec 1.1, 1.2, E-6, S-10, US-1, US-4).
+
+  Das Projekt kommt vom Ordnerzettel, nie aus einer Wahl (S-12). `entstanden` ist JETZT, `sitzung` die Nummer der
+  Claude-Sitzung: Beides setzt das Programm, nicht Claude -- eine von Hand gesetzte Zeit koennte eine fremde,
+  neuere Meldung verdraengen (E-2, E-6).
+
+  Nicht erreichbar -> gemerkt, Rueckgabewert 3; beim naechsten Befehl geht sie mit. Erfolg ist still (US-4).
+*/
+async function leseEingabe() {
+    if (process.stdin.isTTY)
+        return null;
+    const teile = [];
+    for await (const teil of process.stdin)
+        teile.push(Buffer.from(teil));
+    const text = Buffer.concat(teile).toString("utf8").replace(/^/, "");
+    return text.trim() === "" ? null : text;
+}
+export async function planMelde(argv) {
+    const t = MELDUNGEN_TEXTE[sprache()];
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(t.reportHelp);
+        return 0;
+    }
+    const projekt = projektDesOrdners();
+    if (projekt === null)
+        return 1;
+    const text = await leseEingabe();
+    if (text === null) {
+        console.error(t.noInput);
+        return 1;
+    }
+    let roh;
+    try {
+        roh = JSON.parse(text);
+    }
+    catch {
+        console.error(t.inputNoJson);
+        return 1;
+    }
+    const liste = Array.isArray(roh) ? roh : [roh];
+    if (liste.length === 0) {
+        console.error(t.noInput);
+        return 1;
+    }
+    for (const [i, m] of liste.entries()) {
+        const feld = meldungFehler(m);
+        if (feld !== null) {
+            console.error(t.reportUnreadable(i + 1, feld));
+            return 1;
+        }
+    }
+    const entstanden = new Date().toISOString();
+    // Prüfen ist nicht Arbeiten (Spec 2026-10-24 E-8): `--ohne-sitzung` schickt keine Sitzung mit, also leuchtet kein Punkt.
+    const sitzung = schalterOhneWert(argv, "ohne-sitzung").gesetzt ? null : sitzungFuerMeldung(process.env);
+    const umschlaege = liste.map((m) => ({ meldung: m, entstanden, sitzung }));
+    const sendung = await sendeUmschlaege(projekt.projektId, umschlaege);
+    const u = MELDUNGEN_TEXTE[sprache()];
+    // Erst die Absagen (je Satz einmal), dann was mit dem Rest geschieht.
+    for (const satz of new Set(sendung.je.flatMap((e) => (e.art === "abgesagt" ? [e.meldung] : []))))
+        console.error(satz);
+    const offen = umschlaege.filter((_, i) => sendung.je[i].art === "offen");
+    const p = sendung.problem;
+    if (offen.length > 0 && p !== null && p.art !== "absage") {
+        // Jede einzeln merken und zaehlen: Scheitert das Merken mittendrin, muss der Satz sagen, wie viele gemerkt sind.
+        const gemerkt = offen.filter((x) => merke(projekt.projektId, projekt.ordner, x)).length;
+        const satz = gemerkt === offen.length ? (p.art === "anmelden" ? u.storedSignIn : u.stored)
+            : gemerkt > 0 ? u.storedPartly(gemerkt, offen.length)
+                : p.art === "anmelden" ? p.meldung : u.notStored;
+        if (p.art === "anmelden" && gemerkt < offen.length && gemerkt > 0)
+            console.error(p.meldung);
+        console.error(satz);
+        return p.art === "anmelden" ? 2 : 3;
+    }
+    // Ruling Task 7: Eine Spec-Datei, die VOR ihrer Meldung geschrieben wurde, hat die App noch nicht -- jetzt mitnehmen.
+    // Fuer jede ANGENOMMENE Spec-Meldung, auch wenn eine andere der Liste abgesagt wurde.
+    let code = sendung.je.some((e) => e.art === "abgesagt") ? 1 : 0;
+    for (const [i, x] of umschlaege.entries()) {
+        const m = x.meldung;
+        if (sendung.je[i].art !== "angenommen" || m.art !== "spec" || m.datei === null)
+            continue;
+        const text = await ladeSpecText(projekt.projektId, projekt.ordner, m.schluessel, m.datei);
+        if (text === "anmelden") {
+            console.error(u.specTextSignIn(m.datei));
+            return 2;
+        }
+        if (text === "fehler") {
+            console.error(u.specTextFailed(m.datei));
+            code = 3;
+        }
+        else if (text === "zu-gross") {
+            console.error(u.specTextTooBig(m.datei));
+            if (code === 0)
+                code = 1;
+        }
+    }
+    return code;
+}

package/dist/befehle/plan-senden.js

@@ -0,0 +1,149 @@
+import { NichtAngemeldet, ruf } from "../api.js";
+import { leseAnmeldung } from "../anmeldung.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { MELDUNGEN_TEXTE } from "../texte/meldungen.js";
+import { leseSpecTexte } from "../plan-datei.js";
+import { gemerkteMitUnlesbaren, gemerktOrdner, sendeInPaketen, vergiss, } from "../meldungen-speicher.js";
+/*
+  `kimal3 plan senden` und das Senden, das vor jedem Befehl laeuft, der die App erreicht (Board in Echtzeit, S-10,
+  US-4; Bauplan R-4). Dazu der gemeinsame Weg, auf dem auch `plan melde` schickt.
+
+  🔴 EINE Anfrage fuer bis zu 50 Meldungen, nie eine je Meldung (Ruling Task 7): Jeder `kimal3`-Aufruf frischt die
+  Anmeldung auf, und rund 100 Aufrufe in zwei Minuten loesen bei Supabase `429` aus (gemessen in Task 4, D2). Die App
+  wendet sie in der Reihenfolge an, in der sie entstanden, und antwortet je Meldung. Die Ablaufregel (welche Absage
+  welche Meldungen trifft) steht rein in `sendeInPaketen` und wird in `check:cli` geprueft.
+*/
+const PFAD = "/api/cli/projekt/meldungen"; // kein-anzeigetext: Pfad der Schnittstelle
+/** Schickt die Umschlaege eines Projekts ueber das Netz. */
+export async function sendeUmschlaege(projektId, umschlaege) {
+    const schicke = async (paket) => {
+        try {
+            return await ruf(PFAD, { mitAusweis: true, koerper: { projektId, umschlaege: paket } });
+        }
+        catch (f) {
+            return f instanceof NichtAngemeldet ? "nicht-angemeldet" : "netz";
+        }
+    };
+    const sendung = await sendeInPaketen(umschlaege, schicke);
+    const p = sendung.problem;
+    if (p?.art !== "anmelden")
+        return sendung;
+    // Ohne Satz der App (keine Anmeldung auf dieser Platte) der eigene; sonst der der App mit dem Rat dahinter.
+    const t = ALLGEMEIN_TEXTE[sprache()];
+    return { ...sendung, problem: { art: "anmelden", meldung: p.meldung === "" ? t.signInFirst : `${p.meldung}${t.pleaseSignIn}` } };
+}
+/**
+ * Laedt den Text der Datei hoch, die eine Spec-Meldung nennt (Ruling Task 7): Hat Claude die Datei geschrieben, BEVOR
+ * die Spec gemeldet war, hat die App den Text des Mods verworfen (`204`, unbekannte Spec). `ok` auch, wenn es nichts
+ * hochzuladen gibt (keine Datei, ausserhalb des Projekts, allein zu gross -- das sagt `/k3plan`).
+ * Derselbe Ausweis wie der Mod (`~/.kimal3/anmeldung.json`), dieselbe Route.
+ */
+export async function ladeSpecText(projektId, ordner, schluessel, datei) {
+    const gelesen = leseSpecTexte(ordner, [{ schluessel, titel: schluessel, datei }], (e) => e).eintraege[0];
+    if (!("text" in gelesen) || datei === null)
+        return "ok";
+    try {
+        const antwort = await ruf("/api/mod/spec-text", { mitAusweis: true, koerper: { projektId, pfad: datei, text: gelesen.text } }); // kein-anzeigetext: Pfad der Schnittstelle
+        if (antwort.status === 200 || antwort.status === 204)
+            return "ok";
+        if (antwort.status === 401)
+            return "anmelden";
+        return antwort.status === 413 ? "zu-gross" : "fehler";
+    }
+    catch (f) {
+        return f instanceof NichtAngemeldet ? "anmelden" : "fehler";
+    }
+}
+/** Schickt alle gemerkten, je Projekt eine Sendung; angenommene und abgesagte werden vergessen, offene bleiben. */
+export async function sendeGemerkte() {
+    const { liste: alle } = gemerkteMitUnlesbaren();
+    const projekte = [...new Set(alle.map((g) => g.projektId))];
+    const ergebnis = { angenommen: 0, abgesagt: 0, saetze: [], offen: 0, unlesbar: [], problem: null };
+    for (const projektId of projekte) {
+        const liste = alle.filter((g) => g.projektId === projektId);
+        const sendung = await sendeUmschlaege(projektId, liste.map((g) => g.umschlag));
+        const saetze = new Set();
+        for (const [i, g] of liste.entries()) {
+            const e = sendung.je[i];
+            if (e.art === "offen")
+                continue;
+            vergiss(g.datei);
+            if (e.art === "abgesagt") {
+                ergebnis.abgesagt++;
+                saetze.add(e.meldung);
+                continue;
+            }
+            ergebnis.angenommen++;
+            // Nebenbei und ohne Laerm: Scheitert der Text, bringt ihn der Mod beim naechsten Schreiben oder `/k3plan`.
+            const m = g.umschlag.meldung;
+            if (m.art === "spec" && g.ordner !== null)
+                await ladeSpecText(projektId, g.ordner, m.schluessel, m.datei);
+        }
+        ergebnis.saetze.push(...saetze);
+        if (sendung.problem !== null && sendung.problem.art !== "absage") {
+            ergebnis.problem = sendung.problem;
+            break;
+        }
+    }
+    const danach = gemerkteMitUnlesbaren();
+    ergebnis.offen = danach.liste.length;
+    ergebnis.unlesbar = danach.unlesbar;
+    return ergebnis;
+}
+/** Die Zeilen ueber das Nachschicken: angenommen, abgesagt (mit Gruenden), unlesbare Dateien. */
+function berichte(e, ausgabe) {
+    const t = MELDUNGEN_TEXTE[sprache()];
+    if (e.angenommen > 0)
+        ausgabe(t.sentStored(e.angenommen));
+    if (e.abgesagt > 0)
+        console.error(t.refusedStored(e.abgesagt));
+    for (const satz of e.saetze)
+        console.error(satz);
+    if (e.unlesbar.length > 0)
+        console.error(t.unreadableStored(e.unlesbar, gemerktOrdner()));
+}
+/**
+ * Vor jedem Befehl, der die App erreicht (kimal3.ts): gemerkte Meldungen zuerst. Wirft nie und haelt den Befehl nie
+ * auf -- ist die App nicht erreichbar, sagt es gleich der Befehl selbst. Gesagt wird nur, was Claude wissen muss:
+ * wie viele angekommen sind, wie viele abgesagt (mit Grund, E-6: „kam zu spaet an“).
+ */
+export async function vorabSenden() {
+    try {
+        if (gemerkteMitUnlesbaren().liste.length === 0 || leseAnmeldung() === null)
+            return;
+        berichte(await sendeGemerkte(), (z) => console.error(z));
+    }
+    catch {
+        /* Ein Nebenschauplatz darf den Befehl nicht umwerfen. */
+    }
+}
+export async function planSenden(argv) {
+    const t = MELDUNGEN_TEXTE[sprache()];
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(t.sendHelp);
+        return 0;
+    }
+    const vorher = gemerkteMitUnlesbaren();
+    if (vorher.liste.length === 0) {
+        if (vorher.unlesbar.length === 0) {
+            console.log(t.nothingStored);
+            return 0;
+        }
+        // Nur unlesbare: nicht „nichts gemerkt“ sagen -- es liegt etwas da, das jemand ansehen muss.
+        console.error(t.unreadableStored(vorher.unlesbar, gemerktOrdner()));
+        return 1;
+    }
+    const e = await sendeGemerkte();
+    const u = MELDUNGEN_TEXTE[sprache()];
+    berichte(e, (z) => console.log(z));
+    if (e.problem?.art === "anmelden") {
+        console.error(e.problem.meldung);
+        return 2;
+    }
+    if (e.problem?.art === "nicht-erreichbar") {
+        console.error(u.stillStored(e.offen));
+        return 3;
+    }
+    return e.abgesagt > 0 || e.unlesbar.length > 0 ? 1 : 0;
+}

package/dist/befehle/plan.js

@@ -4,8 +4,46 @@ import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
 import { PLAN_TEXTE } from "../texte/plan.js";
 import { schlussFehler } from "../fehler.js";
 import { lesePlanDatei } from "../plan-datei.js";
+import { projektDesOrdners } from "./projekt-verbinden.js";
 const istZahl = (w) => typeof w === "number" && Number.isInteger(w);
 const textOderNull = (w) => typeof w === "string" || w === null;
+const alsObjekt = (w) => (w && typeof w === "object" && !Array.isArray(w) ? w : null);
+/** Der Stand aus der Antwort; `undefined`, wenn er da ist, aber nicht die erwartete Form hat. */
+function standAus(w) {
+    if (w === null)
+        return null;
+    const o = alsObjekt(w);
+    if (o === null || !Array.isArray(o.specs) || !Array.isArray(o.themen))
+        return undefined;
+    const specs = [];
+    for (const sp of o.specs) {
+        const s = alsObjekt(sp);
+        if (s === null || typeof s.schluessel !== "string" || typeof s.titel !== "string" || !textOderNull(s.datei) || !Array.isArray(s.stories))
+            return undefined;
+        const stories = s.stories.map(alsObjekt);
+        if (stories.some((st) => st === null || typeof st.schluessel !== "string" || typeof st.titel !== "string" || typeof st.stand !== "string" || !istZahl(st.runde)))
+            return undefined;
+        specs.push({
+            schluessel: s.schluessel, titel: s.titel, datei: s.datei,
+            stories: stories.map((st) => ({ schluessel: st.schluessel, titel: st.titel, stand: st.stand, runde: st.runde })),
+        });
+    }
+    const themen = o.themen.flatMap((th) => {
+        const x = alsObjekt(th);
+        return x !== null && typeof x.schluessel === "string" && typeof x.text === "string" ? [{ schluessel: x.schluessel, text: x.text }] : [];
+    });
+    return { specs, themen };
+}
+/** Reine Rechnung: je Spec eine Zeile, je Story „US-2 · in Arbeit · Runde 1 · Titel“, danach Claudes notierte Themen. */
+export function standZeilen(stand, s) {
+    const t = PLAN_TEXTE[s];
+    if (stand === null)
+        return [t.noPlanning];
+    return [
+        ...stand.specs.flatMap((sp) => [t.specLine(sp.schluessel, sp.titel, sp.datei), ...sp.stories.map((st) => t.storyLine(st.schluessel, t.storyStand(st.stand), st.runde, st.titel))]),
+        ...stand.themen.map((th) => t.topicLine(th.schluessel, th.text)),
+    ];
+}
 function offenAus(w) {
     if (!w || typeof w !== "object")
         return null;
@@ -34,9 +72,10 @@ export function planAntwortAus(koerper) {
         return null;
     const offen = k.offen.map((o) => offenAus(o));
     const bestaetigt = k.bestaetigt.map((b) => bestaetigtAus(b));
-    if (offen.includes(null) || bestaetigt.includes(null))
+    const stand = standAus(k.stand);
+    if (offen.includes(null) || bestaetigt.includes(null) || stand === undefined)
         return null;
-    return { adresse: k.adresse, offen: offen, bestaetigt: bestaetigt };
+    return { adresse: k.adresse, offen: offen, bestaetigt: bestaetigt, stand };
 }
 /** Reine Rechnung: die Zeilen, die Claude zu sehen bekommt. */
 export function planZeilen(a, s) {
@@ -87,14 +126,10 @@ export async function plan(argv) {
         console.log(PLAN_TEXTE[s].listHelp);
         return 0;
     }
-    const datei = planDateiOderAbsage(s);
-    if (datei === null)
+    const projekt = projektDesOrdners();
+    if (projekt === null)
         return 1;
-    const suche = new URLSearchParams();
-    if (typeof datei.json.projekt_id === "string")
-        suche.set("projekt-id", datei.json.projekt_id);
-    if (typeof datei.json.projekt === "string")
-        suche.set("projekt", datei.json.projekt);
+    const suche = new URLSearchParams({ "projekt-id": projekt.projektId, projekt: projekt.titel });
     const antwort = await ruf(`/api/cli/projekt/plan?${suche.toString()}`, { methode: "GET", mitAusweis: true }); // kein-anzeigetext: Pfad und HTTP-Methode
     // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
     s = sprache();
@@ -105,6 +140,6 @@ export async function plan(argv) {
         console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
         return 3;
     }
-    planZeilen(a, s).forEach((z) => console.log(z));
+    [...standZeilen(a.stand, s), ...planZeilen(a, s)].forEach((z) => console.log(z));
     return 0;
 }

package/dist/befehle/projekt-verbinden.js

@@ -0,0 +1,141 @@
+import { feld, ruf } from "../api.js";
+import { schalterOhneWert, zerlege } from "../argumente.js";
+import { schalterIn } from "../befehlswoerter.js";
+import { schlussFehler } from "../fehler.js";
+import { firmenKoerperAus, ohneFirmaAusArgv } from "../projekt-neu-firma.js";
+import { ordnerlageJetzt, schreibeZettel, verbindenErgebnis } from "../projekt-ordner.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { MELDUNGEN_TEXTE } from "../texte/meldungen.js";
+import { absage } from "./kontext-gemeinsam.js";
+/*
+  `kimal3 projekt verbinden` -- jeder Projektordner hat sein Projekt in der App (Board in Echtzeit, Spec 1.7, E-7,
+  S-27 bis S-32, US-8). Der Mod stoesst es an, Claude ruft es auf.
+
+  - Zettel liegt: die App fragen, ob es das Projekt noch gibt. Ja -> nichts sagen, `0` (S-27, Gegenprobe). Nein ->
+    „Soll ich ein neues anlegen?“, `1`; erst `--neu` legt an (S-31: ohne Ja passiert nichts).
+  - Kein Zettel, aber `plan/stand.json` mit `projekt_id` (1.4): dasselbe Nachfragen, dann den Zettel daraus schreiben.
+  - Sonst: Titel = Name des Projektordners; die App verbindet mit dem einen gleichnamigen oder legt an (wie `projekt neu`).
+    Zwei gleichnamige -> Liste mit Nummern, `--projekt <n>` waehlt (S-28: es waehlt nie still).
+*/
+/**
+ * Fuer `plan` und `plan melde`: das Projekt dieses Ordners -- oder `null`, nachdem der Grund gesagt ist. Kommt die
+ * Nummer noch aus `plan/stand.json`, wird der Zettel daraus jetzt angelegt (1.4: „beim ersten Lesen“) und das gesagt.
+ */
+export function projektDesOrdners() {
+    const t = MELDUNGEN_TEXTE[sprache()];
+    const lage = ordnerlageJetzt();
+    if (lage.art === "kein-projektordner") {
+        console.error(t.notProjectFolder);
+        return null;
+    }
+    if (lage.zettel === null) {
+        console.error(t.notConnected);
+        return null;
+    }
+    if (lage.ausStandJson && schreibeZettel(lage.ordner, lage.zettel))
+        console.error(t.connected(lage.zettel.titel));
+    return { projektId: lage.zettel.projekt_id, titel: lage.zettel.titel, ordner: lage.ordner };
+}
+/**
+ * Was hinter `kimal3 projekt verbinden` in den Firmen-Vorschlaegen steht (Fixrunde 1): Mit `--neu` muss es mitreisen --
+ * sonst traefe der kopierte Vorschlag wieder den Zettel des geloeschten Projekts, und Claude fragte im Kreis (S-31).
+ */
+export function verbindenOptionen(neu, s) {
+    return neu ? ` --${schalterIn("neu", s)}` : "";
+}
+export async function projektVerbinden(argv) {
+    let s = sprache();
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(MELDUNGEN_TEXTE[s].connectHelp);
+        return 0;
+    }
+    const neu = schalterOhneWert(argv, "neu");
+    const { rest, ohneFirma } = ohneFirmaAusArgv(neu.rest);
+    const z = zerlege(rest, ["projekt", "firma", "firma-id"], s);
+    if (!z.ok) {
+        console.error(z.meldung);
+        return 1;
+    }
+    const o = z.werte.optionen;
+    const wunsch = firmenKoerperAus(o.firma, o["firma-id"], ohneFirma, s);
+    if (!wunsch.ok) {
+        console.error(wunsch.meldung);
+        return 1;
+    }
+    const lage = ordnerlageJetzt();
+    if (lage.art === "kein-projektordner") {
+        console.error(MELDUNGEN_TEXTE[s].notProjectFolder);
+        return 1;
+    }
+    const vorhanden = neu.gesetzt ? null : lage.zettel;
+    const antwort = await ruf("/api/cli/projekt/verbinden", {
+        mitAusweis: true,
+        koerper: { titel: vorhanden?.titel ?? lage.name, projektId: vorhanden?.projekt_id ?? null, ...wunsch.koerper },
+    });
+    // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
+    s = sprache();
+    const t = MELDUNGEN_TEXTE[s];
+    const e = verbindenErgebnis(antwort.status, antwort.koerper);
+    const merkeZettel = (z, satz) => {
+        if (!schreibeZettel(lage.ordner, z)) {
+            console.error(t.noteNotWritten(z.titel, z.projekt_id));
+            return 1;
+        }
+        console.log(satz);
+        return 0;
+    };
+    switch (e.art) {
+        case "verbunden": {
+            const z = { format: 1, projekt_id: e.projektId, titel: e.titel };
+            if (e.angelegt)
+                return merkeZettel(z, t.created(e.titel));
+            // Der Zettel lag schon und stimmt: still (S-27, Gegenprobe). Aus `plan/stand.json` oder per Titel: Zettel schreiben.
+            if (vorhanden !== null && !lage.ausStandJson)
+                return 0;
+            return merkeZettel(z, t.connected(e.titel));
+        }
+        case "geloescht":
+            console.error(t.deleted);
+            console.error(t.deletedHow);
+            return 1;
+        case "mehrdeutig": {
+            const wahl = o.projekt;
+            if (wahl === undefined) {
+                console.error(e.meldung);
+                e.kandidaten.forEach((k, i) => console.error(t.candidate(i + 1, k.titel, k.projektId)));
+                console.error(t.chooseHow);
+                return 1;
+            }
+            const nummer = Number(wahl);
+            const k = Number.isInteger(nummer) ? e.kandidaten[nummer - 1] : undefined;
+            if (k === undefined) {
+                console.error(t.noSuchCandidate(wahl, e.kandidaten.length));
+                return 1;
+            }
+            return merkeZettel({ format: 1, projekt_id: k.projektId, titel: k.titel }, t.connected(k.titel));
+        }
+        case "kein-profil":
+            console.error(t.noProfile);
+            return 1;
+        case "firma":
+            return absage(antwort, "projekt verbinden", verbindenOptionen(neu.gesetzt, s)); // kein-anzeigetext: Befehlsschluessel
+        case "unlesbar":
+            console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+            return 3;
+        case "sonst": {
+            const meldung = feld(antwort.koerper, "meldung") ?? ALLGEMEIN_TEXTE[s].genericFailure;
+            if (antwort.status === 401) {
+                console.error(`${meldung}${ALLGEMEIN_TEXTE[s].pleaseSignIn}`);
+                return 2;
+            }
+            if (antwort.status === 400 || antwort.status === 409) {
+                console.error(meldung);
+                return 1;
+            }
+            const schluss = schlussFehler(antwort.status, meldung, s);
+            console.error(schluss.text);
+            return schluss.wert;
+        }
+    }
+}

package/dist/befehle/skill-install.js

@@ -10,7 +10,7 @@ import { sprache } from "../sprache.js";
 import { andereSpracheZuRaeumen, skillQuelle } from "../slash-befehle.js";
 import { SKILL_TEXTE } from "../texte/skill.js";
 import { frischeCoachAuf } from "../coach-ablegen.js";
-import { frischeLogoAuf } from "../logo-ablegen.js";
+import { frischeModsAuf } from "../mods-ablegen.js";
 export const VERALTETE_BEFEHLE = [
     /*
       🔴 **Der ERSTE Eintrag ueberhaupt** (2026-08-28). `/k3firma` heisst jetzt
@@ -332,7 +332,7 @@ export async function skillInstall() {
 export async function skillInstallBefehl() {
     const code = await skillInstall();
     frischeCoachAuf(sprache());
-    frischeLogoAuf(sprache());
+    frischeModsAuf(sprache());
     return code;
 }
 /**

package/dist/befehle-katalog-en.js

@@ -119,17 +119,17 @@ export const BEFEHLE_EN = {
         ],
     },
     "kimal3 plan": {
-        stempel: "5a366449",
+        stempel: "6a0d2fec",
         befehl: "kimal3 plan",
         tippen: "/k3plan",
         terminal: "kimal3 plan",
-        beschreibung: "Upload planning or fetch responses",
+        beschreibung: "Fetch the planning state and report changes",
         rhythmusOderSatz: "check my planning",
         details: [
-            "kimal3 plan fetches what you've said in the app since the last upload: every “doesn't work” and every noted topic with its number, plus the confirmed stories. Claude sorts them and enters them in plan/stand.json.",
-            "kimal3 plan upload sends plan/stand.json to your project and then enters projekt_id and basis in the file itself. With --dry-run it only checks and saves nothing.",
-            "If the plan can't be read, a round goes down or the app already holds a newer plan, it refuses and saves nothing at all — the message says what to do. Use --overwrite only if you really mean it.",
-            "You'll know it worked when it reports with ✓ how many stories were uploaded and how many are waiting for your test, and gives the link to the planning.",
+            "kimal3 plan fetches the state of your planning from the app: every spec with its stories, plus every “doesn't work” and every noted topic with its number. The project is named in the folder note plan/projekt.json.",
+            "When Claude changes something — spec created, story started or built, topic noted — it reports each change on its own with kimal3 plan report. Every session enters only its own change; nothing is overwritten.",
+            "If the app can't be reached right now, kimal3 keeps the report and sends it along with the next command (or with kimal3 plan send). If the folder doesn't belong to a project yet, kimal3 project connect creates it.",
+            "You'll know it worked when the report goes through silently — the command tells you about an error. kimal3 plan upload is no longer needed; only with --overwrite does it replace the whole state with plan/stand.json.",
         ],
     },
     "kimal3 kurs": {

package/dist/befehle-katalog.js

@@ -168,21 +168,22 @@ export const BEFEHLE = [
         ],
     },
     /*
-      `kimal3 plan` und `kimal3 plan hoch` (Spec 2026-10-21-projektseite-planung) -- EIN Eintrag fuer beide: Claude
-      ruft sie nacheinander auf, und ein Mensch sucht hier nach der Planung, nicht nach zwei Befehlen.
+      `kimal3 plan` und seine Geschwister (Spec 2026-10-21-projektseite-planung; seit 0.7.0 Board in Echtzeit: `plan melde`,
+      `plan senden`, `projekt verbinden`) -- EIN Eintrag fuer alle: Claude ruft sie auf, und ein Mensch sucht hier nach
+      der Planung, nicht nach vier Befehlen.
     */
     {
         befehl: "kimal3 plan",
-        beschreibung: "Planung hochladen oder Rückmeldungen holen",
+        beschreibung: "Den Stand der Planung holen und Änderungen melden",
         wer: "claude",
         ausloeser: "prüf meine Planung",
         tippen: "/k3plan",
         terminal: "kimal3 plan",
         details: [
-            "kimal3 plan holt aus der App, was du seit dem letzten Hochladen gesagt hast: jedes „passt nicht“ und jedes notierte Thema mit seiner Nummer, dazu die bestätigten Stories. Claude ordnet sie ein und trägt sie in plan/stand.json ein.",
-            "kimal3 plan hoch schickt plan/stand.json an dein Projekt und trägt danach projekt_id und basis selbst in die Datei ein. Mit --probe prüft er nur und speichert nichts.",
-            "Ist der Plan nicht lesbar, wird eine Runde kleiner oder liegt in der App schon ein neuerer Plan, lehnt er ab und speichert gar nichts — die Meldung sagt, was zu tun ist. --ueberschreiben nur, wenn du es wirklich willst.",
-            "Geklappt hat es, wenn er mit ✓ meldet, wie viele Stories hochgeladen sind und wie viele auf deinen Test warten, und den Link zur Planung nennt.",
+            "kimal3 plan holt den Stand deiner Planung aus der App: jede Spec mit ihren Stories, dazu jedes „passt nicht“ und jedes notierte Thema mit seiner Nummer. Das Projekt steht im Ordnerzettel plan/projekt.json.",
+            "Ändert Claude etwas — Spec angelegt, Story begonnen oder gebaut, Thema notiert —, meldet es das einzeln mit kimal3 plan melde. Jede Sitzung trägt nur ihre eigene Änderung ein; nichts wird überschrieben.",
+            "Ist die App gerade nicht erreichbar, merkt sich kimal3 die Meldung und schickt sie beim nächsten Befehl mit (oder mit kimal3 plan senden). Gehört der Ordner noch zu keinem Projekt, legt kimal3 projekt verbinden es an.",
+            "Geklappt hat es, wenn die Meldung still durchgeht — einen Fehler sagt der Befehl. kimal3 plan hoch braucht es nicht mehr; nur mit --ueberschreiben ersetzt es den ganzen Stand durch plan/stand.json.",
         ],
     },
     {

package/dist/befehlswoerter.js

@@ -13,6 +13,10 @@ export const BEFEHLSWOERTER = {
     // `kimal3 plan` (Spec 2026-10-21-projektseite-planung, US-9): `plan` heisst in beiden Sprachen gleich.
     plan: { de: "plan", en: "plan" },
     "plan hoch": { de: "plan hoch", en: "plan upload" }, // kein-anzeigetext: Befehlswörter (Spec projektseite-planung)
+    // Board in Echtzeit (Spec 2026-10-23-brett-in-echtzeit-design.md, 1.2, 1.7; Bauplan Task 7)
+    "projekt verbinden": { de: "projekt verbinden", en: "project connect" }, // kein-anzeigetext: Befehlswörter (Spec brett-in-echtzeit)
+    "plan melde": { de: "plan melde", en: "plan report" }, // kein-anzeigetext: Befehlswörter (Spec brett-in-echtzeit)
+    "plan senden": { de: "plan senden", en: "plan send" }, // kein-anzeigetext: Befehlswörter (Spec brett-in-echtzeit)
     "firma daten": { de: "firma daten", en: "company data" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     kurs: { de: "kurs", en: "course" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     wache: { de: "wache", en: "watch" },
@@ -76,6 +80,11 @@ export const SCHALTER_EN = {
     "without-typed": "ohne-getipptes",
     // `kimal3 plan upload` (Spec 2026-10-21-projektseite-planung, US-11); `--overwrite` steht schon oben.
     "dry-run": "probe",
+    // `kimal3 project connect` (Board in Echtzeit, Task 7)
+    new: "neu",
+    project: "projekt",
+    // `kimal3 plan report --no-session` (Board auf einen Blick, Spec 2026-10-24 E-8)
+    "no-session": "ohne-sitzung",
 };
 /** `company` -> `firma`; ein deutscher (oder unbekannter) Name bleibt, wie er ist. */
 export function deutscherSchalter(getippt) {

package/dist/einstellungen-schreiben.js

@@ -36,7 +36,7 @@ export function tragePluginsEin(katalogPfad, mitSuperpowers) {
         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)));
+        return katalogPfad === null || (stand.logo !== "fehlt" && stand.plan !== "fehlt" && text.includes(`"${KATALOG}"`) && text.includes(JSON.stringify(katalogPfad)));
     }, pluginSicherungsDatei());
 }
 /**

package/dist/kimal3.js

@@ -38,6 +38,10 @@ import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { plan } from "./befehle/plan.js";
 import { planHoch } from "./befehle/plan-hoch.js";
+import { planMeldeAngenommen } from "./argumente.js";
+import { planMelde } from "./befehle/plan-melde.js";
+import { planSenden, vorabSenden } from "./befehle/plan-senden.js";
+import { projektVerbinden } from "./befehle/projekt-verbinden.js";
 import { skillDatei, skillInstallBefehl } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
 import { zeigenAuswerten, zeigenBild, zeigenStatus, zeigenStopp } from "./befehle/zeigen.js";
@@ -480,9 +484,19 @@ function zustandsZeile() {
     const a = leseAnmeldung();
     return a ? t.credentialsStored(a.email) : t.notSignedIn;
 }
+/**
+ * Befehle, die die App erreichen und vor denen gemerkte Meldungen nachgeschickt werden (Board in Echtzeit, Task 7).
+ * Bewusst NICHT: `wache` (laeuft beim Start jeder Sitzung und soll dort nichts verzoegern), `plan senden` (tut es
+ * selbst), Anmelden/Abmelden, `einrichten` und die Befehle, die nur auf dieser Platte arbeiten.
+ */
+const ERREICHT_APP = [
+    "projekt neu", "projekt liste", "projekt verbinden", "plan", "plan hoch", "plan melde", "firma daten", "kurs", // kein-anzeigetext: Befehlsnamen
+    "kontext runter", "kontext hoch", "kontext fragen", // kein-anzeigetext: Befehlsnamen
+];
 /** `null` = der Rest passt nicht zu diesem Befehl -> "kenne ich nicht", wie bisher. */
 async function fuehreAus(name, rest) {
     const allein = rest.length === 0;
+    const hilfe = rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h");
     switch (name) {
         case "login": return allein ? login() : null;
         case "logout": return allein ? logout() : null;
@@ -492,6 +506,11 @@ async function fuehreAus(name, rest) {
         // `plan` nimmt nur `--help`; ein Wort dahinter (`plan muell`) bleibt unbekannt wie bei `login extra`.
         case "plan": return allein || (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h")) ? plan(rest) : null;
         case "plan hoch": return planHoch(rest);
+        // Board in Echtzeit (Task 7): `plan melde` liest die Meldung von der Eingabe, nicht aus Argumenten.
+        // Seit Board auf einen Blick (Spec 2026-10-24 E-8) auch `--ohne-sitzung`: `/k3plan` prueft nur, es arbeitet nicht.
+        case "plan melde": return planMeldeAngenommen(rest) ? planMelde(rest) : null;
+        case "plan senden": return allein || hilfe ? planSenden(rest) : null;
+        case "projekt verbinden": return projektVerbinden(rest);
         case "kurs": return allein ? kurs() : null;
         // ⚠️ Rest wird durchgereicht, nicht auf Gleichheit geprueft: `firma daten --firma X` gehoert dazu.
         case "firma daten": return firmaDaten(rest);
@@ -562,6 +581,9 @@ async function haupt() {
     if (erkannt?.name === "einrichten")
         merkeBefehlsSprache(argv[0] === BEFEHLSWOERTER.einrichten.en ? "en" : "de");
     if (erkannt) {
+        // 🔑 Gemerkte Meldungen zuerst (Board in Echtzeit, S-10, US-4): vor jedem Befehl, der die App erreicht.
+        if (ERREICHT_APP.includes(erkannt.name) && !erkannt.rest.includes("--help") && !erkannt.rest.includes("-h"))
+            await vorabSenden();
         const code = await fuehreAus(erkannt.name, erkannt.rest);
         if (code !== null)
             return code;