kimal3 0.6.4 → 0.7.0

package/dist/meldungen-speicher.js

@@ -0,0 +1,189 @@
+/**
+ * Meldungen an die Projektseite und die gemerkten, die noch nicht ankamen (Spec 2026-10-23-brett-in-echtzeit-design.md,
+ * 1.1, E-6, S-10, US-4; Bauplan R-4).
+ *
+ * 🔑 `Meldung` und `Umschlag` stehen hier Feld fuer Feld wie in `src/lib/planung/meldung.ts` -- `cli/` kann `src/` nicht
+ * importieren. `meldungFehler` urteilt wie `pruefeMeldung` dort; `check:cli` haelt beide an denselben Proben gegeneinander.
+ * Warum die CLI ueberhaupt selbst prueft: Die App lehnt eine Anfrage mit EINER unlesbaren Meldung ganz ab. Eine solche,
+ * offline gemerkt, hielte sonst jede spaetere Sendung auf -- fuer immer.
+ *
+ * Gemerkt wird unter `~/.kimal3/meldungen/` (ueberlebt das Schliessen der Sitzung, US-4), eine Datei je Meldung:
+ * `<entstanden ohne :>-<6 Zeichen>.json`. Mit drin: das Projekt, fuer das sie gedacht war, und der Ordner, aus dem sie
+ * kam -- sie wird auch aus einem anderen Ordner nachgeschickt, und eine Spec-Meldung nimmt ihren Text von dort mit.
+ */
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { schreibeAtomar } from "./atomar.js";
+/**
+ * Die Sitzung, aus der eine Meldung kommt: zuerst `KIMAL3_SITZUNG`, die der Mod `kimal3-plan` bei jedem Start setzt --
+ * auch nach `/clear`, wo ungemessen ist, ob `CLAUDE_CODE_SESSION_ID` neu ist (Ruling Final, Important 2). Ohne Mod
+ * Claudes eigene Variable. Nur fuer Meldungen: die Wache bleibt bei `sitzungJetzt`.
+ */
+export function sitzungFuerMeldung(umgebung) {
+    for (const wert of [umgebung.KIMAL3_SITZUNG, umgebung.CLAUDE_CODE_SESSION_ID]) {
+        if (typeof wert === "string" && wert.trim() !== "")
+            return wert;
+    }
+    return null;
+}
+const istObjekt = (w) => typeof w === "object" && w !== null && !Array.isArray(w);
+const istText = (w) => typeof w === "string" && w.length > 0;
+const istTextOderNull = (w) => w === null || istText(w);
+const STAENDE = ["offen", "in_arbeit", "gebaut", "weggelassen"];
+/** `null` = lesbar; sonst das Feld, das die App nennen wuerde (`meldung` oder `art`). Spiegel von `pruefeInhalt`. */
+export function meldungFehler(m) {
+    if (!istObjekt(m))
+        return "meldung";
+    switch (m.art) {
+        case "spec":
+            if (!istText(m.schluessel) || !istText(m.titel) || !istTextOderNull(m.datei) || !Array.isArray(m.stories))
+                return "meldung";
+            return m.stories.every((s) => istObjekt(s) && istText(s.schluessel) && istText(s.titel)) ? null : "meldung";
+        case "story":
+            if (!istText(m.spec) || !istText(m.story) || typeof m.stand !== "string" || !STAENDE.includes(m.stand))
+                return "meldung";
+            if (m.runde !== undefined && !Number.isInteger(m.runde))
+                return "meldung";
+            if (m.kriterien !== undefined && !Array.isArray(m.kriterien))
+                return "meldung";
+            if (m.befunde !== undefined && !Array.isArray(m.befunde))
+                return "meldung";
+            return (m.testen === undefined || istTextOderNull(m.testen)) && (m.grund === undefined || istTextOderNull(m.grund)) ? null : "meldung";
+        case "thema": return istText(m.schluessel) && istText(m.text) ? null : "meldung";
+        case "uebernommen": return Number.isInteger(m.rueckmeldung) && istText(m.antwort) ? null : "meldung";
+        case "eingeordnet": return istText(m.schluessel) && istText(m.text) && istText(m.antwort) ? null : "meldung";
+        default: return "art";
+    }
+}
+// ── gemerkte Meldungen ────────────────────────────────────────────────────────────────────────────────────────────
+const ORDNER = join(homedir(), ".kimal3", "meldungen");
+export const dateiNameFuer = (entstanden, zufall) => `${entstanden.replace(/:/g, "")}-${zufall}.json`; // kein-anzeigetext: Dateiname
+/**
+ * In der Reihenfolge, in der sie entstanden -- als ZEIT verglichen, nicht als Text (ein Versatz wie `+02:00` sortiert
+ * als Text falsch); bei gleicher Zeit nach Dateiname, damit die Reihenfolge nie vom Zufall des Dateisystems abhaengt.
+ */
+export function ordneGemerkte(liste) {
+    return [...liste].sort((a, b) => Date.parse(a.umschlag.entstanden) - Date.parse(b.umschlag.entstanden) || (a.datei < b.datei ? -1 : a.datei > b.datei ? 1 : 0));
+}
+/** Merkt eine Meldung fuer spaeter. `false`: nicht geschrieben -- dann ist sie verloren, und das muss man sagen. */
+export function merke(projektId, ordner, u) {
+    try {
+        mkdirSync(ORDNER, { recursive: true });
+        const datei = dateiNameFuer(u.entstanden, randomBytes(3).toString("hex"));
+        schreibeAtomar(join(ORDNER, datei), `${JSON.stringify({ format: 1, projektId, ordner, umschlag: u }, null, 2)}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Alle gemerkten, in Sendereihenfolge -- und die Dateien, die sich nicht lesen lassen. Die bleiben liegen (geloescht
+ * wird nichts ungesehen), werden aber GENANNT: Still uebergangen saehe „nichts gemerkt“ aus wie Erfolg.
+ */
+export function gemerkteMitUnlesbaren() {
+    let namen;
+    try {
+        namen = readdirSync(ORDNER).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return { liste: [], unlesbar: [] };
+    }
+    const unlesbar = [];
+    const liste = namen.flatMap((datei) => {
+        try {
+            const o = JSON.parse(readFileSync(join(ORDNER, datei), "utf8"));
+            if (istObjekt(o) && istText(o.projektId) && istObjekt(o.umschlag)) {
+                const u = o.umschlag;
+                if (istText(u.entstanden) && !Number.isNaN(Date.parse(u.entstanden)) && meldungFehler(u.meldung) === null) {
+                    const sitzung = istText(u.sitzung) ? u.sitzung : null;
+                    return [{ datei, projektId: o.projektId, ordner: istText(o.ordner) ? o.ordner : null, umschlag: { meldung: u.meldung, entstanden: u.entstanden, sitzung } }];
+                }
+            }
+        }
+        catch {
+            /* unten gezaehlt */
+        }
+        unlesbar.push(datei);
+        return [];
+    });
+    return { liste: ordneGemerkte(liste), unlesbar: unlesbar.sort() };
+}
+export const gemerkte = () => gemerkteMitUnlesbaren().liste;
+export const gemerktOrdner = () => ORDNER;
+export function vergiss(datei) {
+    try {
+        rmSync(join(ORDNER, datei));
+    }
+    catch {
+        /* schon weg */
+    }
+}
+/** Absagen, die nur DIESE Anfrage betreffen (ihre Form) -- die naechste Anfrage desselben Projekts kann durchgehen. */
+const NUR_DIESES_PAKET = ["rumpf", "zu-viele", "meldung-unlesbar"];
+/**
+ * Was die Antwort fuer die Meldungen bedeutet. 🔑 „merken“ heisst: Ob sie ankamen, ist nicht sicher -- also nochmals
+ * schicken. Das ist harmlos: Dieselbe Meldung zweimal aendert nichts (E-6 vergleicht „spaeter als“, nicht „gleich“).
+ * 🔴 Endgueltig abgesagt ist eine Meldung NUR, wenn die App selbst mit einem `grund` antwortet (Ruling Fixrunde 1):
+ * Eine `413` vom Rumpf-Deckel von Vercel, eine `403`-Seite einer Firewall, eine `400` ohne JSON kamen nie bei der App an
+ * -- wer sie als Absage nimmt, loescht gemerkte Meldungen, die nie jemand geprueft hat. Darum: ohne `grund` „merken“.
+ * Ebenso Aussetzer (5xx, 408, 429) und eine `200`, deren Rumpf nicht die erwartete Form hat (WLAN-Anmeldeportal).
+ */
+export function meldungenErgebnis(status, koerper) {
+    const k = istObjekt(koerper) ? koerper : null;
+    const grund = typeof k?.grund === "string" && k.grund !== "" ? k.grund : null;
+    const meldung = typeof k?.meldung === "string" ? k.meldung : "";
+    if (status === 200) {
+        const abgesagt = Array.isArray(k?.abgesagt) ? k.abgesagt : null;
+        const lesbar = abgesagt?.every((a) => istObjekt(a) && Number.isInteger(a.index) && typeof a.meldung === "string");
+        if (k === null || !Number.isInteger(k.angenommen) || abgesagt === null || !lesbar)
+            return { art: "merken" };
+        return { art: "ok", angenommen: k.angenommen, abgesagt: abgesagt };
+    }
+    if (status === 401)
+        return { art: "anmelden", meldung };
+    if (grund === null || status === 408 || status === 429 || status >= 500)
+        return { art: "merken" };
+    return { art: "absage", grund, meldung, umfang: NUR_DIESES_PAKET.includes(grund) ? "paket" : "projekt" };
+}
+// ── In Paketen schicken (reine Ablaufregel; das Netz kommt als Funktion herein) ──────────────────────────────────
+export const JE_ANFRAGE = 50;
+/**
+ * Schickt die Umschlaege eines Projekts in Paketen zu 50 (Ruling Task 7: eine Anfrage, nicht eine je Meldung).
+ * `je` hat dieselbe Laenge und Reihenfolge wie `umschlaege`; `offen` heisst: nicht sicher, ob sie ankam.
+ * Eine Absage, die das PROJEKT betrifft (geloescht, Planung unlesbar), gilt fuer alle restlichen Meldungen dieses
+ * Projekts; eine, die nur die Form DIESES Pakets betrifft, nur fuer dieses -- die naechsten Pakete gehen trotzdem.
+ */
+export async function sendeInPaketen(umschlaege, schicke) {
+    const je = umschlaege.map(() => ({ art: "offen" }));
+    let problem = null;
+    for (let von = 0; von < umschlaege.length; von += JE_ANFRAGE) {
+        const paket = umschlaege.slice(von, von + JE_ANFRAGE);
+        const v = await schicke(paket);
+        if (v === "netz")
+            return { je, problem: { art: "nicht-erreichbar" } };
+        if (v === "nicht-angemeldet")
+            return { je, problem: { art: "anmelden", meldung: "" } };
+        const e = meldungenErgebnis(v.status, v.koerper);
+        if (e.art === "merken")
+            return { je, problem: { art: "nicht-erreichbar" } };
+        if (e.art === "anmelden")
+            return { je, problem: { art: "anmelden", meldung: e.meldung } };
+        if (e.art === "absage") {
+            const bis = e.umfang === "projekt" ? umschlaege.length : von + paket.length;
+            for (let i = von; i < bis; i++)
+                je[i] = { art: "abgesagt", meldung: e.meldung };
+            problem = { art: "absage", grund: e.grund, meldung: e.meldung };
+            if (e.umfang === "projekt")
+                return { je, problem };
+            continue;
+        }
+        paket.forEach((_, i) => { je[von + i] = { art: "angenommen" }; });
+        for (const a of e.abgesagt)
+            if (a.index >= 0 && a.index < paket.length)
+                je[von + a.index] = { art: "abgesagt", meldung: a.meldung };
+    }
+    return { je, problem };
+}

package/dist/{logo-ablegen.js → mods-ablegen.js}

@@ -1,11 +1,12 @@
 import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { homedir, platform } from "node:os";
+import { basename, dirname, join, posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { EINRICHTEN_TEXTE } from "./texte/einrichten.js";
+import { eigeneVersion } from "./version.js";
 /**
- * Legt den Plugin-Katalog mit dem Logo-Mod in `~/.kimal3/claude-plugins` ab und setzt dort die
- * Sprache des Kontos. Claude Code liest den Mod aus genau diesem Ordner (Katalog `kimal3`,
+ * Legt den Plugin-Katalog mit den beiden Mods (Logo und Board) in `~/.kimal3/claude-plugins` ab und setzt dort die
+ * Sprache des Kontos, im Logo-Mod dazu die Ablage (`mitAblage`). Claude Code liest die Mods aus genau diesem Ordner (Katalog `kimal3`,
  * `plugins-mischen.ts`).
  *
  * 🔑 Warum ein fester Ordner im Benutzerordner und nicht der Ordner im installierten npm-Paket:
@@ -16,6 +17,9 @@ import { EINRICHTEN_TEXTE } from "./texte/einrichten.js";
 export function katalogOrdner() {
     return join(homedir(), ".kimal3", "claude-plugins"); // kein-anzeigetext: Ordnername
 }
+/** Die Dateien der Mods, die die Sprach-Zeile tragen (relativ zum Katalog); nur der Logo-Mod trägt auch die Ablage-Zeile. */
+const LOGO_MOD = join("kimal3-logo", "hooks", "register.tsx"); // kein-anzeigetext: Dateipfad
+const MODS = [LOGO_MOD, join("kimal3-plan", "hooks", "register.tsx")]; // kein-anzeigetext: Dateipfade
 /** Die Zeile im Mod, die die Sprache festlegt -- `check:logo` prüft, dass es sie genau einmal gibt. */
 export const SPRACH_ZEILE = "const SPRACHE: 'de' | 'en' = 'de'"; // kein-anzeigetext: Quelltext des Mods
 /** Reine Rechnung: der Mod-Text in der Sprache des Kontos, oder `null`, wenn die Zeile fehlt. */
@@ -24,10 +28,64 @@ export function mitSprache(quelltext, sprache) {
         return null;
     return quelltext.replace(SPRACH_ZEILE, `const SPRACHE: 'de' | 'en' = '${sprache}'`); // kein-anzeigetext: Quelltext des Mods
 }
+/** Die Zeile im Mod, die beim Ablegen die Ablage bekommt; im Paket steht dort die leere. */
+export const ABLAGE_ZEILE = "const ABLAGE: Ablage = KEINE_ABLAGE"; // kein-anzeigetext: Quelltext des Mods
+/**
+ * Reine Rechnung: der Mod-Text mit der Ablage, oder `null`, wenn die Zeile nicht genau einmal dasteht. Ohne Ablage
+ * (keine eigene Fassung) bleibt die leere Zeile stehen -- der Mod zeigt dann wie bisher nur das Logo (U-9).
+ * 🔴 `split`/`join`, nie `replace(zeile, text)`: Im Ersatz-Text eines `replace` sind `$&` und `$'` Befehle, und ein
+ * Ordnername darf beides enthalten -- dann stünde fremder Quelltext im Mod (messen-und-pruefen §23, U-16). `JSON.stringify`
+ * macht aus jedem Wert ein gültiges Stück Quelltext, auch mit `"` und `\` (Windows-Pfade).
+ */
+export function mitAblage(quelltext, ablage) {
+    const teile = quelltext.split(ABLAGE_ZEILE);
+    if (teile.length !== 2)
+        return null;
+    return ablage === null ? quelltext : teile.join(`const ABLAGE: Ablage = ${JSON.stringify(ablage)}`); // kein-anzeigetext: Quelltext des Mods
+}
+/**
+ * Reine Rechnung hinter `ablageWerte`. Ohne eigene Fassung keine Ablage (`null`).
+ * `npm` ist das `npm-cli.js`, das zu DIESEM Node gehört (Windows daneben, sonst unter `lib/`), und nur dann gesetzt, wenn
+ * es die Datei gibt und `kimal3` global installiert läuft. Sonst `""`: Der Knopf bittet dann Claude (U-10), statt ein
+ * `npm install -g` anzustoßen, nach dem `kimal3 --version` doch die alte Zahl sagte.
+ * 🔑 Global heißt, als Erlaubnisliste (messen-und-pruefen §23): `…/node_modules/kimal3/…` mit genau EINEM `node_modules`,
+ * ohne `_npx` (der Zwischenspeicher von `npx`), und über dem `node_modules` kein `package.json` (sonst ist es der Ordner
+ * eines Projekts). Ein Start aus dem Repo (`cli/dist`) ist damit auch nicht global.
+ */
+export function ablageAus(lage) {
+    if (lage.fassung === null)
+        return null;
+    const p = lage.system === "win32" ? win32 : posix;
+    const npm = lage.system === "win32"
+        ? p.join(p.dirname(lage.node), "node_modules", "npm", "bin", "npm-cli.js") // kein-anzeigetext: Pfad
+        : p.join(p.dirname(p.dirname(lage.node)), "lib", "node_modules", "npm", "bin", "npm-cli.js"); // kein-anzeigetext: Pfad
+    const teile = lage.kimal3.split(/[\\/]/);
+    const i = teile.indexOf("node_modules");
+    const global = i > 0 && teile.lastIndexOf("node_modules") === i && teile[i + 1] === "kimal3" && !teile.includes("_npx")
+        && !lage.gibtEs(p.join(teile.slice(0, i).join(p.sep), "package.json"));
+    return {
+        fassung: lage.fassung,
+        node: lage.node,
+        npm: global && lage.gibtEs(npm) ? npm : "",
+        kimal3: lage.kimal3,
+        kimal3Ordner: p.join(lage.heim, ".kimal3"), // kein-anzeigetext: Ordnername
+    };
+}
+/** Die Ablage dieses Rechners, im laufenden `kimal3` gemessen (Bauplan 2026-10-23, Tabelle in 1.1). */
+export function ablageWerte() {
+    return ablageAus({
+        fassung: eigeneVersion(),
+        node: process.execPath,
+        kimal3: fileURLToPath(new URL("./kimal3.js", import.meta.url)), // kein-anzeigetext: Dateiname
+        heim: homedir(),
+        system: platform(),
+        gibtEs: existsSync,
+    });
+}
 /**
  * 🔴 NIE EIN HALBER ORDNER (Durchsicht-Funde 2 und 9): Claudes Einstellungen zeigen auf `katalogOrdner()`,
  * und eine laufende Claude-Sitzung hat den Mod daraus geladen. Deshalb:
- *   1. Sprache setzen, BEVOR irgendetwas angefasst wird -- fehlt die Zeile, bleibt alles, wie es war.
+ *   1. Sprache und Ablage setzen, BEVOR irgendetwas angefasst wird -- fehlt eine der Zeilen, bleibt alles, wie es war.
  *   2. Steht schon genau das da, was entstehen soll: nichts anfassen (Lage P-8). Das ist auch der Normalfall
  *      eines zweiten Laufs, und so kommt er gar nicht erst in die Nähe der Windows-Sperren unten.
  *   3. Den neuen Ordner daneben fertig bauen (`….neu`), dann tauschen: alten Ordner wegschieben, neuen an
@@ -39,17 +97,23 @@ export function mitSprache(quelltext, sprache) {
  * den der Aufrufer in einer Zeile nennt. Unter Windows hält ihn ein Programm fest, dessen Arbeitsordner darin liegt;
  * Claude selbst tut es nicht (gemessen 18.10. bei acht laufenden Claude-Prozessen, Spec 2026-10-18, Abschnitt 1.2).
  */
-export function logoAblegen(sprache) {
-    // `dist/logo-ablegen.js` -> `../claude-plugins` im installierten Paket (`files` in package.json).
+export function modsAblegen(sprache) {
+    // `dist/mods-ablegen.js` -> `../claude-plugins` im installierten Paket (`files` in package.json).
     const quelle = fileURLToPath(new URL("../claude-plugins", import.meta.url));
     const ziel = katalogOrdner();
     const neu = `${ziel}.neu`; // kein-anzeigetext: Ordnername
-    const modDatei = (ordner) => join(ordner, "kimal3-logo", "hooks", "register.tsx");
     try {
-        const text = mitSprache(readFileSync(modDatei(quelle), "utf8"), sprache);
-        if (text === null)
-            return { ok: false, detail: modDatei(quelle) };
-        if (stehtSchonDa(quelle, ziel, text)) {
+        // Beide Mods bekommen die Sprache des Kontos, der Logo-Mod dazu die Ablage für den Update-Knopf (nur er trägt die
+        // Zeile); fehlt eine Zeile, bleibt alles, wie es war.
+        const texte = new Map();
+        for (const mod of MODS) {
+            const mitSpr = mitSprache(readFileSync(join(quelle, mod), "utf8"), sprache);
+            const text = mitSpr === null ? null : mod === LOGO_MOD ? mitAblage(mitSpr, ablageWerte()) : mitSpr;
+            if (text === null)
+                return { ok: false, detail: join(quelle, mod) };
+            texte.set(mod, text);
+        }
+        if (stehtSchonDa(quelle, ziel, texte)) {
             // Auch im Normalfall aufräumen, samt einem halb gebauten `….neu`: sonst blieben Reste für immer (Durchsicht 3/4).
             rmSync(neu, { recursive: true, force: true });
             resteWegraeumen(ziel);
@@ -57,7 +121,8 @@ export function logoAblegen(sprache) {
         }
         rmSync(neu, { recursive: true, force: true });
         cpSync(quelle, neu, { recursive: true });
-        writeFileSync(modDatei(neu), text, "utf8");
+        for (const [mod, text] of texte)
+            writeFileSync(join(neu, mod), text, "utf8");
         if (!existsSync(ziel)) {
             renameSync(neu, ziel);
             return { ok: true, ordner: ziel, stand: "neu" };
@@ -85,15 +150,15 @@ export function logoAblegen(sprache) {
     }
 }
 /**
- * Für `login` und `skill install` (Spec 2026-10-18, Abschnitt 1.2): ein VORHANDENES Logo auffrischen (Update,
+ * Für `login` und `skill install` (Spec 2026-10-18, Abschnitt 1.2): VORHANDENE Mods auffrischen (Update,
  * Sprachwechsel), nie eines anlegen -- das darf nur `einrichten`, wie beim Coach (`frischeCoachAuf`). Wer das Logo nie
  * eingerichtet hat, hört nichts und bekommt keinen Ordner (L-2). Eine Zeile nur, wenn getauscht wurde, das alte bleiben
  * musste oder etwas scheiterte; sonst Stille. Wirft nie und ändert den Rückgabewert des Befehls nicht (L-6).
  */
-export function frischeLogoAuf(s) {
+export function frischeModsAuf(s) {
     if (!existsSync(katalogOrdner()))
         return;
-    const ablage = logoAblegen(s);
+    const ablage = modsAblegen(s);
     const t = EINRICHTEN_TEXTE[s];
     if (!ablage.ok)
         console.log(t.logoNotWritten(ablage.detail));
@@ -102,16 +167,18 @@ export function frischeLogoAuf(s) {
     else if (ablage.stand === "alt")
         console.log(t.logoNotRefreshed);
 }
-/** Gleiche Dateien, gleicher Inhalt -- der Mod mit der Sprache des Kontos, alles andere wie im Paket. */
-function stehtSchonDa(quelle, ziel, modText) {
+/** Gleiche Dateien, gleicher Inhalt -- die Mods mit Sprache (und im Logo-Mod Ablage), alles andere wie im Paket. */
+function stehtSchonDa(quelle, ziel, modTexte) {
     if (!existsSync(ziel))
         return false;
     const dateien = (ordner) => alleDateien(ordner).sort();
     const soll = dateien(quelle);
     if (JSON.stringify(soll) !== JSON.stringify(dateien(ziel)))
         return false;
-    const mod = join("kimal3-logo", "hooks", "register.tsx");
-    return soll.every((d) => (d === mod ? Buffer.from(modText, "utf8") : readFileSync(join(quelle, d))).equals(readFileSync(join(ziel, d))));
+    return soll.every((d) => {
+        const modText = modTexte.get(d);
+        return (modText === undefined ? readFileSync(join(quelle, d)) : Buffer.from(modText, "utf8")).equals(readFileSync(join(ziel, d)));
+    });
 }
 /**
  * Alle Dateien unter `ordner`, als Pfade relativ dazu. 🔑 Von Hand statt `readdirSync(…, { recursive: true })`: Das kann

package/dist/plugins-mischen.js

@@ -1,6 +1,6 @@
 import { istObjekt, leseEinstellungen } from "./einstellungen-mischen.js";
 /**
- * Traegt superpowers und das KImal3-Logo in Claudes Einstellungen ein -- als Katalog plus
+ * Traegt superpowers, das KImal3-Logo und das Board (kimal3-plan) in Claudes Einstellungen ein -- als Katalog plus
  * Einschalter, so wie Anthropic Firmen-Mods auf jeden Rechner verteilt (Bauplan 2026-10-15,
  * „Warum anders als die Spec"). Beim naechsten Start laedt Claude Code beides selbst.
  *
@@ -10,6 +10,7 @@ import { istObjekt, leseEinstellungen } from "./einstellungen-mischen.js";
  */
 export const KATALOG = "kimal3"; // kein-anzeigetext: Name des Plugin-Katalogs in Claudes Einstellungen
 export const LOGO = `kimal3-logo@${KATALOG}`; // kein-anzeigetext: Plugin-Kennung
+export const PLAN = `kimal3-plan@${KATALOG}`; // kein-anzeigetext: Plugin-Kennung
 const OFFIZIELL = "claude-plugins-official"; // kein-anzeigetext: Anthropics Katalog
 export const SUPERPOWERS = `superpowers@${OFFIZIELL}`; // kein-anzeigetext: Plugin-Kennung
 /**
@@ -47,6 +48,9 @@ export function mischePlugins(alt, katalogPfad, mitSuperpowers = true) {
         neueKataloge[KATALOG] = zeigtSchonHin ? alterEintrag : { ...alterEintrag, source: { source: "directory", path: katalogPfad } };
         if (!(LOGO in plugins))
             neuePlugins[LOGO] = true;
+        // Wie beim Logo: ein Eintrag -- auch `false` -- heißt, er hat entschieden (US-7); nur was fehlt, wird eingeschaltet.
+        if (!(PLAN in plugins))
+            neuePlugins[PLAN] = true;
     }
     if (mitSuperpowers && !Object.keys(plugins).some((k) => k.startsWith("superpowers@"))) {
         neuePlugins[SUPERPOWERS] = true;
@@ -69,10 +73,11 @@ export function pluginStand(inhalt) {
     const lesen = leseEinstellungen(inhalt);
     const plugins = lesen.ok ? lesen.objekt.enabledPlugins : undefined;
     if (!istObjekt(plugins))
-        return { superpowers: "fehlt", logo: "fehlt" };
+        return { superpowers: "fehlt", logo: "fehlt", plan: "fehlt" };
     const superpowers = Object.entries(plugins).filter(([k]) => k.startsWith("superpowers@")).map(([, v]) => v);
     return {
         superpowers: superpowers.includes(true) ? "an" : superpowers.length > 0 ? "aus" : "fehlt",
         logo: plugins[LOGO] === true ? "an" : LOGO in plugins ? "aus" : "fehlt",
+        plan: plugins[PLAN] === true ? "an" : PLAN in plugins ? "aus" : "fehlt",
     };
 }

package/dist/projekt-ordner.js

@@ -0,0 +1,189 @@
+/**
+ * Zu welchem Projekt in der App gehoert dieser Ordner? (Spec 2026-10-23-brett-in-echtzeit-design.md, 1.4, 1.7, S-27
+ * bis S-31, US-8). Die Regel ist eine reine Rechnung (`ordnerlage`, `hauptordnerFuer`): Sie bekommt, was es auf der
+ * Platte gibt, als zwei Funktionen -- so prueft `check:cli` sie gegen die Tabelle in `scripts/projektordner-faelle.mts`,
+ * dieselbe, die der Mod (Task 8) in seine Tests uebernimmt.
+ *
+ * Projektordner: ein Ordner DIREKT in `werkbank-…/projekte/` (englisch `workbench-…/projects/`, auch gemischt), wie
+ * bei `/k3start`; der Beispielordner zaehlt nicht. Eine Arbeitskopie gehoert zum Projekt ihres Hauptordners -- auch
+ * eine, die NEBEN ihm in `projekte/` liegt (sonst waere `kimal3-app-board` ein eigenes Projekt).
+ *
+ * Der Ordnerzettel `plan/projekt.json` traegt Nummer und Titel des Projekts und kommt mit Git mit. Fehlt er, gilt
+ * hoechstens noch `projekt_id` aus `plan/stand.json` -- nur, um den Zettel daraus anzulegen (1.4).
+ */
+import { readFileSync, statSync, mkdirSync } from "node:fs";
+import { schreibeAtomar } from "./atomar.js";
+import { werkbankSpracheAus } from "./werkbank-name.js";
+export const ZETTEL_PFAD = "plan/projekt.json"; // kein-anzeigetext: Dateipfad
+const STAND_PFAD = "plan/stand.json"; // kein-anzeigetext: Dateipfad
+const BEISPIELE = ["beispiel-rechnungen-erfassen", "example-capture-invoices"];
+const PROJEKTORDNER = ["projekte", "projects"];
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const normiert = (pfad) => pfad.replace(/\\/g, "/").replace(/\/+$/, "");
+/** Der Ordner und alle darueber, naechster zuerst (wie `ordnerNachOben` im Logo-Mod). */
+const nachOben = (pfad) => {
+    const teile = normiert(pfad).split("/");
+    return teile.map((_, i) => teile.slice(0, teile.length - i).join("/")).filter((p) => p !== "");
+};
+/** `werkbank-x/projekte/<name>` irgendwo im Pfad -- der aeusserste Treffer, damit `.claude/worktrees/x` nicht zaehlt. */
+function projektordnerIn(pfad) {
+    const teile = normiert(pfad).split("/");
+    for (let i = 0; i + 2 < teile.length; i++) {
+        if (werkbankSpracheAus(teile[i]) === null || !PROJEKTORDNER.includes(teile[i + 1]))
+            continue;
+        const name = teile[i + 2];
+        return name === "" || BEISPIELE.includes(name) ? null : { ordner: teile.slice(0, i + 3).join("/"), name };
+    }
+    return null;
+}
+const ohneBom = (text) => (text.startsWith("") ? text.slice(1) : text);
+function objektAus(text) {
+    if (text === null)
+        return null;
+    try {
+        const j = JSON.parse(ohneBom(text));
+        return j !== null && typeof j === "object" && !Array.isArray(j) ? j : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Der Zettel, wenn er gueltig ist -- sonst `null` (kein JSON, andere Formatnummer, keine Projektnummer). */
+export function zettelAus(text) {
+    const o = objektAus(text);
+    if (o === null || o.format !== 1 || typeof o.projekt_id !== "string" || !UUID.test(o.projekt_id))
+        return null;
+    if (typeof o.titel !== "string" || o.titel.trim() === "")
+        return null;
+    return { format: 1, projekt_id: o.projekt_id, titel: o.titel };
+}
+export function zettelText(z) {
+    return `${JSON.stringify({ format: z.format, projekt_id: z.projekt_id, titel: z.titel }, null, 2)}\n`;
+}
+/** Aus einer alten `plan/stand.json` nur die Nummer (und der Titel, falls er dasteht). */
+function zettelAusStand(text, name) {
+    const o = objektAus(text);
+    if (o === null || typeof o.projekt_id !== "string" || !UUID.test(o.projekt_id))
+        return null;
+    const titel = typeof o.projekt === "string" && o.projekt.trim() !== "" ? o.projekt : name;
+    return { format: 1, projekt_id: o.projekt_id, titel };
+}
+/**
+ * Der Hauptordner einer Git-Arbeitskopie: die naechste `.git` ueber `cwd`. Ist sie eine Datei mit
+ * `gitdir: …/.git/worktrees/<name>`, ist der Ordner davor der Hauptordner; sonst `null` (normales Projekt,
+ * Untermodul, kein Git). Dieselbe Erkennung wie `hauptordnerAusGitdatei` im Logo-Mod.
+ * Ein RELATIVER Pfad (`git worktree add` mit `worktree.useRelativePaths`: `gitdir: ../kimal3-app/.git/worktrees/x`)
+ * gilt ab der Wurzel der Arbeitskopie, nicht ab dem Startordner (Fixrunde 1).
+ */
+export function hauptordnerFuer(cwd, gibt, lies) {
+    const wurzel = nachOben(cwd).find((o) => gibt(`${o}/.git`)); // kein-anzeigetext: Dateipfad
+    if (wurzel === undefined)
+        return null;
+    const text = lies(`${wurzel}/.git`); // kein-anzeigetext: Dateipfad
+    const treffer = text === null ? null : /^gitdir:\s*(.+?)[\\/]\.git[\\/]worktrees[\\/][^\\/]+\s*$/.exec(text.trim());
+    if (treffer === null)
+        return null;
+    const ziel = normiert(treffer[1]);
+    return /^([A-Za-z]:)?\//.test(ziel) ? ziel : aufgeloest(`${wurzel}/${ziel}`);
+}
+/** `.` und `..` in einem Pfad mit `/` aufloesen, ohne die Platte zu fragen (die Wurzel bleibt stehen). */
+function aufgeloest(pfad) {
+    const teile = [];
+    for (const t of pfad.split("/")) {
+        if (t === "." || (t === "" && teile.length > 0))
+            continue;
+        if (t === ".." && teile.length > 1)
+            teile.pop();
+        else if (t !== "..")
+            teile.push(t);
+    }
+    return teile.join("/");
+}
+export function ordnerlage(cwd, gibt, lies, hauptordner) {
+    // In einer Arbeitskopie zaehlt das Projekt des Hauptordners; der Zettel gehoert in ihre eigene Wurzel.
+    const projekt = projektordnerIn(hauptordner ?? cwd);
+    if (projekt === null)
+        return { art: "kein-projektordner" };
+    const ordner = hauptordner === null ? projekt.ordner : nachOben(cwd).find((o) => gibt(`${o}/.git`)) ?? projekt.ordner; // kein-anzeigetext: Dateipfad
+    const orte = ordner === projekt.ordner ? [ordner] : [ordner, projekt.ordner];
+    for (const o of orte) {
+        const zettel = zettelAus(lies(`${o}/${ZETTEL_PFAD}`));
+        if (zettel !== null)
+            return { art: "projekt", ordner, name: projekt.name, zettel, ausStandJson: false };
+    }
+    for (const o of orte) {
+        const zettel = zettelAusStand(lies(`${o}/${STAND_PFAD}`), projekt.name);
+        if (zettel !== null)
+            return { art: "projekt", ordner, name: projekt.name, zettel, ausStandJson: true };
+    }
+    return { art: "projekt", ordner, name: projekt.name, zettel: null, ausStandJson: false };
+}
+// ── Platte ──────────────────────────────────────────────────────────────────────────────────────────────────────────
+const gibtWirklich = (pfad) => {
+    try {
+        statSync(pfad);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const liesWirklich = (pfad) => {
+    try {
+        return readFileSync(pfad, "utf8");
+    }
+    catch {
+        return null; // fehlt, oder ein Ordner (`.git` eines normalen Projekts)
+    }
+};
+/** Die Lage des Ordners, in dem `kimal3` gerade laeuft. */
+export function ordnerlageJetzt() {
+    const cwd = process.cwd();
+    return ordnerlage(cwd, gibtWirklich, liesWirklich, hauptordnerFuer(cwd, gibtWirklich, liesWirklich));
+}
+/** Schreibt den Zettel. `false` heisst: nicht geschrieben (Schreibschutz, Ordner weg). */
+export function schreibeZettel(ordner, z) {
+    try {
+        mkdirSync(`${ordner}/plan`, { recursive: true }); // kein-anzeigetext: Dateipfad
+        schreibeAtomar(`${ordner}/${ZETTEL_PFAD}`, zettelText(z));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const textFeld = (k, name) => k !== null && typeof k === "object" && typeof k[name] === "string" ? k[name] : null;
+/**
+ * Was die Antwort bedeutet. 🔑 Eine `404` ist nur mit dem Grund `projekt-geloescht` ein geloeschtes Projekt -- ohne
+ * Grund kennt die App die Route noch nicht (B-7), und dann darf Claude nicht „Soll ich ein neues anlegen?“ fragen.
+ */
+export function verbindenErgebnis(status, koerper) {
+    const grund = textFeld(koerper, "grund");
+    if (status === 200) {
+        const projektId = textFeld(koerper, "projektId"); // kein-anzeigetext: Feldname der Antwort
+        const titel = textFeld(koerper, "titel");
+        const angelegt = koerper?.angelegt;
+        return projektId !== null && UUID.test(projektId) && titel !== null && typeof angelegt === "boolean"
+            ? { art: "verbunden", projektId, titel, angelegt } : { art: "unlesbar" };
+    }
+    if (status === 404 && grund === "projekt-geloescht")
+        return { art: "geloescht" };
+    if (status === 409 && grund === "projekt-mehrdeutig") {
+        const roh = koerper.kandidaten;
+        const kandidaten = Array.isArray(roh)
+            ? roh.flatMap((x) => {
+                const projektId = textFeld(x, "projektId"); // kein-anzeigetext: Feldname der Antwort
+                const titel = textFeld(x, "titel");
+                return projektId !== null && titel !== null ? [{ projektId, titel }] : [];
+            })
+            : [];
+        return { art: "mehrdeutig", meldung: textFeld(koerper, "meldung") ?? "", kandidaten };
+    }
+    if (status === 409 && grund === "kein-profil")
+        return { art: "kein-profil", meldung: textFeld(koerper, "meldung") ?? "" };
+    // Die Firmenwahl kommt in der Form von `projekt neu` (mit `firmen`/`auswahl`); jede andere 409 ist ein fertiger Satz.
+    const k = koerper;
+    if (status === 409 && (Array.isArray(k?.firmen) || Array.isArray(k?.auswahl)))
+        return { art: "firma" };
+    return { art: "sonst" };
+}

package/dist/texte/einrichten.js

@@ -42,6 +42,7 @@ const de = {
     noWorkbank: "In der Lieferung steckt keine Werkbank. Bitte melde das an kimal3.",
     // Plugins (Bauplan 2026-10-15): Claude liest die Zeile und sagt der Kundin, was nach dem Neustart erscheint.
     logoName: "KImal3-Logo",
+    planName: "KImal3-Board",
     // `an`: eingeschaltet · `aus`: von ihr selbst ausgeschaltet (bleibt so, die Anleitung schickt sie dann nicht ins Menü)
     // · `neu`: gerade eingetragen (kommt mit dem Neustart) oder stand schon da (Durchsicht-Funde 1 und 7).
     pluginsLine: (an, aus, neu) => `  ${M.de.plugins} ${an.length > 0 ? `${an.join(", ")} — ${neu ? "erscheinen, sobald Claude ganz beendet und neu geöffnet ist" : "sind schon eingetragen"}.` : "nichts eingeschaltet."}` +
@@ -57,7 +58,7 @@ const de = {
     // Die Sperre setzt ein anderes Programm mit Arbeitsordner im Logo-Ordner, nicht Claude -- deshalb kein Rat, Claude zu
     // beenden (für App-Nutzer ein Kreis; Spec 2026-10-18, Abschnitt 1.2).
     logoOldVersion: "  Das Logo konnte gerade nicht aufgefrischt werden, weil ein anderes Programm seinen Ordner benutzt. Es kommt beim nächsten `kimal3 einrichten`.",
-    // Auffrischen bei `login` und `skill install` (`frischeLogoAuf`); scheitert es, sagt es `logoNotWritten`.
+    // Auffrischen bei `login` und `skill install` (`frischeModsAuf`); scheitert es, sagt es `logoNotWritten`.
     logoRefreshed: "  Das Logo über dem Eingabefeld ist aufgefrischt. Ist es eingeschaltet, siehst du es nach dem nächsten Neustart von Claude.",
     logoNotRefreshed: "  Das Logo konnte gerade nicht aufgefrischt werden, weil ein anderes Programm seinen Ordner benutzt. Es kommt beim nächsten `kimal3 skill install`.",
 };
@@ -98,6 +99,7 @@ const en = {
     unsafeFolder: (name) => `The server sent a folder name I won't create: ${name}. Please report this to kimal3.`,
     noWorkbank: "The delivery contains no workbench. Please report this to kimal3.",
     logoName: "KImal3 logo",
+    planName: "KImal3 board",
     pluginsLine: (an, aus, neu) => `  ${M.en.plugins} ${an.length > 0 ? `${an.join(", ")} — ${neu ? "will appear once Claude is fully quit and reopened" : "already added"}.` : "nothing switched on."}` +
         (aus.length > 0 ? ` Switched off by you, stays off: ${aus.join(", ")}.` : ""),
     pluginsNotWritten: (grund) => `  ${M.en.plugins} not added — ${grund}`,