kimal3 0.4.0-durchstich.1 → 0.4.0

package/dist/logo-ablegen.js

@@ -0,0 +1,117 @@
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * 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`,
+ * `plugins-mischen.ts`).
+ *
+ * 🔑 Warum ein fester Ordner im Benutzerordner und nicht der Ordner im installierten npm-Paket:
+ * Der hängt am Installationsort von Node.js und wechselt mit ihm -- der Eintrag in Claudes
+ * Einstellungen zeigte dann ins Leere.
+ * 🔑 Der Ordner gehört `kimal3` (seine README sagt es): Jeder Lauf ersetzt ihn ganz (Lage P-11).
+ */
+export function katalogOrdner() {
+    return join(homedir(), ".kimal3", "claude-plugins"); // kein-anzeigetext: Ordnername
+}
+/** 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. */
+export function mitSprache(quelltext, sprache) {
+    if (quelltext.split(SPRACH_ZEILE).length !== 2)
+        return null;
+    return quelltext.replace(SPRACH_ZEILE, `const SPRACHE: 'de' | 'en' = '${sprache}'`); // kein-anzeigetext: Quelltext des Mods
+}
+/**
+ * 🔴 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.
+ *   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
+ *      seinen Platz, alten löschen.
+ * 🔑 Der weggeschobene Ordner bekommt bei JEDEM Lauf einen frischen Namen (Durchsicht 2, Funde 2 und 4):
+ * Ein Rest, den Windows festhält, blockiert so keinen späteren Lauf, und zurückgeholt wird nur, was
+ * DIESER Lauf weggeschoben hat -- nie ein veralteter Rest von früher.
+ * Lässt sich der alte nicht wegschieben (Claude hält ihn manchmal fest), bleibt er unversehrt stehen und
+ * gilt weiter: ein Erfolg mit `alterStand`, den `kimal3 einrichten` in einer Zeile nennt.
+ */
+export function logoAblegen(sprache) {
+    // `dist/logo-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)) {
+            // 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);
+            return { ok: true, ordner: ziel };
+        }
+        rmSync(neu, { recursive: true, force: true });
+        cpSync(quelle, neu, { recursive: true });
+        writeFileSync(modDatei(neu), text, "utf8");
+        if (!existsSync(ziel)) {
+            renameSync(neu, ziel);
+            return { ok: true, ordner: ziel };
+        }
+        const alt = `${ziel}.alt-${Date.now()}`; // kein-anzeigetext: Ordnername
+        try {
+            renameSync(ziel, alt);
+        }
+        catch {
+            rmSync(neu, { recursive: true, force: true });
+            return { ok: true, ordner: ziel, alterStand: true };
+        }
+        try {
+            renameSync(neu, ziel);
+        }
+        catch (e) {
+            renameSync(alt, ziel);
+            return { ok: false, detail: e.message };
+        }
+        resteWegraeumen(ziel);
+        return { ok: true, ordner: ziel };
+    }
+    catch (e) {
+        return { ok: false, detail: e.message };
+    }
+}
+/** Gleiche Dateien, gleicher Inhalt -- der Mod mit der Sprache des Kontos, alles andere wie im Paket. */
+function stehtSchonDa(quelle, ziel, modText) {
+    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))));
+}
+/**
+ * Alle Dateien unter `ordner`, als Pfade relativ dazu. 🔑 Von Hand statt `readdirSync(…, { recursive: true })`: Das kann
+ * Node.js erst ab 20.1, und unter 20.0 fände der Vergleich gar keine Datei -- „gleich“, und das Logo würde nie erneuert
+ * (Durchsicht 3, Fund 7; `engines` erlaubt 20).
+ */
+function alleDateien(ordner, unter = "") {
+    return readdirSync(join(ordner, unter), { withFileTypes: true }).flatMap((e) => e.isDirectory() ? alleDateien(ordner, join(unter, e.name)) : e.isFile() ? [join(unter, e.name)] : []);
+}
+/** Weggeschobene Ordner früherer Läufe (`claude-plugins.alt…`); was Windows noch festhält, bleibt bis zum nächsten Lauf. */
+function resteWegraeumen(ziel) {
+    const name = `${basename(ziel)}.alt`; // kein-anzeigetext: Ordnername
+    for (const eintrag of readdirSync(dirname(ziel))) {
+        if (!eintrag.startsWith(name))
+            continue;
+        try {
+            rmSync(join(dirname(ziel), eintrag), { recursive: true, force: true });
+        }
+        catch {
+            /* festgehalten -- der nächste Lauf versucht es wieder */
+        }
+    }
+}

package/dist/plugins-mischen.js

@@ -0,0 +1,78 @@
+import { istObjekt, leseEinstellungen } from "./einstellungen-mischen.js";
+/**
+ * Traegt superpowers und das KImal3-Logo 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.
+ *
+ * 🔴 DIESE DATEI FASST KEINE DATEI AN -- dieselbe Bauform wie `einstellungen-mischen.ts`, aus
+ * demselben Grund: In `~/.claude/settings.json` steht der Arbeitsplatz des Menschen.
+ * Geschrieben wird ueber `einstellungen-schreiben.ts` (Sicherung, Zuruecklesen).
+ */
+export const KATALOG = "kimal3"; // kein-anzeigetext: Name des Plugin-Katalogs in Claudes Einstellungen
+export const LOGO = `kimal3-logo@${KATALOG}`; // kein-anzeigetext: Plugin-Kennung
+const OFFIZIELL = "claude-plugins-official"; // kein-anzeigetext: Anthropics Katalog
+export const SUPERPOWERS = `superpowers@${OFFIZIELL}`; // kein-anzeigetext: Plugin-Kennung
+/**
+ * 🔑 Jede Entscheidung des Menschen bleibt stehen (Lagen P-5 bis P-7, P-10):
+ * - Ein Eintrag fuer das Logo -- auch `false` -- heisst: Er hat schon entschieden. Wir setzen
+ *   nur, was fehlt.
+ * - superpowers aus IRGENDEINEM Katalog (`superpowers@…`, an oder aus) heisst: nicht noch eins.
+ *   Zwei superpowers gaeben jede Faehigkeit doppelt.
+ * - Den offiziellen Katalog tragen wir nur ein, wenn er fehlt und wir superpowers einschalten.
+ * Nur der Katalog `kimal3` gehoert uns: Er zeigt immer auf unseren Ordner (P-9, Umzug).
+ * 🔑 `katalogPfad` ist `null`, wenn der Logo-Ordner nicht angelegt werden konnte: Dann bleiben Katalog und
+ * Logo-Eintrag, wie sie sind, und superpowers kommt trotzdem -- es braucht den Ordner nicht (Durchsicht 2, Fund 1).
+ * 🔑 `mitSuperpowers` ist `false`, wenn Git fehlt: Claude Code klont Anthropics Katalog mit Git und scheiterte sonst bei
+ * jedem Start (Durchsicht 3, Fund 5). Was schon drinsteht, bleibt -- auch ein früher eingetragenes superpowers.
+ */
+export function mischePlugins(alt, katalogPfad, mitSuperpowers = true) {
+    const lesen = leseEinstellungen(alt);
+    if (!lesen.ok)
+        return { art: "abgelehnt", grund: lesen.grund };
+    const { objekt, leer } = lesen;
+    const kataloge = objekt.extraKnownMarketplaces ?? {};
+    const plugins = objekt.enabledPlugins ?? {};
+    if (!istObjekt(kataloge) || !istObjekt(plugins))
+        return { art: "abgelehnt", grund: "fremde-form" };
+    // Nur die Quelle gehört uns; was Claude Code selbst in den Eintrag schreibt (`autoUpdate`, wenn
+    // Sabine es unter /plugin umschaltet), bleibt stehen (QA-Fund 7). Zeigt die Quelle schon auf unseren
+    // Ordner, bleibt der Eintrag Zeichen für Zeichen, wie er ist -- auch in anderer Reihenfolge der
+    // Schlüssel; sonst schriebe jeder Lauf die Datei neu (Durchsicht-Fund 6, Lage P-8).
+    const alterEintrag = istObjekt(kataloge[KATALOG]) ? kataloge[KATALOG] : {};
+    const alteQuelle = istObjekt(alterEintrag.source) ? alterEintrag.source : {};
+    const zeigtSchonHin = alteQuelle.source === "directory" && alteQuelle.path === katalogPfad;
+    const neueKataloge = { ...kataloge };
+    const neuePlugins = { ...plugins };
+    if (katalogPfad !== null) {
+        neueKataloge[KATALOG] = zeigtSchonHin ? alterEintrag : { ...alterEintrag, source: { source: "directory", path: katalogPfad } };
+        if (!(LOGO in plugins))
+            neuePlugins[LOGO] = true;
+    }
+    if (mitSuperpowers && !Object.keys(plugins).some((k) => k.startsWith("superpowers@"))) {
+        neuePlugins[SUPERPOWERS] = true;
+        if (!(OFFIZIELL in kataloge)) {
+            neueKataloge[OFFIZIELL] = { source: { source: "github", repo: "anthropics/claude-plugins-official" } };
+        }
+    }
+    const neu = { ...objekt, extraKnownMarketplaces: neueKataloge, enabledPlugins: neuePlugins };
+    // Wie bei der Wache: Wer nichts zu tun hat, fasst die Datei nicht an (P-8).
+    if (!leer && JSON.stringify(neu) === JSON.stringify(objekt))
+        return { art: "unveraendert" };
+    return { art: "geschrieben", inhalt: JSON.stringify(neu, null, 2) + "\n" };
+}
+/**
+ * Was nach dem Eintragen wirklich gilt -- fuer die Zeile `Plugins:`, die Claude der Kundin weitersagt.
+ * 🔑 Aus der Datei gelesen, nicht aus dem, was wir eingetragen haben: Hat sie superpowers selbst
+ * ausgeschaltet, muss die Zeile das sagen, damit die Anleitung sie nicht ins Menue schickt (Durchsicht-Fund 1).
+ */
+export function pluginStand(inhalt) {
+    const lesen = leseEinstellungen(inhalt);
+    const plugins = lesen.ok ? lesen.objekt.enabledPlugins : undefined;
+    if (!istObjekt(plugins))
+        return { superpowers: "fehlt", logo: "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",
+    };
+}

package/dist/texte/coach.js

@@ -0,0 +1,27 @@
+import { EINRICHTEN_MARKEN } from "./einrichten-marken.js";
+const M = EINRICHTEN_MARKEN;
+const de = {
+    setUp: (pfad) => `  ${M.de.coach} eingerichtet (${pfad}).`,
+    upToDate: `  ${M.de.coach} ist aktuell.`,
+    updated: `  ${M.de.coach} aktualisiert — deine gelernten Regeln sind geblieben.`,
+    foreign: (pfad) => `  ${M.de.coach} Unter ${pfad} liegt schon eine Datei, die nicht von KImal3 stammt — ich lasse sie, wie sie ist.`,
+    noSeparator: (pfad, neu) => `  ${M.de.coach} nicht aktualisiert — in ${pfad} fehlt die Zeile, ab der deine gelernten Regeln stehen. Die neue Fassung liegt unter ${neu}.`,
+    failed: (grund) => `  ${M.de.coach} konnte nicht abgelegt werden — ${grund}`,
+    // Der Grund zu `failed`, wenn der Vorlage im Programm selbst die Trenn-Marke fehlt (ein Paketfehler, `coach-rechnung.ts`).
+    templateWithoutSeparator: "der Vorlage im Programm fehlt die Zeile, ab der die gelernten Regeln stehen. Das ist ein Fehler in kimal3 — bitte melde ihn uns.",
+    // Die Zeile spricht immer die Sprache, in die umgestellt wurde -- deshalb steht der Sprachname fest im Satz.
+    languageSwitched: "✓ Dein Coach ist jetzt auf Deutsch — deine gelernten Regeln sind geblieben.",
+    oldCourseCoach: (pfad, ablage) => `  ${M.de.alterKursCoach} Du hast im alten Mini-Kurs schon einmal einen Coach eingerichtet (${pfad}). Jetzt gibt es einen neuen, und zwei gleichzeitig würden sich widersprechen. Soll ich den alten beiseitelegen? Du findest ihn danach unter ${ablage}.`,
+};
+const en = {
+    setUp: (pfad) => `  ${M.en.coach} set up (${pfad}).`,
+    upToDate: `  ${M.en.coach} up to date.`,
+    updated: `  ${M.en.coach} updated — your learned rules are still there.`,
+    foreign: (pfad) => `  ${M.en.coach} There's already a file at ${pfad} that doesn't come from KImal3 — I'll leave it as it is.`,
+    noSeparator: (pfad, neu) => `  ${M.en.coach} not updated — ${pfad} is missing the line your learned rules start below. The new version is at ${neu}.`,
+    failed: (grund) => `  ${M.en.coach} couldn't be put in place — ${grund}`,
+    templateWithoutSeparator: "the program's template is missing the line your learned rules start below. That's a bug in kimal3 — please tell us.",
+    languageSwitched: "✓ Your coach is now in English — your learned rules are still there.",
+    oldCourseCoach: (pfad, ablage) => `  ${M.en.alterKursCoach} You set up a coach in the old mini course (${pfad}). There's a new one now, and two at once would contradict each other. Shall I put the old one aside? You'll find it at ${ablage} afterwards.`,
+};
+export const COACH_TEXTE = { de, en };

package/dist/texte/einrichten-marken.js

@@ -4,6 +4,6 @@
  * Programm druckt sie, die Anleitung nennt sie, `check:kurs` haelt beide gleich.
  */
 export const EINRICHTEN_MARKEN = {
-    de: { code: "Anmelde-Code:", adresse: "Adresse:", arbeitsplatz: "Arbeitsplatz:", werkbank: "Werkbank:", angemeldet: "Angemeldet als" },
-    en: { code: "Sign-in code:", adresse: "Address:", arbeitsplatz: "Workplace:", werkbank: "Workbench:", angemeldet: "Signed in as" },
+    de: { code: "Anmelde-Code:", adresse: "Adresse:", arbeitsplatz: "Arbeitsplatz:", werkbank: "Werkbank:", angemeldet: "Angemeldet als", plugins: "Plugins:", naechster: "Als Nächstes:", coach: "Coach:", alterKursCoach: "Alter Kurs-Coach:" },
+    en: { code: "Sign-in code:", adresse: "Address:", arbeitsplatz: "Workplace:", werkbank: "Workbench:", angemeldet: "Signed in as", plugins: "Plugins:", naechster: "Next:", coach: "Coach:", alterKursCoach: "Old course coach:" },
 };

package/dist/texte/einrichten.js

@@ -5,31 +5,102 @@ const de = {
     addressLine: (url) => `  ${M.de.adresse} ${url}`,
     browserOpened: "  Ich öffne die Seite gerade in deinem Browser. Bestätige dort nur, wenn derselbe Code dasteht.",
     browserNotOpened: "  Öffne die Adresse oben in deinem Browser. Bestätige dort nur, wenn derselbe Code dasteht.",
-    help: "\n  kimal3 einrichten [--firma \"Name\" | --firma-id \"…\"]\n\n  Meldet dich an (der Browser öffnet sich mit deinem Code), legt deinen\n  KI-Arbeitsplatz in deinem Benutzerordner an, richtet die /k3-Befehle und\n  die Wache ein und hakt die Schritte im Kurs ab. Ein zweiter Lauf ergänzt\n  nur, was fehlt.\n",
+    help: "\n  kimal3 einrichten [--firma \"Name\" | --firma-id \"…\"] [--arbeitsplatz \"<pfad>\"] [--werkbank <name>]\n\n  Meldet dich an (der Browser öffnet sich mit deinem Code), sucht deinen\n  KI-Arbeitsplatz oder legt ihn in deinem Benutzerordner an, richtet die\n  /k3-Befehle und die Wache ein und hakt die Schritte im Kurs ab. Ein\n  vorhandener Arbeitsplatz wird benutzt, nicht verändert.\n\n  --arbeitsplatz  wo dein Arbeitsplatz liegt oder neu entstehen soll\n  --werkbank      welche Werkbank darin deine ist\n",
     start: "\nIch richte deinen KI-Arbeitsplatz ein.",
     filesWritten: (neu, schonDa) => `\n✓ ${neu} Dateien angelegt, ${schonDa} lagen schon da.`,
     workplaceLine: (pfad) => `  ${M.de.arbeitsplatz} ${pfad}`,
     workbenchLine: (name) => `  ${M.de.werkbank} ${name}`,
+    // Was Sabine in der nächsten Sitzung schreibt (Spec 2026-10-16, Z-15): Steht die Anleitung für die erste
+    // Sitzung noch in ihrer Werkbank, der Startsatz der Vorlage; sonst der Befehl für jeden weiteren Tag.
+    nextLine: (offen) => `  ${M.de.naechster} ${offen ? "„Lass uns einrichten“" : "/k3start"}`,
+    // Vorhandener Arbeitsplatz (Spec 2026-10-16, „Neue Sätze“). Jede Rückfrage endet mit fertigen Befehlen.
+    foundWorkplace: (pfad) => `\nDein Arbeitsplatz liegt schon unter ${pfad} — ich benutze diesen.`,
+    severalFound: "\nIch habe mehrere Arbeitsplätze gefunden. Welchen soll ich benutzen?",
+    foreignFolder: (pfad) => `\nUnter ${pfad} liegt schon ein Ordner, der nicht von KImal3 stammt. Ich lege dort nichts ab.`,
+    searchIncomplete: "\nIch konnte nicht überall nachsehen. Hast du schon einen Arbeitsplatz?",
+    rememberedGone: (pfad) => `\nDein Arbeitsplatz lag unter ${pfad}, dort ist er nicht mehr. Wo liegt er jetzt?`,
+    noMatchingWorkbench: (pfad) => `\nIn ${pfad} finde ich keine Werkbank für dich.`,
+    confirmWorkbench: (name) => `\nIst ${name} deine Werkbank?`,
+    noWorkbenchInWorkplace: (pfad) => `\nIn ${pfad} gibt es noch keine Werkbank. Leg deine an und starte die Einrichtung danach noch einmal:`,
+    // Die Überschriften über den Befehlen der Rückfragen.
+    existingWorkplace: "  Er liegt hier (Pfad einsetzen):",
+    newWorkplace: "  Leg einen neuen an:",
+    otherPlace: "  Nimm einen anderen Ort, leer oder mit deinem Arbeitsplatz:",
+    yes: "  Ja:",
+    noOther: "  Nein, es ist eine andere:",
+    oneOfThese: "  Ist eine davon deine:",
+    ownWorkbench: "  Noch keine eigene? Leg sie an und starte die Einrichtung danach noch einmal:",
+    pathPlaceholder: "<pfad>",
+    // Ein mitkopierter Platzhalter in `--arbeitsplatz` -- Claude fragt dann nach dem echten Ort.
+    placeholderPath: (wert) => `\n${wert} ist ein Platzhalter, kein Ordner. Setz dort den echten Pfad deines Arbeitsplatzes ein; ich habe nichts angelegt.`,
+    commandLine: (rest) => `    kimal3 ${rest}`,
+    cdLine: (pfad) => `    cd ${pfad}`,
     courseMarked: "✓ Im Kurs abgehakt.",
     courseNotMarked: "  Die Haken im Kurs konnte ich gerade nicht setzen — der nächste Lauf holt das nach.",
     done: "\n✓ Fertig eingerichtet.",
     unsafeFolder: (name) => `Der Server hat einen Ordnernamen geschickt, den ich nicht anlege: ${name}. Bitte melde das an kimal3.`,
     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",
+    // `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."}` +
+        (aus.length > 0 ? ` Selbst ausgeschaltet, bleibt aus: ${aus.join(", ")}.` : ""),
+    pluginsNotWritten: (grund) => `  ${M.de.plugins} nicht eingetragen — ${grund}`,
+    settingsInvalid: "deine Claude-Einstellungen (~/.claude/settings.json) sind kein gültiges JSON. Ich habe sie nicht angefasst.",
+    settingsForeign: "in deinen Claude-Einstellungen (~/.claude/settings.json) steht etwas in einer Form, die ich nicht kenne. Ich habe sie nicht angefasst.",
+    settingsFailed: (ursache) => `deine Claude-Einstellungen (~/.claude/settings.json): ${ursache}.`,
+    // Logo (Durchsicht 2, Funde 1 und 3): Scheitert der Ordner, kommt superpowers trotzdem; hält Claude ihn fest, gilt die alte Fassung.
+    logoNotWritten: (detail) => `  Den Ordner für das KImal3-Logo konnte ich nicht anlegen oder erneuern (${detail}).`,
+    // Ohne Git kein superpowers (Durchsicht 3, Fund 5); die Anleitung zitiert den Anfang dieser Zeile.
+    superpowersNeedsGit: "  superpowers braucht Git — es kommt mit dem nächsten `kimal3 einrichten`, sobald Git da ist.",
+    logoOldVersion: "  Das KImal3-Logo bleibt vorerst in der bisherigen Fassung, weil Claude den Ordner gerade benutzt. Beende Claude ganz und starte danach `kimal3 einrichten` noch einmal.",
 };
 const en = {
     codeLine: (code) => `\n  ${M.en.code} ${code}`,
     addressLine: (url) => `  ${M.en.adresse} ${url}`,
     browserOpened: "  Opening the page in your browser now. Only confirm there if it shows the same code.",
     browserNotOpened: "  Open the address above in your browser. Only confirm there if it shows the same code.",
-    help: "\n  kimal3 setup [--company \"Name\" | --company-id \"…\"]\n\n  Signs you in (your browser opens with your code), creates your AI Workplace\n  in your user folder, sets up the /k3 commands and the watch, and ticks off\n  the course steps. A second run only adds what is missing.\n",
+    help: "\n  kimal3 setup [--company \"Name\" | --company-id \"…\"] [--workplace \"<path>\"] [--workbench <name>]\n\n  Signs you in (your browser opens with your code), finds your AI Workplace\n  or creates it in your user folder, sets up the /k3 commands and the watch,\n  and ticks off the course steps. An existing workplace is used, not changed.\n\n  --workplace  where your workplace is, or where a new one should go\n  --workbench  which workbench in it is yours\n",
     start: "\nSetting up your AI Workplace.",
     filesWritten: (neu, schonDa) => `\n✓ ${neu} files created, ${schonDa} were already there.`,
     workplaceLine: (pfad) => `  ${M.en.arbeitsplatz} ${pfad}`,
     workbenchLine: (name) => `  ${M.en.werkbank} ${name}`,
+    // The start sentence of the English template (workbench-your-name/CLAUDE.md, anleitung-en.ts) -- exactly that one.
+    nextLine: (offen) => `  ${M.en.naechster} ${offen ? "“Let's get set up”" : "/k3start"}`,
+    foundWorkplace: (pfad) => `\nYour workplace already exists at ${pfad} — I'll use that one.`,
+    severalFound: "\nI found more than one workplace. Which one should I use?",
+    foreignFolder: (pfad) => `\nThere's already a folder at ${pfad} that doesn't come from KImal3. I won't put anything there.`,
+    searchIncomplete: "\nI couldn't look everywhere. Do you already have a workplace?",
+    rememberedGone: (pfad) => `\nYour workplace was at ${pfad} and isn't there anymore. Where is it now?`,
+    noMatchingWorkbench: (pfad) => `\nI can't find a workbench for you in ${pfad}.`,
+    confirmWorkbench: (name) => `\nIs ${name} your workbench?`,
+    noWorkbenchInWorkplace: (pfad) => `\nThere's no workbench in ${pfad} yet. Create yours, then run the setup again:`,
+    existingWorkplace: "  It's here (fill in the path):",
+    newWorkplace: "  Create a new one:",
+    otherPlace: "  Choose another place, empty or with your workplace in it:",
+    yes: "  Yes:",
+    noOther: "  No, it's another one:",
+    oneOfThese: "  If one of these is yours:",
+    ownWorkbench: "  None of your own yet? Create it, then run the setup again:",
+    pathPlaceholder: "<path>",
+    placeholderPath: (wert) => `\n${wert} is a placeholder, not a folder. Put the real path of your workplace there; I haven't created anything.`,
+    commandLine: (rest) => `    kimal3 ${rest}`,
+    cdLine: (pfad) => `    cd ${pfad}`,
     courseMarked: "✓ Ticked off in the course.",
     courseNotMarked: "  I couldn't tick off the course steps just now — the next run will catch up.",
     done: "\n✓ All set up.",
     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",
+    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}`,
+    settingsInvalid: "your Claude settings (~/.claude/settings.json) are not valid JSON. I left them untouched.",
+    settingsForeign: "your Claude settings (~/.claude/settings.json) contain something in a form I don't know. I left them untouched.",
+    settingsFailed: (ursache) => `your Claude settings (~/.claude/settings.json): ${ursache}.`,
+    logoNotWritten: (detail) => `  I couldn't create or renew the folder for the KImal3 logo (${detail}).`,
+    superpowersNeedsGit: "  superpowers needs Git — it comes with the next `kimal3 setup` once Git is there.",
+    logoOldVersion: "  The KImal3 logo stays on its previous version for now, because Claude is using the folder. Quit Claude completely, then run `kimal3 setup` again.",
 };
 export const EINRICHTEN_TEXTE = { de, en };

package/dist/texte/kurs.js

@@ -0,0 +1,21 @@
+const de = {
+    beatFertig: (nummer) => `Beat ${nummer} ✓`,
+    beatTeil: (nummer, erledigt, gesamt) => `Beat ${nummer} — ${erledigt} von ${gesamt}`,
+    uebersicht: (beats) => `Kurs: ${beats}`,
+    alleErledigt: (anzahl) => `Kurs: abgeschlossen ✓ — alle ${anzahl} Schritte erledigt.`,
+    naechster: (text, claude) => `Als Nächstes: ${text} (${claude ? "setzt Claude" : "du hakst ab"})`,
+    nochOffen: "Noch offen:",
+    offenZeile: (beat, text, claude) => `  ○ Beat ${beat}: ${text} (${claude ? "setzt Claude" : "du hakst ab"})`,
+    imBrowser: (url) => `Im Browser: ${url}/kurs`,
+};
+const en = {
+    beatFertig: (nummer) => `Part ${nummer} ✓`,
+    beatTeil: (nummer, erledigt, gesamt) => `Part ${nummer} — ${erledigt} of ${gesamt}`,
+    uebersicht: (beats) => `Course: ${beats}`,
+    alleErledigt: (anzahl) => `Course: complete ✓ — all ${anzahl} steps done.`,
+    naechster: (text, claude) => `Next: ${text} (${claude ? "Claude sets it" : "you tick it off"})`,
+    nochOffen: "Still open:",
+    offenZeile: (beat, text, claude) => `  ○ Part ${beat}: ${text} (${claude ? "Claude sets it" : "you tick it off"})`,
+    imBrowser: (url) => `In the browser: ${url}/kurs`,
+};
+export const KURS_TEXTE = { de, en };

package/dist/wache-schalter.js

@@ -32,6 +32,8 @@ export function leseWacheDatei() {
         if (Array.isArray(inhalt.sitzungen)) {
             raus.sitzungen = inhalt.sitzungen.filter((s) => typeof s === "string");
         }
+        if (typeof inhalt.eingerichtet === "string")
+            raus.eingerichtet = inhalt.eingerichtet;
         return raus;
     }
     catch {
@@ -116,6 +118,22 @@ export function merkeSitzung(sitzung) {
         return;
     schreibeWacheDatei(mitSitzung(leseWacheDatei() ?? {}, sitzung));
 }
+/**
+ * Merken, in welcher Claude-Sitzung die Wache gerade eingetragen wurde. Wirft nie.
+ *
+ * 🔴 NICHT `merkeSitzung` (Sandbox-Lauf 14.10., Befund S-3): Der Eintrag greift erst beim
+ * naechsten Start -- ohne Merkzettel meldete der naechste Befehl in derselben Sitzung sofort
+ * "hat nicht nachgesehen". Bis 0.4.0-durchstich.1 stempelte `skill install` deshalb die
+ * Sitzung als NACHGESEHEN. Das hielt den Fehlalarm still, aber auch die Wache selbst: Wer im
+ * selben Gespraech weitermacht, hoerte sie am ersten Tag nie (gemessen: das Pro-Angebot lag
+ * bereit, `cli_nachrichten_gezeigt` blieb leer). Ein eigenes Feld trennt beides --
+ * `wacheAusgefallen` liest es, `schonFuerDieseSitzung` nicht.
+ */
+export function merkeEinrichtung(sitzung) {
+    if (sitzung === null)
+        return;
+    schreibeWacheDatei({ ...(leseWacheDatei() ?? {}), eingerichtet: sitzung });
+}
 /** Wie viele Sitzungen der Merkzettel sich merkt -- genug fuer mehrere Fenster ueber Tage. */
 const MERKE_SITZUNGEN = 20;
 /**
@@ -171,7 +189,10 @@ function gesehen(inhalt, jetzt) {
  * Terminalfenster tippt, will die Antwort jetzt -- ein Merkzettel von gestern
  * darf ihn nicht zum Schweigen bringen.
  */
-export function schonFuerDieseSitzung(inhalt, jetzt) {
+export function schonFuerDieseSitzung(
+// `eingerichtet` steht im Typ, damit der ganze Merkzettel hereinpasst -- gelesen wird es
+// hier ABSICHTLICH nicht: Eingerichtet heisst nicht nachgesehen (S-3, `merkeEinrichtung`).
+inhalt, jetzt) {
     return jetzt !== null && inhalt !== null && gesehen(inhalt, jetzt);
 }
 /**
@@ -186,9 +207,13 @@ export function schonFuerDieseSitzung(inhalt, jetzt) {
  * dann aus wie an einem guten Tag. *Eine Wache, die still stirbt, ist
  * schlimmer als keine: Sie kauft Vertrauen und deckt nichts mehr.*
  *
- * 🔴 DREI MAL SCHWEIGEN, EINMAL SPRECHEN:
+ * 🔴 FUENF MAL SCHWEIGEN, EINMAL SPRECHEN:
  *   - Keine Sitzungsnummer -> der Mensch sitzt im Terminalfenster, die Wache
  *     hatte nie einen Anlass zu laufen. "Nicht gelaufen" heisst hier nichts.
+ *   - Kein Merkzettel -> die Wache war nie eingerichtet; `skill install` legt ihn an.
+ *     Bis 0.4.0-durchstich.1 meldete das hier -- die allererste Ausgabe einer neuen
+ *     Kundin war ein Fehlalarm (Sandbox-Lauf 14.10., Befund S-2).
+ *   - In dieser Sitzung eingerichtet -> sie greift erst beim naechsten Start (S-3).
  *   - Abgeschaltet -> wer `kimal3 wache aus` getippt hat, will nicht taeglich
  *     daran erinnert werden. Sonst waere der Ausschalter keiner.
  *   - Dieselbe Nummer -> sie hat fuer diese Sitzung nachgesehen.
@@ -201,9 +226,9 @@ export function wacheAusgefallen(
 // Fassung traegt genau das und sonst nichts, und dieser Fall gehoert
 // geprueft. Ein Typ, der ihn verbietet, verbietet auch seine Pruefung.
 inhalt, jetzt) {
-    if (jetzt === null)
+    if (jetzt === null || inhalt === null)
         return false;
-    if (inhalt !== null && inhalt.aus === true)
+    if (inhalt.aus === true)
         return false;
-    return inhalt === null || !gesehen(inhalt, jetzt);
+    return !gesehen(inhalt, jetzt) && inhalt.eingerichtet !== jetzt;
 }

package/package.json

@@ -1,27 +1,29 @@
-{
-  "name": "kimal3",
-  "version": "0.4.0-durchstich.1",
-  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
-  "type": "module",
-  "bin": {
-    "kimal3": "dist/kimal3.js"
-  },
-  "files": [
-    "dist",
-    "skill",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "kimal3",
-    "cli"
-  ],
-  "homepage": "https://app.kimal3.de/pro",
-  "license": "SEE LICENSE IN README.md"
-}
+{
+  "name": "kimal3",
+  "version": "0.4.0",
+  "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
+  "type": "module",
+  "bin": {
+    "kimal3": "dist/kimal3.js"
+  },
+  "files": [
+    "dist",
+    "skill",
+    "claude-plugins",
+    "coach",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "kimal3",
+    "cli"
+  ],
+  "homepage": "https://app.kimal3.de/pro",
+  "license": "SEE LICENSE IN README.md"
+}

package/skill/SKILL.md

@@ -24,7 +24,7 @@ den du erkennst.
 | `/k3` | Wo er steht — und alle kimal3-Befehle auf einen Blick |
 | `/k3start` | Sitzung starten: wo das Projekt steht und was als Nächstes dran ist |
 | `/k3feierabend` | Sitzung sauber beenden: Stand sichern, aufräumen, zusammenfassen |
-| `/k3kurs` | Zurück in den Mini-Kurs — da weiter, wo er aufgehört hat |
+| `/k3kurs` | Zurück in den Mini-Kurs — holt den Stand mit `kimal3 kurs` und macht da weiter, wo er aufgehört hat |
 | `/k3projekt` | Ein fertiges Projekt ins Erfolgsprofil eintragen |
 | `/k3liste` | Seine eingetragenen Projekte zeigen |
 | `/k3analyse` | Firmendaten holen und seine Frage dazu beantworten |
@@ -158,8 +158,7 @@ gemeinsam ausfüllen — es sind vier verschiedene. Such nach eckigen Klammern,
 zu folgen: Eine abgetippte Liste veraltet in dem Moment, in dem die Vorlage wächst. Frag nach,
 statt zu raten.
 
-⚠️ `[FIRMA]` findest du meist schon ausgefüllt — den Namen setzt der Server beim Ausliefern ein.
-`[DATUM]` ebenso. Was übrig bleibt, sind die Angaben über den **Menschen** vor dir.
+⚠️ `[FIRMA]` findest du meist schon ausgefüllt — den Namen setzt der Server beim Ausliefern ein. Was übrig bleibt, sind die Angaben über den **Menschen** vor dir.
 
 🔴 **Nur in der Werkbank — nirgends sonst.** Die oberste `CLAUDE.md` und alles in `kontext/` (in einer englischen Firma `context/`)
 gehören der **Firma**, nicht dem Menschen vor dir. Den Firmennamen setzt der Server beim
@@ -360,6 +359,11 @@ mitbestimmungspflichtig. Das entscheidet die Firma, nicht dieses Werkzeug.
 - „Was würdest du als Geschäftsführung als Nächstes automatisieren, gemessen an dem, was bisher
   funktioniert hat — und was davon lässt sich auf andere Abteilungen übertragen?"
 
+## Kursstand lesen (`kimal3 kurs`)
+Zeigt, wo der Mensch im Mini-Kurs steht: eine Zeile je Beat, `Als Nächstes:` mit dem nächsten Schritt und dahinter, wer
+ihn abhakt — „(du hakst ab)" oder „(setzt Claude)". Rückgabewert `2` heißt nicht angemeldet, `3` nicht erreichbar —
+dann **keinen Kurs aus dem Gedächtnis erzählen**. Der Slash-Befehl `/k3kurs` führt dadurch.
+
 ## Rückgabewerte
 `0` erledigt · `1` **Wiederholen hilft nicht — LIES DIE MELDUNG** · `2` Anmeldung fehlt ·
 `3` vorübergehende Störung, einmal wiederholen · `4` angemeldet, aber kein Pro-Zugang —

package/skill/commands/k3feierabend.md

@@ -24,10 +24,9 @@ Die Status-Datei (`WEITER-HIER.md` oder `ROADMAP.md`) ist der Zettel für den n
 taugt nur, solange man sie in einem Atemzug lesen kann. **Jeder Feierabend schreibt etwas dazu —
 also muss auch jeder Feierabend etwas wegräumen**, sonst wächst sie, bis niemand sie mehr liest.
 
-**Der Statuszettel heißt `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde.** Liegt einer da, nimm ihn. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. Muss einer neu entstehen: in `werkbank-…` heißt er `WEITER-HIER.md`, in `workbench-…` `NEXT-STEPS.md`, sonst `WEITER-HIER.md`.
+**Wo der Statuszettel liegt und wie er heißt.** Die Projektregel gilt **nur innerhalb eines Arbeitsplatzes**: Liegt ein Ordner `projekte/` oder `projects/` direkt in einem Ordner `werkbank-…` oder `workbench-…` (beide Schreibweisen kommen vor, auch gemischt) und steht die Sitzung in oder unter einem Ordner darin, ist dieser **Projektordner** der Ort. Name dort: unter `projekte/` `WEITER-HIER.md`, unter `projects/` `NEXT-STEPS.md`. **Überall sonst** (Starter-Paket, eigene Repos, auch ein Ordner `~/projects/mein-repo`) bleibt es wie bisher: Der Zettel liegt im Startordner, liegt einer da, nimm ihn; muss einer neu entstehen, heißt er `WEITER-HIER.md` — oder `NEXT-STEPS.md`, wenn der Ordner englisch angelegt wurde. Liegen beide da, frag, welcher gilt, und schreib in keinen, bevor die Antwort da ist. **Welcher gilt (im Arbeitsplatz):** Hat das Projekt einen, gilt der des Projekts. Sonst gilt ein vorhandener Werkbank-Zettel (`werkbank-…/WEITER-HIER.md` oder `workbench-…/NEXT-STEPS.md` aus der alten Vorlage) — den liest und pflegst du weiter. Gibt es keinen von beiden, entsteht er **im Projekt**. **Leg nie einen neuen Zettel in der Werkbank an.**
 
-Gibt es keine Status-Datei und die Arbeit wächst über eine Sitzung hinaus: eine vorschlagen,
-dann weiter mit Schritt 3.
+**Im Arbeitsplatz** schreibst du in den Zettel des Projekts, an dem heute gearbeitet wurde — fehlt er und liegt auch kein Werkbank-Zettel, leg ihn im Projekt an. **Nach einer reinen Profil-Sitzung** („Wer hier arbeitet“ ausgefüllt, noch kein Projekt) schreibst du **keinen** Zettel, sondern sagst, dass es beim nächsten Mal mit „Erste Sitzung“ in der Werkbank-`CLAUDE.md` weitergeht — dann weiter mit Schritt 3. **Außerhalb eines Arbeitsplatzes** gilt wie bisher: Gibt es keine Status-Datei und die Arbeit wächst über eine Sitzung hinaus, schlag eine vor, dann weiter mit Schritt 3.
 
 1. **Nachziehen:** „Wo wir stehen" und „nächster Schritt" auf das setzen, was heute passiert ist.
 2. **Wegräumen, was nicht mehr gilt.** Ins Archiv wandert: