kimal3 0.4.0-durchstich.3 → 0.4.0

package/dist/arbeitsplatz-finden.js

@@ -0,0 +1,115 @@
+/**
+ * Die reinen Rechnungen zum Finden eines vorhandenen Arbeitsplatzes (Spec
+ * 2026-10-16-vorhandener-arbeitsplatz-lagen.md) -- ohne Dateisystem. Das Suchen auf der
+ * Platte kommt in eine eigene Datei; hier steht nur, was aus dem Gefundenen folgt.
+ *
+ * 🔑 **Warum die Werkbank am ORDNERNAMEN erkannt wird** (Spec, Bauform 5): Dennis' eigene
+ * Werkbank hat keine `CLAUDE.md`. Eine Erkennung "Unterordner mit eigener `CLAUDE.md`"
+ * (wie `werkbankAusDateien`) fande bei ihm gar keine -- ausgerechnet beim ersten Menschen,
+ * der den Befehl benutzt.
+ *
+ * 🔑 **Warum `bestaetigen` statt still zu waehlen:** Ein Name, der nur ueber seinen Anfang
+ * passt (`werkbank-sabine` zu sabine.mueller@...), passt genauso zu Sabine Schmidt. Zwei
+ * Sabines in einer Firma waren der Befund 10 der Pruefrunde 2. Deshalb fragt `einrichten`
+ * einmal und merkt sich die Antwort zum Konto; nur der volle Name gilt ohne Frage.
+ *
+ * ⚠️ Die Vordrucke aus der Vorlage (`werkbank-dein-name`) gehoeren niemandem: Sie sind nie
+ * waehlbar und machen aus einem Ordner keinen Arbeitsplatz (V-15, Repo-Klon in Suchtiefe).
+ */
+import { arbeitsplatzAus } from "./kontext-stand.js";
+import { WERKBANK_PRAEFIXE, werkbankOrdnerAus, werkbankSpracheAus } from "./werkbank-name.js";
+/** Die Werkbank-Namen, die die Vorlage selbst mitbringt. */
+export const WERKBANK_VORDRUCKE = ["werkbank-dein-name", "workbench-your-name"];
+const istVordruck = (name) => WERKBANK_VORDRUCKE.includes(name);
+/** Eine Schreibweise fuer den Vergleich: Windows unterscheidet Gross/klein nicht, `\` und `/` sind dasselbe. */
+const pfadSchluessel = (pfad) => pfad.replaceAll("\\", "/").toLowerCase();
+/**
+ * Welche der Kandidaten Arbeitsplätze sind.
+ *
+ * 🔴 **`mitWerkbank` ist Pflicht, kein optionaler Schalter** (Ruling 8): Die Regel von `kontext runter` allein
+ * (eine `CLAUDE.md` und `context/company.md`) ist die übliche Form JEDES Claude-Projekts. Ohne Werkbank hielte die
+ * SUCHE das eigene Repo des Kunden für einen Arbeitsplatz, und V-12c ließe Claude dort eine Werkbank anlegen.
+ * Deshalb zählt beim Suchen (`true`) nur ein Ordner mit mindestens einer echten Werkbank. Hat der Mensch den
+ * Ordner dagegen SELBST genannt (`--arbeitsplatz`, der gemerkte Ort) oder geht es darum, ob ein Ordner fremd ist
+ * (`false`), zählt auch einer ohne Werkbank -- sonst wäre V-12c unerreichbar, und ein eigener Arbeitsplatz mit
+ * gelöschter Werkbank hieße „fremd“.
+ */
+export function fundAus(kandidaten, o) {
+    const pfade = [];
+    const gesehen = new Set();
+    for (const k of kandidaten) {
+        if (arbeitsplatzAus([k]).art === "keiner")
+            continue;
+        // Nur Vordrucke = die Vorlage aus dem Repo (V-15) -- in keinem Fall ein Arbeitsplatz.
+        const echte = k.werkbaenke.filter((n) => !istVordruck(n));
+        if (k.werkbaenke.length > 0 && echte.length === 0)
+            continue;
+        if (o.mitWerkbank && echte.length === 0)
+            continue;
+        const schluessel = pfadSchluessel(k.pfad);
+        if (gesehen.has(schluessel))
+            continue;
+        gesehen.add(schluessel);
+        pfade.push(k.pfad);
+    }
+    if (pfade.length === 0)
+        return { art: "keiner" };
+    if (pfade.length === 1)
+        return { art: "einer", pfad: pfade[0] };
+    return { art: "mehrere", pfade };
+}
+/** Der Name ohne sein Praefix (`werkbank-sabine` -> `sabine`); `null`, wenn es keine Werkbank ist. */
+function kernAus(name) {
+    const sprache = werkbankSpracheAus(name);
+    return sprache === null ? null : name.slice(WERKBANK_PRAEFIXE[sprache].length);
+}
+export function werkbankWahl(namen, email, gewaehlt) {
+    const echte = namen.filter((n) => !istVordruck(n) && kernAus(n) !== null);
+    if (echte.length === 0)
+        return { art: "keine" };
+    if (gewaehlt !== null && echte.includes(gewaehlt))
+        return { art: "genau", name: gewaehlt };
+    // Der erwartete Kern ist in beiden Sprachen derselbe; das Praefix ist beim Vergleich egal (V-13).
+    const erwartet = werkbankOrdnerAus(email, "de");
+    const erwarteterKern = erwartet === null ? null : kernAus(erwartet);
+    if (erwarteterKern === null)
+        return { art: "keine-passende", namen: echte };
+    const voll = echte.find((n) => kernAus(n) === erwarteterKern);
+    if (voll !== undefined)
+        return { art: "genau", name: voll };
+    const anfang = echte.filter((n) => erwarteterKern.startsWith(`${kernAus(n)}-`));
+    if (anfang.length === 1)
+        return { art: "bestaetigen", name: anfang[0] };
+    if (anfang.length > 1)
+        return { art: "mehrere", namen: anfang };
+    return { art: "keine-passende", namen: echte };
+}
+/**
+ * Steht die Anleitung fuer die erste Sitzung noch in der Werkbank-`CLAUDE.md`? Sie geht erst,
+ * wenn der Mensch sie ausgefuellt hat (Marke weg, kein ✏️ mehr). Ohne Datei: nein.
+ *
+ * Eine Zitatzeile (erstes Zeichen `>`) zaehlt nicht: Die alte Vorlage behaelt dort fuer immer den
+ * Hinweis „✏️ Muss nicht von Hand ausgefuellt werden …“, auch bei ausgefuelltem Profil -- sonst
+ * schickte `kimal3 einrichten` jeden Bestandskunden wieder in „Lass uns einrichten“.
+ */
+export function ersteSitzungOffen(werkbankClaudeMd) {
+    if (werkbankClaudeMd === null)
+        return false;
+    const ohneZitate = werkbankClaudeMd.split(/\r?\n/).filter((z) => !z.trimStart().startsWith(">")).join("\n");
+    return ohneZitate.includes("<!-- kimal3:erste-sitzung -->") || ohneZitate.includes("✏️"); // kein-anzeigetext: Marke in der Datei, kein Satz fuer Menschen
+}
+/** Der gemerkte Ort -- nur wenn die Datei die richtige Form hat UND zu diesem Konto gehoert (V-12b). */
+export function gemerktFuer(roh, email) {
+    if (typeof roh !== "object" || roh === null)
+        return null;
+    const o = roh;
+    if (typeof o.email !== "string" || typeof o.pfad !== "string")
+        return null;
+    if (o.werkbank !== null && typeof o.werkbank !== "string")
+        return null;
+    if (o.zustand !== "angefangen" && o.zustand !== "fertig")
+        return null;
+    if (o.email.toLowerCase() !== email.toLowerCase())
+        return null;
+    return { email: o.email, pfad: o.pfad, werkbank: o.werkbank, zustand: o.zustand };
+}

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,16 +1,23 @@
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir, platform } from "node:os";
-import { join } from "node:path";
+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 { SKILL_TEXTE } from "../texte/skill.js";
@@ -21,14 +28,22 @@ import { skillInstall, ursacheDes } from "./skill-install.js";
  * 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.
  *
  * 🔑 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ü.
  *
- * 📌 Noch ohne Coach und ohne Suche nach einem vorhandenen Arbeitsplatz an anderer Stelle (S-8).
+ * 🔑 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();
@@ -36,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);
@@ -64,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;
     }
@@ -73,22 +290,15 @@ 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));
-    // Plugins VOR der Wache: So hält ihre Sicherungskopie Sabines unveränderte Einstellungen (QA-Fund 9).
-    const git = gitAntwortet();
-    pluginsEinrichten(git);
-    const befehle = await skillInstall();
-    await kursAbhaken(git ? ["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 };
 }
 /**
  * superpowers und das Logo: Ordner ablegen, in Claudes Einstellungen eintragen, eine Zeile `Plugins:`.
@@ -148,14 +358,22 @@ function gitAntwortet() {
 /**
  * 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);
 }