kimal3 0.4.0-durchstich.1 → 0.4.0

package/dist/arbeitsplatz-suche.js

@@ -0,0 +1,176 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { gemerktFuer, fundAus } from "./arbeitsplatz-finden.js";
+import { werkbankSpracheAus } from "./werkbank-name.js";
+/**
+ * Das Suchen auf der Platte (Spec 2026-10-16-vorhandener-arbeitsplatz-lagen.md, Bauform 2 und 3).
+ * Was aus dem Gefundenen folgt, rechnet `arbeitsplatz-finden.ts` -- ohne Dateisystem.
+ *
+ * 🔬 **Die Messung vom 16.10.** (auf Dennis' Rechner): Bis Ebene 3 unter dem Benutzerordner sind es
+ * 110 Ordner, gelesen in 0,2 s -- die Suche ist billig, solange sie Verknuepfungen meidet. Im
+ * Benutzerordner liegen elf davon (`OneDrive`, `Eigene Dateien`, `Anwendungsdaten` ...); Node
+ * meldet sie als Verknuepfung (`isSymbolicLink`), und wer sie betritt, laeuft im Kreis oder in
+ * fremde Konten. "Versteckt" ist unter Windows ein Dateiattribut, das Node nicht liefert --
+ * deshalb zaehlt nur der Punkt am Namensanfang.
+ *
+ * ⚠️ Die Zeitgrenze macht aus einer langsamen Platte ein "nicht vollstaendig", nie einen Abbruch:
+ * wer sicher sein will, dass nichts uebersehen wurde, fragt `vollstaendig`.
+ */
+/** Ordner, in denen nie ein Arbeitsplatz liegt, aber viele Dateien (kleingeschrieben verglichen). */
+const AUSLASSEN = ["appdata", "library", "node_modules"]; // kein-anzeigetext: Ordnernamen
+/** Nur auf macOS und nur direkt im Benutzerordner: grosse Ablagen ohne Arbeitsplatz. */
+const AUSLASSEN_MAC_EBENE_1 = ["desktop", "downloads"]; // kein-anzeigetext: Ordnernamen
+const TIEFE_HEIM = 3;
+const TIEFE_DOKUMENTE = 2;
+function namenIn(pfad, nurDateien) {
+    try {
+        return readdirSync(pfad, { withFileTypes: true }).filter((e) => !nurDateien || !e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return []; // ein Ordner, in den ich nicht hineinsehe, zaehlt wie einer ohne unsere Dateien
+    }
+}
+function istDatei(pfad) {
+    try {
+        return statSync(pfad).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Was dieser Ordner ueber sich verraet: `kontext/`, `context/`, `CLAUDE.md` und die Werkbank-Unterordner. */
+export function kandidatAus(pfad) {
+    const eintraege = (() => {
+        try {
+            return readdirSync(pfad, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+    })();
+    return {
+        pfad,
+        kontextNamen: namenIn(join(pfad, "kontext"), true), // kein-anzeigetext: Ordnername
+        contextNamen: namenIn(join(pfad, "context"), true), // kein-anzeigetext: Ordnername
+        hatClaude: istDatei(join(pfad, "CLAUDE.md")), // kein-anzeigetext: Dateiname
+        werkbaenke: eintraege.filter((e) => e.isDirectory() && werkbankSpracheAus(e.name) !== null).map((e) => e.name),
+    };
+}
+/**
+ * Macht dieser Lesefehler die Suche unvollstaendig? Nur unter macOS, nur `EPERM`, nur auf `~/Documents`
+ * (V-6, V-8). Der Ordner wird ueber seinen Pfad erkannt -- er liegt auf Ebene 2 des Benutzerordners.
+ */
+export function macVerweigert(plattform, heim, ordner, code) {
+    return plattform === "darwin" && code === "EPERM" && ordner === join(heim, "Documents"); // kein-anzeigetext: Ordnername
+}
+export function sucheArbeitsplatz(a) {
+    const ende = Date.now() + a.fristMs;
+    const treffer = [];
+    let vollstaendig = true;
+    const pruefe = (pfad) => {
+        const k = kandidatAus(pfad);
+        // Nur mit echter Werkbank (Ruling 8): Ein Claude-Projekt des Kunden ist kein Treffer und wird weiter durchsucht.
+        if (fundAus([k], { mitWerkbank: true }).art === "keiner")
+            return false;
+        treffer.push(k);
+        return true;
+    };
+    // (a) Vom aktuellen Ordner aufwaerts -- billig und ohne Zeitgrenze. 200 wie in `findeArbeitsplatz`.
+    let oben = resolve(a.start);
+    for (let i = 0; i < 200; i++) {
+        pruefe(oben);
+        const eltern = dirname(oben);
+        if (eltern === oben)
+            break;
+        oben = eltern;
+    }
+    // (b) und (c): Die Tiefe zaehlt ab der Wurzel (Kinder = Ebene 1). Ein Treffer wird nicht weiter durchstiegen.
+    const durchsuche = (ordner, ebene, maxTiefe) => {
+        if (Date.now() >= ende) {
+            vollstaendig = false;
+            return;
+        }
+        let eintraege;
+        try {
+            eintraege = readdirSync(ordner, { withFileTypes: true });
+        }
+        catch (e) {
+            // Unter macOS fragt das System beim ersten Zugriff auf Dokumente nach; ein Nein ist ein `EPERM`
+            // genau dort -- das ist eine Luecke, die die Suche melden muss (V-6, V-8). Sonst: still weiter.
+            const code = e.code;
+            if (macVerweigert(a.plattform, a.heim, ordner, code))
+                vollstaendig = false;
+            return;
+        }
+        for (const eintrag of eintraege) {
+            // Verknuepfungen nie betreten: `isDirectory()` ist fuer sie falsch, die Zeile sagt es trotzdem laut.
+            if (eintrag.isSymbolicLink() || !eintrag.isDirectory())
+                continue;
+            const name = eintrag.name.toLowerCase();
+            if (name.startsWith(".") || AUSLASSEN.includes(name))
+                continue;
+            if (a.plattform === "darwin" && ordner === a.heim && AUSLASSEN_MAC_EBENE_1.includes(name))
+                continue;
+            const kind = join(ordner, eintrag.name);
+            if (pruefe(kind))
+                continue;
+            if (ebene < maxTiefe)
+                durchsuche(kind, ebene + 1, maxTiefe);
+        }
+    };
+    durchsuche(a.heim, 1, TIEFE_HEIM);
+    if (a.dokumente !== null)
+        durchsuche(a.dokumente, 1, TIEFE_DOKUMENTE);
+    return { fund: fundAus(treffer, { mitWerkbank: true }), vollstaendig };
+}
+/** Aus der Zeile `Personal  REG_EXPAND_SZ  %USERPROFILE%\OneDrive\Dokumente` den Pfad; `%NAME%` kommt aus `env`. */
+export function dokumenteAusRegistry(ausgabe, env) {
+    const wert = /Personal\s+REG_\w+\s+(.+?)\s*$/m.exec(ausgabe)?.[1]; // kein-anzeigetext: Registry-Wert
+    if (wert === undefined)
+        return null;
+    // Unbekannte Namen bleiben stehen -- dann gibt es den Ordner nicht, und die Suche ueberspringt ihn.
+    return wert.replace(/%([^%]+)%/g, (rest, name) => env[name] ?? rest);
+}
+/**
+ * Der Ordner "Dokumente" unter Windows -- bei OneDrive-Konten liegt er NICHT unter dem Benutzerordner.
+ * `KIMAL3_DOKUMENTE` hat Vorrang (leer = keiner), damit Messungen nie den echten Ordner lesen.
+ */
+export function windowsDokumente() {
+    const vorgabe = process.env.KIMAL3_DOKUMENTE; // kein-anzeigetext: Umgebungsvariable
+    if (vorgabe !== undefined)
+        return vorgabe === "" ? null : vorgabe;
+    if (platform() !== "win32")
+        return null;
+    const r = spawnSync("reg", // kein-anzeigetext: Windows-Programm
+    ["query", String.raw `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders`, "/v", "Personal"], // kein-anzeigetext: Registry
+    { encoding: "utf8", windowsHide: true });
+    if (r.status !== 0)
+        return null;
+    return dokumenteAusRegistry(r.stdout, process.env);
+}
+const ORDNER = join(homedir(), ".kimal3");
+const DATEI = join(ORDNER, "arbeitsplatz.json"); // kein-anzeigetext: Dateiname
+/** Der gemerkte Ort dieses Kontos; kaputte oder fremde Datei -> `null`. Wirft nie. */
+export function leseGemerktenOrt(email) {
+    try {
+        return gemerktFuer(JSON.parse(readFileSync(DATEI, "utf8")), email);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Den Ort merken. 🔴 Wirft nie: Ein nicht schreibbarer Merkzettel darf `einrichten` nicht scheitern
+ * lassen -- schlimmstenfalls wird einmal mehr gesucht. `mode: 0o700` wie in `gesehen.ts`.
+ */
+export function merkeOrt(o) {
+    try {
+        mkdirSync(ORDNER, { recursive: true, mode: 0o700 });
+        writeFileSync(DATEI, JSON.stringify(o, null, 2), "utf8");
+    }
+    catch {
+        /* nicht schreibbar -- der Befehl laeuft trotzdem durch */
+    }
+}

package/dist/befehle/einrichten.js

@@ -1,27 +1,49 @@
 import { spawnSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { leseAnmeldung } from "../anmeldung.js";
+import { alterKursCoachAblage, alterKursCoachPfad, coachDateiLiegt, legeCoachAb, meldeCoach } from "../coach-ablegen.js";
+import { istAlterKursCoach } from "../coach-rechnung.js";
+import { tragePluginsEin } from "../einstellungen-schreiben.js";
+import { logoAblegen } from "../logo-ablegen.js";
+import { pluginStand } from "../plugins-mischen.js";
 import { ruf } from "../api.js";
 import { FIRMEN_OPTIONEN, fehlendeDateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
-import { zerlege } from "../argumente.js";
+import { WERKBANK_VORDRUCKE, ersteSitzungOffen, fundAus, werkbankWahl } from "../arbeitsplatz-finden.js";
+import { kandidatAus, leseGemerktenOrt, merkeOrt, sucheArbeitsplatz, windowsDokumente } from "../arbeitsplatz-suche.js";
+import { alsWort, zerlege } from "../argumente.js";
+import { befehlIn, schalterIn } from "../befehlswoerter.js";
+import { ORDNER_NAMEN } from "../kontext-stand.js";
 import { sprache } from "../sprache.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { COACH_TEXTE } from "../texte/coach.js";
 import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
 import { anmeldenMitBrowser } from "./login.js";
-import { skillInstall } from "./skill-install.js";
+import { SKILL_TEXTE } from "../texte/skill.js";
+import { skillInstall, ursacheDes } from "./skill-install.js";
 /**
  * `kimal3 einrichten` / `kimal3 setup` -- der eine Befehl, den Claude beim Einstieg mit Leitung
  * aufruft (Spec 2026-10-11, Abschnitt 0, S-1, S-2, S-7). Er verbindet, was es schon gibt:
  * Anmeldung (mit Browser), die Vorlage von `/api/cli/arbeitsplatz`, `skill install`, und setzt
  * die Kurs-Haken.
  *
- * 🔑 Der Arbeitsplatz liegt IMMER im Benutzerordner (N-8), nie im Ordner, in dem Claude gerade
- * steht -- die Sitzung ohne Ordner ist ein Wegwerf-Ordner der App (M-L2).
- * 🔑 Nichts wird überschrieben: Ein zweiter Lauf ergänzt nur Fehlendes (`fehlendeDateienSchreiben`).
+ * 🔑 Einen VORHANDENEN Arbeitsplatz benutzt er, wie er ist (Spec 2026-10-16, Bauform 1): gemerkt in
+ * `~/.kimal3/arbeitsplatz.json`, sonst gesucht. Neu angelegt wird er im Benutzerordner (N-8), nie im
+ * Ordner, in dem Claude gerade steht -- die Sitzung ohne Ordner ist ein Wegwerf-Ordner der App (M-L2).
+ * 🔑 Nichts wird überschrieben: Nachgeliefert wird nur in einen eigenen, abgebrochenen Lauf (gemerkt
+ * `angefangen`, V-17). Ein fertiger Arbeitsplatz bekommt keine Datei zurück, die der Mensch gelöscht hat (V-16).
+ * 🔑 Jede Rückfrage (welcher Arbeitsplatz, welche Werkbank, fremder Ordner) endet mit `1` und fertigen
+ * Befehlen, BEVOR Plugins, Befehle oder Haken eingetragen werden -- Claude fragt den Menschen und startet
+ * den Befehl, der zu seiner Antwort passt.
  *
- * 📌 Durchstich-Fassung: ohne Coach, Logo und Suche nach einem vorhandenen Arbeitsplatz an
- * anderer Stelle (S-8) -- das kommt mit dem zweiten Bauplan, nach dem echten Lauf.
+ * 🔑 superpowers und das Logo trägt er seit Bauplan 2026-10-15 selbst in Claudes Einstellungen ein
+ * (`pluginsEinrichten`) -- Claude installiert dafür nichts mehr per Befehlszeile oder Menü.
+ *
+ * 🔑 Den Coach legt er in Claudes Regel-Ordner (`~/.claude/rules/kimal3-coach.md`, Spec 2026-10-16, zweiter Teil von
+ * S-8) -- vorher fragt er den Server einmal nach dem Kursstand: Das frischt die Kontosprache auf und prüft die
+ * Anmeldung, damit Plugins, Befehle und Coach in der richtigen Sprache entstehen (Bauform 5). `~/.claude/CLAUDE.md`
+ * liest er nur: Steht dort der Coach aus dem alten Mini-Kurs, sagt eine Zeile es, und Claude fragt den Menschen (S-14).
  */
 export async function einrichten(argv) {
     const s = sprache();
@@ -29,25 +51,227 @@ export async function einrichten(argv) {
         console.log(EINRICHTEN_TEXTE[s].help);
         return 0;
     }
-    const zerlegt = zerlege(argv, FIRMEN_OPTIONEN, s);
+    const zerlegt = zerlege(argv, [...FIRMEN_OPTIONEN, "arbeitsplatz", "werkbank"], s);
     if (!zerlegt.ok) {
         console.error(`${zerlegt.meldung}\n${EINRICHTEN_TEXTE[s].help}`);
         return 1;
     }
-    const wunsch = { firma: zerlegt.werte.optionen.firma, firmaId: zerlegt.werte.optionen["firma-id"] };
+    const angaben = zerlegt.werte.optionen;
+    const wunsch = { firma: angaben.firma, firmaId: angaben["firma-id"] };
+    // Ein mitkopierter Platzhalter aus einer Rückfrage („<pfad>“) ist kein Ordner -- sonst entstünde ein Ordner
+    // dieses Namens (macOS) oder ein Schreibfehler mitten im Lauf (Windows). Vor der Anmeldung: nichts geschrieben.
+    if (angaben.arbeitsplatz !== undefined && /[<>]/.test(angaben.arbeitsplatz))
+        return frage([EINRICHTEN_TEXTE[s].placeholderPath(angaben.arbeitsplatz)]);
     console.log(EINRICHTEN_TEXTE[s].start);
     const gespeichert = leseAnmeldung();
     if (gespeichert)
         console.log(ALLGEMEIN_TEXTE[s].signedInAs(gespeichert.email));
     else {
-        const angemeldet = await anmeldenMitBrowser();
+        const angemeldet = await anmeldenEinmal();
         if (angemeldet !== 0)
             return angemeldet;
     }
+    // Gleich nach der Anmeldung, VOR der ersten Zeile über den Arbeitsplatz: Erst danach kennt `sprache()` die Kontosprache,
+    // und schon „Dein Arbeitsplatz liegt schon unter …“ soll in ihr stehen (Gesamt-Durchsicht, Fund 7). Liest nur -- eine
+    // Rückfrage danach hat weiter nichts geschrieben (eine nötige Neuanmeldung ausgenommen, wie oben).
+    await kursstandVorab();
+    // Die Adresse entscheidet, welcher gemerkte Ort und welche Werkbank diesem Konto gehören (V-12b).
+    const email = leseAnmeldung()?.email ?? "";
+    const gemerkt = leseGemerktenOrt(email);
+    const ziel = zielBestimmen(angaben.arbeitsplatz, gemerkt);
+    if (ziel.art === "rueckfrage")
+        return frage(ziel.zeilen);
+    let ort;
+    if (ziel.art === "vorhanden") {
+        // 🔑 Kein Abruf der Vorlage (V-19): Ein gefundener Arbeitsplatz braucht sie nicht, also auch keine Firmenfrage.
+        console.log(EINRICHTEN_TEXTE[sprache()].foundWorkplace(ziel.pfad));
+        const werkbank = werkbankBestimmen(ziel.pfad, email, angaben.werkbank, gemerkt);
+        if (typeof werkbank !== "string")
+            return frage(werkbank);
+        ort = { pfad: ziel.pfad, werkbank };
+    }
+    else {
+        const neu = await neuAnlegen(ziel.pfad, wunsch, email, gespeichert !== null);
+        if (typeof neu === "number")
+            return neu;
+        ort = neu;
+    }
+    // 🌐 Die Antwort der Vorlage kann die Kontosprache umgestellt haben -- ab hier in der neuen.
+    const t = EINRICHTEN_TEXTE[sprache()];
+    console.log(t.workplaceLine(ort.pfad));
+    console.log(t.workbenchLine(ort.werkbank));
+    console.log(t.nextLine(ersteSitzungOffen(liesOderNull(join(ort.pfad, ort.werkbank, "CLAUDE.md"))))); // kein-anzeigetext: Dateiname
+    merkeOrt({ email, pfad: ort.pfad, werkbank: ort.werkbank, zustand: "fertig" });
+    // Plugins VOR der Wache: So hält ihre Sicherungskopie Sabines unveränderte Einstellungen (QA-Fund 9).
+    const git = gitAntwortet();
+    pluginsEinrichten(git);
+    // Der Coach VOR `skillInstall()`: Das frischt einen vorhandenen Coach auf und findet ihn so schon aktuell -- still.
+    meldeCoach(legeCoachAb(sprache(), true), sprache());
+    const befehle = await skillInstall();
+    const alt = alterKursCoachPfad();
+    if (istAlterKursCoach(liesOderNull(alt) ?? ""))
+        console.log(COACH_TEXTE[sprache()].oldCourseCoach(alt, alterKursCoachAblage()));
+    // `beat2-coach` heißt „Coach und /k3-Befehle sind dauerhaft eingerichtet“ (E-9): Unter dem Namen liegt eine DATEI
+    // (auch eine fremde, E-5 -- ein Ordner ist kein Coach) und die Befehle stehen. Logo und Plugins zählen nicht.
+    const coachSteht = befehle === 0 && coachDateiLiegt();
+    const haken = git ? ["beat2-werkzeuge", "beat2-kimal3", "beat2-arbeitsplatz", "beat2-coach"] : ["beat2-kimal3", "beat2-arbeitsplatz", "beat2-coach"];
+    await kursAbhaken(haken.filter((id) => id !== "beat2-coach" || coachSteht));
+    if (befehle !== 0)
+        return befehle;
+    console.log(EINRICHTEN_TEXTE[sprache()].done);
+    return 0;
+}
+/**
+ * Fragt den Kursstand, bevor etwas in einer Sprache geschrieben wird (Spec 2026-10-16, Bauform 5): Jede Antwort trägt
+ * die Kontosprache, und `ruf` übernimmt sie -- so ist die Einrichtung in der Sprache, die Sabine gerade in der App
+ * gewählt hat (C-6). Den Stand selbst braucht `einrichten` nicht.
+ * 🔑 `401` -> neu anmelden (`anmeldenEinmal`) und noch einmal fragen. Scheitert das, läuft die Einrichtung trotzdem
+ * weiter (Durchsicht Aufgabe 5, Fund 5): Plugins, Coach und Befehle brauchen kein Netz; nur die Haken fehlen dann, und
+ * `kursAbhaken` sagt es in einer Zeile. Ein zweites `401` nach der Anmeldung bleibt ohne weitere Anmeldung.
+ * 🔑 Jeder andere Ausgang (auch `404` einer App ohne diese Route, Netzfehler) zählt nicht: weiter, ohne Zeile (Spec 6).
+ */
+async function kursstandVorab() {
+    const stand = async () => {
+        try {
+            return (await ruf("/api/cli/kurs", { methode: "GET", mitAusweis: true })).status; // kein-anzeigetext: Pfad der Schnittstelle
+        }
+        catch {
+            return 0;
+        }
+    };
+    if ((await stand()) === 401 && (await anmeldenEinmal()) === 0)
+        await stand();
+}
+/**
+ * Höchstens EINE Anmeldung mit Browser je Lauf (Durchsicht Aufgabe 5, Fund 5). Jede davon wartet bis zu zehn Minuten
+ * auf Sabines Bestätigung; scheiterte die erste (abgelaufen, kein Netz), soll ein zweiter Versuch sie nicht noch einmal
+ * zehn Minuten warten lassen. Jeder weitere Aufruf antwortet `2` („nicht angemeldet“), ohne Browser.
+ */
+let anmeldungVersucht = false;
+async function anmeldenEinmal() {
+    if (anmeldungVersucht)
+        return 2;
+    anmeldungVersucht = true;
+    return anmeldenMitBrowser();
+}
+/**
+ * Die Reihenfolge aus Spec 2026-10-16, Bauform 2 und 3: die Angabe des Menschen, dann der gemerkte Ort
+ * dieses Kontos, dann die Suche. Liest nur, schreibt nichts und fragt kein Netz.
+ */
+function zielBestimmen(angabe, gemerkt) {
+    const t = EINRICHTEN_TEXTE[sprache()];
+    if (angabe !== undefined) {
+        const pfad = resolve(angabe);
+        // Auch ein Ordner IN einem Arbeitsplatz meint diesen -- nie einen zweiten darin anlegen. Ohne Werkbank zählt nur
+        // der genannte Ordner selbst (V-12c); ein Ordner DARÜBER ist gesucht, nicht genannt, und braucht wie bei der Suche
+        // eine Werkbank (Ruling 8) -- sonst wäre `--arbeitsplatz ~/Projects/app/KI-Arbeitsplatz` das Repo `app`.
+        for (let oben = pfad;; oben = dirname(oben)) {
+            if (istArbeitsplatz(oben, oben !== pfad))
+                return { art: "vorhanden", pfad: oben };
+            if (dirname(oben) === oben)
+                break;
+        }
+        if (istFremd(pfad))
+            return { art: "rueckfrage", zeilen: [t.foreignFolder(pfad), t.otherPlace, platzBefehl(t.pathPlaceholder)] };
+        return { art: "neu", pfad };
+    }
+    // Ein eigener, abgebrochener Lauf wird fertig geschrieben (V-17) -- der einzige Fall, in dem nachgeliefert wird.
+    if (gemerkt?.zustand === "angefangen" && existsSync(gemerkt.pfad))
+        return { art: "neu", pfad: gemerkt.pfad };
+    if (gemerkt?.zustand === "fertig" && istArbeitsplatz(gemerkt.pfad, false))
+        return { art: "vorhanden", pfad: gemerkt.pfad };
+    const { fund, vollstaendig } = sucheArbeitsplatz({
+        start: process.cwd(),
+        heim: homedir(),
+        dokumente: windowsDokumente(),
+        plattform: platform(),
+        fristMs: 3000,
+    });
+    if (fund.art === "einer")
+        return { art: "vorhanden", pfad: fund.pfad };
+    if (fund.art === "mehrere")
+        return { art: "rueckfrage", zeilen: [t.severalFound, ...fund.pfade.map((p) => platzBefehl(p))] };
+    // 🔑 Es gab einen, oder die Suche kam nicht überall hin: dann NICHT still einen zweiten anlegen (V-7, V-8).
+    const woIstEr = [t.existingWorkplace, platzBefehl(t.pathPlaceholder), t.newWorkplace, platzBefehl(join(homedir(), ORDNER_NAMEN[sprache()].wurzel))];
+    if (gemerkt !== null)
+        return { art: "rueckfrage", zeilen: [t.rememberedGone(gemerkt.pfad), ...woIstEr] };
+    if (!vollstaendig)
+        return { art: "rueckfrage", zeilen: [t.searchIncomplete, ...woIstEr] };
+    return { art: "neu", pfad: null };
+}
+/**
+ * Welche Werkbank im gefundenen Arbeitsplatz diesem Konto gehört (Bauform 5) -- ihr Name, oder die Zeilen
+ * der Rückfrage. 🔑 Die Rückfrage-Befehle nennen den Arbeitsplatz mit: Kam er aus `--arbeitsplatz` (nach
+ * „mehrere gefunden“), fände ein Lauf nur mit `--werkbank` wieder mehrere -- eine Frage im Kreis.
+ */
+function werkbankBestimmen(pfad, email, angabe, gemerkt) {
+    const t = EINRICHTEN_TEXTE[sprache()];
+    const echte = kandidatAus(pfad).werkbaenke.filter((n) => !WERKBANK_VORDRUCKE.includes(n));
+    const frueher = gemerkt !== null && resolve(gemerkt.pfad) === resolve(pfad) ? gemerkt.werkbank : null;
+    const wahl = werkbankWahl(echte, email, angabe ?? frueher);
+    const mit = (name) => platzBefehl(pfad, name);
+    const eigene = [t.ownWorkbench, ...v12c(pfad)];
+    // Eine genannte Werkbank, die es hier nicht gibt, wird nie still durch eine andere ersetzt (Bauform 6).
+    const passt = wahl.art === "genau" && (angabe === undefined || wahl.name === angabe);
+    if (passt)
+        return wahl.name;
+    if (wahl.art === "keine")
+        return [t.noWorkbenchInWorkplace(pfad), ...v12c(pfad)];
+    if (wahl.art === "bestaetigen" && angabe === undefined) {
+        const andere = echte.filter((n) => n !== wahl.name);
+        return [t.confirmWorkbench(wahl.name), t.yes, mit(wahl.name), ...(andere.length > 0 ? [t.noOther, ...andere.map((n) => mit(n))] : []), ...eigene];
+    }
+    return [t.noMatchingWorkbench(pfad), t.oneOfThese, ...echte.map((n) => mit(n)), ...eigene];
+}
+/** Der Weg aus V-12c: `werkbank neu` arbeitet im aktuellen Ordner, erst der zweite Lauf trägt Plugins und Haken ein. */
+function v12c(pfad) {
+    const t = EINRICHTEN_TEXTE[sprache()];
+    return [t.cdLine(alsWort(pfad, true)), t.commandLine(befehlIn("werkbank neu", sprache())), platzBefehl(pfad)]; // kein-anzeigetext: Befehlsschluessel
+}
+/** `kimal3 einrichten --arbeitsplatz "…" [--werkbank …]` in der Sprache dieses Laufs, zum Kopieren. */
+function platzBefehl(pfad, werkbank) {
+    const s = sprache();
+    const teile = [befehlIn("einrichten", s), `--${schalterIn("arbeitsplatz", s)}`, alsWort(pfad, true)]; // kein-anzeigetext: Befehlsschluessel
+    if (werkbank !== undefined)
+        teile.push(`--${schalterIn("werkbank", s)}`, alsWort(werkbank)); // kein-anzeigetext: Befehlsschluessel
+    return EINRICHTEN_TEXTE[s].commandLine(teile.join(" "));
+}
+function frage(zeilen) {
+    console.log(zeilen.join("\n"));
+    return 1;
+}
+/** `mitWerkbank`: wie bei der Suche nur mit echter Werkbank (Ruling 8) -- für Ordner, die der Mensch nicht selbst genannt hat. */
+const istArbeitsplatz = (pfad, mitWerkbank) => fundAus([kandidatAus(pfad)], { mitWerkbank }).art === "einer";
+/**
+ * Ein Ordner, der da ist, kein Arbeitsplatz ist und etwas enthält -- dort legt `einrichten` nichts ab (V-11).
+ * Ohne Werkbank-Pflicht: Ein eigener Arbeitsplatz mit gelöschter Werkbank ist nicht fremd, `einrichten` ergänzt ihn.
+ */
+function istFremd(pfad) {
+    try {
+        return statSync(pfad).isDirectory() && readdirSync(pfad).length > 0 && !istArbeitsplatz(pfad, false);
+    }
+    catch {
+        return false;
+    }
+}
+function liesOderNull(pfad) {
+    try {
+        return readFileSync(pfad, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Einen neuen Arbeitsplatz anlegen oder einen eigenen, abgebrochenen fertig schreiben -- wie bisher über
+ * die Vorlage. 🔑 Gemerkt wird `angefangen` VOR der ersten Datei: Bricht der Lauf ab, sähe der halbe Ordner
+ * sonst beim nächsten Mal wie ein fremder aus (V-17).
+ */
+async function neuAnlegen(pfad, wunsch, email, gespeichert) {
     let holen = await vorlageHolen("einrichten", "", wunsch, null);
     // Die gespeicherte Anmeldung galt nicht mehr (401 -> 2): einmal neu anmelden, dann noch einmal holen.
     if (!holen.ok && holen.wert === 2 && gespeichert) {
-        const angemeldet = await anmeldenMitBrowser();
+        const angemeldet = await anmeldenEinmal();
         if (angemeldet !== 0)
             return angemeldet;
         holen = await vorlageHolen("einrichten", "", wunsch, null);
@@ -57,7 +281,7 @@ export async function einrichten(argv) {
     // 🌐 Die Antwort kann die Kontosprache umgestellt haben -- ab hier in der neuen.
     const t = EINRICHTEN_TEXTE[sprache()];
     const { wurzel, dateien } = holen.daten;
-    if (istUnsichererOrdnername(wurzel)) {
+    if (pfad === null && istUnsichererOrdnername(wurzel)) {
         console.error(t.unsafeFolder(wurzel));
         return 3;
     }
@@ -66,35 +290,90 @@ export async function einrichten(argv) {
         console.error(t.noWorkbank);
         return 3;
     }
-    const ziel = join(homedir(), wurzel);
+    const ziel = pfad ?? join(homedir(), wurzel);
+    if (pfad === null && istFremd(ziel))
+        return frage([t.foreignFolder(ziel), t.otherPlace, platzBefehl(t.pathPlaceholder)]);
+    merkeOrt({ email, pfad: ziel, werkbank, zustand: "angefangen" });
     const geschrieben = fehlendeDateienSchreiben(dateien, ziel);
     if (!geschrieben.ok)
         return geschrieben.wert;
     console.log(t.filesWritten(geschrieben.neu, geschrieben.schonDa));
-    console.log(t.workplaceLine(ziel));
-    console.log(t.workbenchLine(werkbank));
-    const befehle = await skillInstall();
-    await kursAbhaken(gitAntwortet() ? ["beat2-werkzeuge", "beat2-kimal3", "beat2-arbeitsplatz"] : ["beat2-kimal3", "beat2-arbeitsplatz"]);
-    if (befehle !== 0)
-        return befehle;
-    console.log(t.done);
-    return 0;
+    return { pfad: ziel, werkbank };
 }
-/** Git ist da, wenn `git --version` antwortet -- Node.js ist es, sonst liefe dieses Programm nicht. */
+/**
+ * superpowers und das Logo: Ordner ablegen, in Claudes Einstellungen eintragen, eine Zeile `Plugins:`.
+ * 🔑 Scheitert etwas, bricht die Einrichtung NICHT ab (Lage P-3): Arbeitsplatz, Befehle und Wache
+ * stehen ja -- die Zeile sagt, was fehlt, und Claude nimmt dann den Menü-Weg für superpowers.
+ * 🔑 Ohne Git trägt er superpowers NICHT ein (Durchsicht 3, Fund 5): Claude Code klont Anthropics Katalog mit Git und
+ * scheiterte sonst bei jedem Start. Eine Zeile sagt es; der nächste Lauf mit Git holt es nach (Mac-Weg ohne Adminrechte).
+ */
+function pluginsEinrichten(git) {
+    const s = sprache();
+    const t = EINRICHTEN_TEXTE[s];
+    const ablage = logoAblegen(s);
+    // Ohne Logo-Ordner kommt superpowers trotzdem (Durchsicht 2, Fund 1): eine Zeile zum Logo, dann weiter.
+    if (!ablage.ok)
+        console.log(t.logoNotWritten(ablage.detail));
+    if (ablage.ok && ablage.alterStand)
+        console.log(t.logoOldVersion);
+    // Schrägstriche vorwärts: So steht der Pfad in Claudes Einstellungen auf jedem System gleich (P-13).
+    const eintrag = tragePluginsEin(ablage.ok ? ablage.ordner.replace(/\\/g, "/") : null, git);
+    if (eintrag.art === "abgelehnt") {
+        console.log(t.pluginsNotWritten(eintrag.grund === "kein-gueltiges-json" ? t.settingsInvalid : t.settingsForeign));
+        return;
+    }
+    if (eintrag.art === "gescheitert") {
+        // Den Schritt in Sabines Sprache, nie das interne Wort (Durchsicht-Fund 3) -- derselbe Satz wie bei der Wache.
+        console.log(t.pluginsNotWritten(t.settingsFailed(ursacheDes(eintrag, SKILL_TEXTE[s]))));
+        return;
+    }
+    const stand = pluginStand(eintrag.inhalt);
+    const namen = { superpowers: "superpowers", logo: t.logoName };
+    const mit = (wert) => ["superpowers", "logo"].filter((p) => stand[p] === wert).map((p) => namen[p]);
+    console.log(t.pluginsLine(mit("an"), mit("aus"), eintrag.art === "eingetragen"));
+    // Auch wenn superpowers schon von früher drinsteht: ohne Git lädt es nicht (Durchsicht 4, Fund 3).
+    if (!git && stand.superpowers !== "aus")
+        console.log(t.superpowersNeedsGit);
+}
+/**
+ * Ist Git da? Node.js ist es, sonst liefe dieses Programm nicht.
+ * 🔴 AUF DEM MAC NIE BLIND `git --version` (Durchsicht 3, Fund 1): Ohne Entwickler-Tools ist `/usr/bin/git` nur ein
+ * Platzhalter, der das Installationsfenster öffnet -- auf einem Standardkonto samt Frage nach einem Admin-Passwort,
+ * mitten in der Einrichtung. Dort zählt Git nur, wenn die Entwickler-Tools da sind (`xcode-select -p`) oder ein Git
+ * außerhalb von `/usr/bin` im Pfad liegt (Homebrew) -- und dann wird genau DAS gefragt, nicht das erste im Pfad.
+ * Dieselbe Regel steht in der Anleitung, Schritt 1.
+ */
 function gitAntwortet() {
-    return spawnSync("git", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+    const antwortet = (befehl) => spawnSync(befehl, ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+    if (platform() !== "darwin")
+        return antwortet("git");
+    if (spawnSync("xcode-select", ["-p"], { stdio: "ignore" }).status === 0)
+        return antwortet("git");
+    // Nur absolute Ordner: Ein leerer Eintrag oder `.` ergäbe den bloßen Namen `git`, und der fände wieder den
+    // Platzhalter in `/usr/bin` (Durchsicht 4, Fund 2).
+    const eigenes = (process.env.PATH ?? "").split(":").filter((ordner) => ordner.startsWith("/") && ordner !== "/usr/bin")
+        .map((ordner) => join(ordner, "git")).find((datei) => existsSync(datei));
+    return eigenes !== undefined && antwortet(eigenes);
 }
 /**
  * Die Haken sind eine Zugabe: Scheitern sie, ist der Arbeitsplatz trotzdem da -- eine Zeile,
  * kein Abbruch, und der nächste Lauf setzt sie (die Route ist dafür wiederholbar).
+ * 🔑 `401` -> einmal neu anmelden (S-8): Ohne diesen Zweig bliebe eine abgelaufene Anmeldung für immer stehen, und
+ * „der nächste Lauf holt das nach“ wäre falsch. Hat dieser Lauf schon eine Anmeldung versucht (beim Kursstand vorab),
+ * öffnet `anmeldenEinmal` keine zweite -- die Zeile sagt dann, dass die Haken fehlen.
  */
 async function kursAbhaken(schritte) {
+    const haken = async () => {
+        try {
+            return (await ruf("/api/cli/kurs", { koerper: { schritte }, mitAusweis: true })).status; // kein-anzeigetext: Pfad der Schnittstelle
+        }
+        catch {
+            return 0;
+        }
+    };
+    let status = await haken();
+    if (status === 401 && (await anmeldenEinmal()) === 0)
+        status = await haken();
     const t = EINRICHTEN_TEXTE[sprache()];
-    try {
-        const a = await ruf("/api/cli/kurs", { koerper: { schritte }, mitAusweis: true }); // kein-anzeigetext: Pfad der Schnittstelle
-        console.log(a.status === 200 ? t.courseMarked : t.courseNotMarked);
-    }
-    catch {
-        console.log(t.courseNotMarked);
-    }
+    console.log(status === 200 ? t.courseMarked : t.courseNotMarked);
 }

package/dist/befehle/kurs.js

@@ -0,0 +1,77 @@
+import { feld, ruf } from "../api.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { KURS_TEXTE } from "../texte/kurs.js";
+import { schlussFehler } from "../fehler.js";
+import { BASIS_URL } from "../anmeldung.js";
+const istZahl = (w) => typeof w === "number" && Number.isFinite(w);
+function schrittAus(w) {
+    if (!w || typeof w !== "object")
+        return null;
+    const s = w;
+    if (typeof s.id !== "string" || !istZahl(s.beat) || typeof s.text !== "string" || (s.wer !== "claude" && s.wer !== "mensch"))
+        return null;
+    return { id: s.id, beat: s.beat, text: s.text, wer: s.wer };
+}
+/** Die Antwort von `GET /api/cli/kurs` -- `null`, wenn sie nicht die erwartete Form hat (z. B. ein WLAN-Anmeldeportal mit `200`). */
+function standAus(koerper) {
+    if (!koerper || typeof koerper !== "object")
+        return null;
+    const k = koerper;
+    if (!Array.isArray(k.beats) || !Array.isArray(k.offen) || typeof k.abgeschlossen !== "boolean")
+        return null;
+    const beats = k.beats.map((b) => {
+        const r = b && typeof b === "object" ? b : {};
+        return istZahl(r.nummer) && istZahl(r.erledigt) && istZahl(r.gesamt) && typeof r.fertig === "boolean"
+            ? { nummer: r.nummer, erledigt: r.erledigt, gesamt: r.gesamt, fertig: r.fertig }
+            : null;
+    });
+    const offen = k.offen.map(schrittAus);
+    const naechster = k.naechster === null ? null : schrittAus(k.naechster);
+    if (beats.includes(null) || offen.includes(null) || (k.naechster !== null && !naechster))
+        return null;
+    return { beats: beats, offen: offen, naechster, abgeschlossen: k.abgeschlossen };
+}
+/** Reine Rechnung: die Zeilen, die der Mensch (und Claude) zu sehen bekommen. */
+export function kursZeilen(stand, s, basisUrl) {
+    const t = KURS_TEXTE[s];
+    const browser = t.imBrowser(basisUrl);
+    if (stand.abgeschlossen)
+        return [t.alleErledigt(stand.beats.reduce((n, b) => n + b.gesamt, 0)), browser];
+    const beats = stand.beats.map((b) => (b.fertig ? t.beatFertig(b.nummer) : t.beatTeil(b.nummer, b.erledigt, b.gesamt)));
+    const zeilen = [t.uebersicht(beats.join(" · "))];
+    if (stand.naechster)
+        zeilen.push(t.naechster(stand.naechster.text, stand.naechster.wer === "claude"));
+    // Alles Offene ausser dem, was schon als „Als Nächstes“ dasteht -- über die Kennung: Zwei offene Schritte
+    // eines Beats können denselben Text tragen, und nur der eine ist der nächste.
+    const rest = stand.offen.filter((o) => o.id !== stand.naechster?.id);
+    if (rest.length > 0) {
+        zeilen.push(t.nochOffen);
+        rest.forEach((o) => zeilen.push(t.offenZeile(o.beat, o.text, o.wer === "claude")));
+    }
+    zeilen.push(browser);
+    return zeilen;
+}
+/** Wo der Mensch im Mini-Kurs steht -- die Grundlage von `/k3kurs`. */
+export async function kurs() {
+    const antwort = await ruf("/api/cli/kurs", { methode: "GET", mitAusweis: true }); // kein-anzeigetext: HTTP-Methode
+    // 🌐 Die Antwort kann die Kontosprache umgestellt haben: Was ab hier gedruckt wird, in der neuen.
+    const s = sprache();
+    if (antwort.status === 200) {
+        const stand = standAus(antwort.koerper);
+        if (!stand) {
+            console.error(ALLGEMEIN_TEXTE[s].unreadableAnswer);
+            return 3;
+        }
+        kursZeilen(stand, s, BASIS_URL).forEach((z) => console.log(z));
+        return 0;
+    }
+    const meldung = feld(antwort.koerper, "meldung") ?? ALLGEMEIN_TEXTE[s].genericFailure;
+    if (antwort.status === 401) {
+        console.error(`${meldung}${ALLGEMEIN_TEXTE[s].pleaseSignIn}`);
+        return 2;
+    }
+    const schluss = schlussFehler(antwort.status, meldung, s);
+    console.error(schluss.text);
+    return schluss.wert;
+}