kimal3 0.3.1 → 0.4.0-durchstich.1

package/dist/arbeitsplatz-dateien.js

@@ -315,6 +315,56 @@ export function dateienSchreiben(dateien, ordnerName, hinweis) {
     }
     return 0;
 }
+/**
+ * Welche Dateien der Lieferung noch nicht auf der Platte liegen (Spec 2026-10-11, S-7).
+ * Rein, damit `check:cli` es ohne Platte misst; `gibtEs` fragt `existsSync`.
+ */
+export function welcheFehlen(dateien, gibtEs) {
+    return dateien.filter((d) => !gibtEs(d.pfad));
+}
+/**
+ * Für `kimal3 einrichten`: schreibt NUR, was fehlt, und fasst nichts an, was schon liegt
+ * (Spec 2026-10-11, S-7, L-26, L-62) -- anders als `dateienSchreiben`, das bei einem nicht
+ * leeren Ordner absagt. Ein zweiter Lauf heilt so einen halb geschriebenen Arbeitsplatz.
+ *
+ * 🔑 `flag: "wx"`: Legt ein zweiter, gleichzeitiger Lauf (L-70) dieselbe Datei an, scheitert
+ * dieser hier, statt sie zu überschreiben. Dieselben Absagen und Rückgabewerte wie
+ * `dateienSchreiben` (Begründungen dort): unsicherer Pfad 3, Platte 1.
+ */
+export function fehlendeDateienSchreiben(dateien, ziel) {
+    const t = ARBEITSPLATZ_TEXTE[sprache()];
+    if (dateien.length === 0) {
+        console.error(t.noFiles1);
+        console.error(t.noFiles2);
+        return { ok: false, wert: 3 };
+    }
+    for (const datei of dateien) {
+        if (istUnsichererPfad(datei.pfad)) {
+            console.error(t.unsafePath(datei.pfad));
+            return { ok: false, wert: 3 };
+        }
+    }
+    const ort = (pfad) => join(ziel, ...pfad.split("/"));
+    try {
+        if (existsSync(ziel) && !statSync(ziel).isDirectory()) {
+            console.error(t.isAFile1(ziel));
+            console.error(t.isAFile2);
+            return { ok: false, wert: 1 };
+        }
+        const fehlen = welcheFehlen(dateien, (pfad) => existsSync(ort(pfad)));
+        for (const datei of fehlen) {
+            mkdirSync(dirname(ort(datei.pfad)), { recursive: true });
+            writeFileSync(ort(datei.pfad), datei.inhalt, { encoding: "utf8", flag: "wx" });
+        }
+        return { ok: true, neu: fehlen.length, schonDa: dateien.length - fehlen.length };
+    }
+    catch (fehler) {
+        console.error(t.writeFailed(fehler instanceof Error ? fehler.message : String(fehler)));
+        console.error(t.incomplete(ziel));
+        console.error(t.writeFailedBlame);
+        return { ok: false, wert: 1 };
+    }
+}
 /**
  * Ein `..`-Segment oder ein absoluter Pfad duerften das Ziel verlassen.
  *

package/dist/befehle/einrichten.js

@@ -0,0 +1,100 @@
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { leseAnmeldung } from "../anmeldung.js";
+import { ruf } from "../api.js";
+import { FIRMEN_OPTIONEN, fehlendeDateienSchreiben, istUnsichererOrdnername, vorlageHolen, werkbankOrdner, } from "../arbeitsplatz-dateien.js";
+import { zerlege } from "../argumente.js";
+import { sprache } from "../sprache.js";
+import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
+import { anmeldenMitBrowser } from "./login.js";
+import { skillInstall } 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`).
+ *
+ * 📌 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.
+ */
+export async function einrichten(argv) {
+    const s = sprache();
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(EINRICHTEN_TEXTE[s].help);
+        return 0;
+    }
+    const zerlegt = zerlege(argv, FIRMEN_OPTIONEN, 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"] };
+    console.log(EINRICHTEN_TEXTE[s].start);
+    const gespeichert = leseAnmeldung();
+    if (gespeichert)
+        console.log(ALLGEMEIN_TEXTE[s].signedInAs(gespeichert.email));
+    else {
+        const angemeldet = await anmeldenMitBrowser();
+        if (angemeldet !== 0)
+            return angemeldet;
+    }
+    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();
+        if (angemeldet !== 0)
+            return angemeldet;
+        holen = await vorlageHolen("einrichten", "", wunsch, null);
+    }
+    if (!holen.ok)
+        return holen.wert;
+    // 🌐 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)) {
+        console.error(t.unsafeFolder(wurzel));
+        return 3;
+    }
+    const werkbank = werkbankOrdner(dateien);
+    if (werkbank === null) {
+        console.error(t.noWorkbank);
+        return 3;
+    }
+    const ziel = join(homedir(), wurzel);
+    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;
+}
+/** Git ist da, wenn `git --version` antwortet -- Node.js ist es, sonst liefe dieses Programm nicht. */
+function gitAntwortet() {
+    return spawnSync("git", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+}
+/**
+ * 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).
+ */
+async function kursAbhaken(schritte) {
+    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);
+    }
+}

package/dist/befehle/login.js

@@ -2,23 +2,51 @@ import { hostname } from "node:os";
 import { feld, ruf } from "../api.js";
 import { BASIS_URL, schreibeAnmeldung } from "../anmeldung.js";
 import { sprache } from "../sprache.js";
+import { anmeldeAdresse, oeffneImBrowser } from "../browser.js";
 import { ALLGEMEIN_TEXTE } from "../texte/allgemein.js";
+import { EINRICHTEN_TEXTE } from "../texte/einrichten.js";
 import { stelleSkillUm } from "./skill-tausch.js";
 const warte = (ms) => new Promise((f) => setTimeout(f, ms));
-export async function login() {
-    // 🌐 Die Sprache wird bei JEDER Ausgabe neu gelesen: Die Abhol-Antwort nennt die Kontosprache
-    // (Task 5) und kann sie mitten im Lauf aendern -- die Adresse vorher kam noch in der alten.
-    const t = () => ALLGEMEIN_TEXTE[sprache()];
+// 🌐 Die Sprache wird bei JEDER Ausgabe neu gelesen: Die Abhol-Antwort nennt die Kontosprache
+// (Task 5) und kann sie mitten im Lauf aendern -- die Adresse vorher kam noch in der alten.
+const t = () => ALLGEMEIN_TEXTE[sprache()];
+async function starteAnmeldung() {
     const start = await ruf("/api/cli/login/start", { koerper: { bezeichnung: hostname() } });
     const nutzerCode = feld(start.koerper, "nutzer_code");
     const geraeteCode = feld(start.koerper, "geraete_code");
     if (start.status !== 200 || !nutzerCode || !geraeteCode) {
         console.error(t().unreachable);
-        return 3;
+        return null;
     }
+    return { nutzerCode, geraeteCode };
+}
+export async function login() {
+    const start = await starteAnmeldung();
+    if (!start)
+        return 3;
     console.log(t().loginOpen(BASIS_URL));
-    console.log(t().loginEnterCode(nutzerCode));
+    console.log(t().loginEnterCode(start.nutzerCode));
     console.log(t().loginWaiting);
+    return warteAufBestaetigung(start.geraeteCode);
+}
+/**
+ * Die Anmeldung für `kimal3 einrichten` (Spec 2026-10-11, S-2): Code und Adresse auf eigenen
+ * Zeilen, die Claude liest (Marken in `texte/einrichten-marken.ts`), und der Browser öffnet
+ * die Seite mit dem Code -- die Seite fragt dort, ob er im Claude-Fenster steht.
+ */
+export async function anmeldenMitBrowser() {
+    const start = await starteAnmeldung();
+    if (!start)
+        return 3;
+    const e = EINRICHTEN_TEXTE[sprache()];
+    const adresse = anmeldeAdresse(BASIS_URL, start.nutzerCode);
+    console.log(e.codeLine(start.nutzerCode));
+    console.log(e.addressLine(adresse));
+    console.log(oeffneImBrowser(adresse) ? e.browserOpened : e.browserNotOpened);
+    console.log(t().loginWaiting);
+    return warteAufBestaetigung(start.geraeteCode);
+}
+async function warteAufBestaetigung(geraeteCode) {
     const endeUm = Date.now() + 10 * 60 * 1000;
     while (Date.now() < endeUm) {
         await warte(2000);

package/dist/befehle/werkbank.js

@@ -34,24 +34,14 @@ import { leseEineDatei, leseMerkzettelDatei } from "../kontext-dateien.js";
  *     arbeitsplatz neu  →  einmal pro FIRMA   (die ganze Familie)
  *     werkbank neu      →  einmal pro MENSCH  (nur der eigene Teil)
  *
- * 🔴 **GRENZE, die dieser Befehl heute NICHT aufhebt** (Review-Runde 4 zu
- * PR #25, nachgemessen an `src/lib/pro/zugang.ts`): Er holt die Vorlage über
- * `/api/cli/arbeitsplatz`, und die Tür dort fragt `istPro(user_id)` — eine
- * Zeile in `konto_plan`, **pro Person**. Es gibt keinen Weg über
- * `memberships`/`organizations`.
+ * 🔑 **Kein Pro nötig (seit 2026-10-11, Spec „Einstieg mit Leitung", S-6)**: Der Befehl
+ * holt die Vorlage über `/api/cli/arbeitsplatz`, und diese Route hat keine Pro-Tür mehr —
+ * jedes angemeldete Konto bekommt den Ordner. Nur die gemeinsamen Firmenantworten gehen
+ * ausschließlich an Pro (`kontextFuerPlan` am Server). Hier im Befehl ändert sich dafür
+ * nichts: Die Entscheidung fällt am Server.
  *
- * Der zweite Mensch einer Kundenfirma — also genau der, für den dieser Befehl
- * gebaut wurde — braucht damit ein **eigenes Pro-Konto**. Hat er keins,
- * bekommt er `402` und Rückgabewert `4`, und `SKILL.md` weist Claude dort
- * ausdrücklich an, NICHT zu wiederholen.
- *
- * ⚠️ Das ist **keine Panne, sondern eine offene Produktfrage**: Erbt ein
- * Firmenmitglied den Zugang, oder kauft jeder einzeln? Sie gehört Dennis, nicht
- * diesem Befehl — deshalb steht sie in `WEITER-HIER.md` unter „Entscheidungen"
- * und nicht als stille Erweiterung von `istPro` hier drin.
- * *Eine Grenze, die man benennt, ist etwas anderes als eine, die man
- * übersieht* — und sie reiht sich neben die schon bekannte: Der Angestellte hat
- * ohnehin noch keinen gebauten Weg an den Firmen-Ordner (Stufe 2).
+ * ⚠️ Eine Grenze bleibt, unabhängig davon: Der Angestellte hat noch keinen
+ * gebauten Weg an den Firmen-Ordner (Stufe 2).
  *
  * 🔴 **Die wichtigste Eigenschaft: Er fasst die Firmenebene NICHT an.** Kein
  * einziges Byte in `kontext/`, `CLAUDE.md`, `README.md`, `.gitignore` — auch

package/dist/befehle-katalog-en.js

@@ -25,14 +25,14 @@ export const BEFEHLE_EN = {
         ],
     },
     "kimal3 arbeitsplatz neu": {
-        stempel: "231b90bf",
+        stempel: "6fd35d27",
         befehl: "kimal3 workplace new",
         tippen: "! kimal3 workplace new",
         terminal: "kimal3 workplace new",
         beschreibung: "Create the whole AI Workplace — company level and workbench",
         rhythmusOderSatz: "once per company",
         details: [
-            "Fetches the template from your Pro account and creates it here as a real folder — CLAUDE.md, routine commands, the workbench for your projects. The same package is available to download on /pro.",
+            "Fetches the template from your kimal3 account and creates it here as a real folder — CLAUDE.md, routine commands, the workbench for your projects. The same package is available to download on /pro.",
             "The folder is called AI-Workplace (KI-Arbeitsplatz for a German-speaking company). To keep several companies apart, use the folder above it, e.g. Clients/ARNO/AI-Workplace. Add your first name and your workbench inside it is called workbench-sabine: kimal3 workplace new sabine.",
             "If the target folder already exists and isn't empty, the command stops instead of overwriting anything — your work is safe. You'll know it worked when it tells you how many files it created.",
             "⚠️ It also creates the company level (context/ with brand, systems, security — kontext/ in a German workplace). If that already exists, you need kimal3 workbench new — otherwise you end up with a second company inside the first.",
@@ -53,7 +53,7 @@ export const BEFEHLE_EN = {
         ],
     },
     "kimal3 kontext runter": {
-        stempel: "9ccf1083",
+        stempel: "55d21a3c",
         befehl: "kimal3 context download",
         tippen: "! kimal3 context download",
         terminal: "kimal3 context download",
@@ -63,7 +63,7 @@ export const BEFEHLE_EN = {
             "Fetches CLAUDE.md and the five files in context/ (kontext/ in a German workplace) from your company and puts them in your AI Workplace. Anything you've changed locally is left alone — it tells you how to send it up.",
             "If you changed a file locally AND the company has changed it too in the meantime, it saves your version in context/before-<date>/ (kontext/vorher-<datum>/ in a German workplace) first, then replaces it — nothing gets lost.",
             "You'll know it worked when it names the updated files or says “Your company context is up to date.”",
-            "⚠️ Like kimal3 workbench new, it needs your own Pro account. Without one you get exit code 4 — then don't retry.",
+            "⚠️ It needs Pro — your own or through your company. Without it you get exit code 4 — then don't retry.",
         ],
     },
     "kimal3 kontext fragen": {

package/dist/befehle-katalog.js

@@ -64,7 +64,7 @@ export const BEFEHLE = [
         tippen: "! kimal3 arbeitsplatz neu",
         terminal: "kimal3 arbeitsplatz neu",
         details: [
-            "Holt die Vorlage von deinem Pro-Konto und legt sie hier als echten Ordner an — CLAUDE.md, Takt-Befehle, die Werkbank für deine Projekte. Dasselbe Paket, das auch als Download auf /pro liegt.",
+            "Holt die Vorlage aus deinem kimal3-Konto und legt sie hier als echten Ordner an — CLAUDE.md, Takt-Befehle, die Werkbank für deine Projekte. Dasselbe Paket, das auch als Download auf /pro liegt.",
             "Der Ordner heißt KI-Arbeitsplatz (bei einer englischsprachigen Firma AI-Workplace) — mehrere Firmen trennst du über den Ordner darüber, z. B. Kunden/ARNO/KI-Arbeitsplatz. Gib deinen Vornamen mit, dann heißt deine Werkbank darin werkbank-sabine (bei einem englischen Konto workbench-sabine): kimal3 arbeitsplatz neu sabine.",
             "Gibt es den Zielordner schon und ist er nicht leer, bricht der Befehl ab, statt etwas zu überschreiben — deine Arbeit ist sicher. Geklappt hat es, wenn er die Zahl der angelegten Dateien nennt.",
             "⚠️ Er legt auch die Firmenebene an (kontext/ mit Marke, Systemen, Sicherheit). Steht die schon, brauchst du kimal3 werkbank neu — sonst entsteht eine zweite Firma in der ersten.",
@@ -112,7 +112,7 @@ export const BEFEHLE = [
             "Holt CLAUDE.md und die fünf Dateien in kontext/ von deiner Firma und legt sie in deinem KI-Arbeitsplatz ab. Was du selbst lokal geändert hast, fasst er nicht an — er sagt dir, wie du es einbringst.",
             "Hast du eine Datei lokal geändert UND hat die Firma sie inzwischen auch geändert, sichert er deine Fassung zuerst nach kontext/vorher-<datum>/, bevor er sie ersetzt — nichts geht verloren.",
             "Geklappt hat es, wenn er die aktualisierten Dateien nennt oder „Dein Firmenkontext ist aktuell“ sagt.",
-            "⚠️ Wie werkbank neu braucht er ein eigenes Pro-Konto. Ohne das kommt Rückgabewert 4 — dann nicht wiederholen.",
+            "⚠️ Er braucht Pro — eigenes oder über deine Firma. Ohne das kommt Rückgabewert 4 — dann nicht wiederholen.",
         ],
     },
     {

package/dist/befehlswoerter.js

@@ -1,4 +1,5 @@
 export const BEFEHLSWOERTER = {
+    einrichten: { de: "einrichten", en: "setup" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)
     login: { de: "login", en: "login" },
     logout: { de: "logout", en: "logout" },
     "skill install": { de: "skill install", en: "skill install" }, // kein-anzeigetext: Befehlswörter (Spec Abschnitt 6)

package/dist/browser.js

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+/**
+ * Öffnet eine Adresse im Standard-Browser (Spec 2026-10-11, S-2: Sabine soll keinen Code abtippen).
+ *
+ * 🔑 Ohne Shell: `rundll32 url.dll,FileProtocolHandler` statt `cmd /c start` -- `cmd` deutet
+ * `&` und `^` in der Adresse als Befehl. Dazu die Positivliste (messen-und-pruefen.md, §23):
+ * Nur http(s) und nur Zeichen, die in unseren Adressen vorkommen.
+ * ⚠️ `platform()` aus `node:os`, nicht `process.platform` -- `check:beenden` lässt hinter
+ * `process` nur eine feste Liste zu.
+ */
+const SICHERE_ADRESSE = /^https?:\/\/[A-Za-z0-9.-]+(:[0-9]+)?(\/[A-Za-z0-9\-._~/?=&%]*)?$/;
+/** Die Adresse der Bestätigungsseite mit mitgebrachtem Code (eine Adresse, kein Anzeigetext). */
+export const anmeldeAdresse = (basis, code) => `${basis}/cli?code=${encodeURIComponent(code)}`; // kein-anzeigetext: Adresse der Bestätigungsseite
+export function browserBefehl(plattform, url) {
+    if (!SICHERE_ADRESSE.test(url))
+        return null;
+    if (plattform === "win32")
+        return { befehl: "rundll32", argumente: ["url.dll,FileProtocolHandler", url] }; // kein-anzeigetext: Windows-Aufruf
+    if (plattform === "darwin")
+        return { befehl: "open", argumente: [url] };
+    return { befehl: "xdg-open", argumente: [url] };
+}
+/**
+ * `true` heißt „versucht", nicht „sichtbar" -- ob ein Fenster aufging, weiß nur der Mensch.
+ * Deshalb druckt `einrichten` die Adresse IMMER mit. Der Kindprozess wird abgehängt
+ * (`unref`), damit er das Programm nicht am Leben hält; ein Fehler beim Starten (kein
+ * `xdg-open`) wird geschluckt, statt das Programm abzubrechen.
+ */
+export function oeffneImBrowser(url) {
+    const b = browserBefehl(platform(), url);
+    if (b === null)
+        return false;
+    try {
+        const kind = spawn(b.befehl, b.argumente, { detached: true, stdio: "ignore", windowsHide: true });
+        kind.on("error", () => { });
+        kind.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/kimal3.js

@@ -20,11 +20,12 @@ import { WACHE_TEXTE } from "./texte/wache.js";
 import { leseWacheDatei, sitzungJetzt, wacheAusgefallen } from "./wache-schalter.js";
 import { formatiere, heuteAus, skillZustand, sollZeigen, } from "./nachricht.js";
 import { eigeneVersion } from "./version.js";
-import { sprache } from "./sprache.js";
+import { merkeBefehlsSprache, sprache } from "./sprache.js";
 import { ALLGEMEIN_TEXTE } from "./texte/allgemein.js";
 import { hilfeText } from "./hilfe.js";
-import { erkenneBefehl } from "./befehlswoerter.js";
+import { BEFEHLSWOERTER, erkenneBefehl } from "./befehlswoerter.js";
 import { arbeitsplatzNeu } from "./befehle/arbeitsplatz.js";
+import { einrichten } from "./befehle/einrichten.js";
 import { werkbankNeu } from "./befehle/werkbank.js";
 import { firmaDaten } from "./befehle/firma-daten.js";
 import { kontextFragen } from "./befehle/kontext-fragen.js";
@@ -484,6 +485,7 @@ async function fuehreAus(name, rest) {
         case "projekt liste": return allein ? projektListe() : null;
         // ⚠️ Rest wird durchgereicht, nicht auf Gleichheit geprueft: `firma daten --firma X` gehoert dazu.
         case "firma daten": return firmaDaten(rest);
+        case "einrichten": return einrichten(rest);
         case "arbeitsplatz neu": return arbeitsplatzNeu(rest);
         case "werkbank neu": return werkbankNeu(rest);
         case "kontext runter": return kontextRunter(rest);
@@ -537,6 +539,10 @@ async function haupt() {
     // extra` bleibt unbekannt. Der grosse Kommentar zur Nachsicht bei `wache --irgendwas` steht
     // unten an `fuehreAus` und gilt unveraendert.
     const erkannt = erkenneBefehl(argv);
+    // 🌐 `setup` spricht Englisch, `einrichten` Deutsch, solange keine Kontosprache gemerkt ist --
+    // die Anleitung, die den Befehl tippt, liest seine Marken (Begruendung an `startSprache`).
+    if (erkannt?.name === "einrichten")
+        merkeBefehlsSprache(argv[0] === BEFEHLSWOERTER.einrichten.en ? "en" : "de");
     if (erkannt) {
         const code = await fuehreAus(erkannt.name, erkannt.rest);
         if (code !== null)

package/dist/nachricht.js

@@ -259,10 +259,14 @@ export function stempelZeile(version, sprache) {
 }
 /**
  * Die Sprache des LETZTEN Stempels (wie `stempelAus`: ein Beispiel im Text darf nicht gewinnen).
+ *
+ * 🔴 Die Vorabfassung (`0.4.0-durchstich.1`) trägt einen Zusatz hinter den Zahlen -- ohne `(?:-…)?`
+ * fand das Muster bei ihr die Sprache nie, jeder englische Stempel galt als deutsch, und der Login
+ * stellte nichts mehr um (gemessen von `check:cli-live` L1/L6 beim Task 7 des Durchstichs).
  * Ohne Zusatz -- und bei jedem anderen Zusatz als genau `en` -- Deutsch (T4-4).
  */
 export function stempelSpracheAus(inhalt) {
-    const treffer = [...inhalt.matchAll(/kimal3:erzeugt version=[0-9][0-9.]*(?: sprache=([a-z]+))?/g)];
+    const treffer = [...inhalt.matchAll(/kimal3:erzeugt version=[0-9][0-9.]*(?:-[0-9A-Za-z.]+)?(?: sprache=([a-z]+))?/g)];
     return treffer.length > 0 && treffer[treffer.length - 1][1] === "en" ? "en" : "de";
 }
 /**

package/dist/sprache.js

@@ -40,11 +40,21 @@ export function spracheAusSystem(gebiet) {
     return klein === "en" || klein.startsWith("en-") ? "en" : "de";
 }
 /**
- * Die Sprache beim Start (T3-2): Merkzettel -> sonst Deutsch, wenn schon eine Anmeldung liegt
- * (wer von einer aelteren Fassung aktualisiert: Sabine mit englischem Windows sah bisher immer
- * Deutsch) -> sonst das Betriebssystem.
+ * Die Sprache beim Start (T3-2): die Sprache des getippten Befehlsworts, wo es eine traegt ->
+ * sonst der Merkzettel -> sonst Deutsch, wenn schon eine Anmeldung liegt (wer von einer aelteren
+ * Fassung aktualisiert: Sabine mit englischem Windows sah bisher immer Deutsch) -> sonst das
+ * Betriebssystem.
+ *
+ * 🔑 DAS BEFEHLSWORT GANZ VORN (Durchstich, Gesamtpruefung Punkt 3 und Review a73305f, Befund 1):
+ * `kimal3 setup` tippt nur die englische Anleitung, und die wartet auf `Sign-in code:`. Jim mit
+ * englischem Konto und deutschem Windows bekam sonst `Anmelde-Code:`. Auch VOR dem Merkzettel:
+ * Der uebersteht `logout` -- meldet Jim auf Kemals Laptop erst Kemal ab, laege dort Kemals
+ * Deutsch. Gilt nur bis zur ersten Antwort des Servers; ab da die Kontosprache
+ * (`uebernimmKontosprache`).
  */
 export function startSprache(lage) {
+    if (lage.befehlsSprache !== null)
+        return lage.befehlsSprache;
     const gemerkt = alsSprache(lage.merkzettel);
     if (gemerkt !== null)
         return gemerkt;
@@ -78,12 +88,24 @@ function leseMerkzettel() {
 }
 let gemerkt;
 let aktuell = null;
+let befehlsSprache = null;
+/**
+ * Der Verteiler meldet hier die Sprache des getippten Befehlsworts -- nur fuer `einrichten`/`setup`,
+ * den einen Befehl, den eine Anleitung auf einem frischen Rechner aufruft und dessen Ausgabe sie
+ * liest. Er laeuft vor der ersten Ausgabe; `aktuell` wird trotzdem verworfen, damit die Reihenfolge
+ * nicht stillschweigend daran haengt.
+ */
+export function merkeBefehlsSprache(s) {
+    befehlsSprache = s;
+    aktuell = null;
+}
 /** Die Sprache dieses Laufs. */
 export function sprache() {
     if (aktuell === null) {
         gemerkt = leseMerkzettel();
         aktuell = startSprache({
             merkzettel: gemerkt,
+            befehlsSprache,
             angemeldet: leseAnmeldung() !== null,
             systemGebiet: Intl.DateTimeFormat().resolvedOptions().locale,
         });
@@ -97,10 +119,12 @@ export function sprache() {
  */
 export function uebernimmKontosprache(kopf) {
     sprache();
+    // 🔑 `aktuell` folgt dem Kopf auch dann, wenn der Merkzettel schon dieselbe Sprache traegt --
+    // sonst bliebe ein Lauf, der mit dem Befehlswort begann (`setup` bei deutschem Konto), englisch.
+    aktuell = alsSprache(kopf) ?? aktuell;
     const neu = nachAntwort(gemerkt, kopf);
     if (neu === null)
         return;
-    aktuell = neu;
     gemerkt = neu;
     try {
         // ⚠️ `mode: 0o700` wie in anmeldung.ts und gesehen.ts -- wer den Ordner zuerst anlegt, legt

package/dist/texte/einrichten-marken.js

@@ -0,0 +1,9 @@
+/**
+ * Die Zeilenanfaenge, an denen Claude die Ausgabe von `kimal3 einrichten` liest
+ * (Anleitung `/einrichten` und `/setup`, Schritt 3). Eine Stelle fuer beide: Das
+ * 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" },
+};

package/dist/texte/einrichten.js

@@ -0,0 +1,35 @@
+import { EINRICHTEN_MARKEN } from "./einrichten-marken.js";
+const M = EINRICHTEN_MARKEN;
+const de = {
+    codeLine: (code) => `\n  ${M.de.code} ${code}`,
+    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",
+    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}`,
+    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.",
+};
+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",
+    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}`,
+    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.",
+};
+export const EINRICHTEN_TEXTE = { de, en };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.3.1",
+  "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": {

package/skill/SKILL.md

@@ -130,10 +130,10 @@ frag ihn, welche Firma.** Was hier auf dem Spiel steht: Der Ordner trägt den Na
 Firma auf die Platte, nach der er nicht gefragt hat — und er merkt es nicht, weil auf seinem
 Bildschirm nur „✓ angelegt" steht.
 
-⚠️ **`werkbank neu` verlangt ein eigenes Pro-Konto.** Die Route prüft den Plan **pro Person**
-(`konto_plan`), nicht über die Firmen-Mitgliedschaft. Ein Kollege ohne eigenes Pro bekommt
-Rückgabewert `4` — dann **nicht** wiederholen und nicht raten, sondern genau das sagen: Sein
-Konto hat keinen Pro-Zugang.
+📌 **`werkbank neu` (und `arbeitsplatz neu`) funktionieren für jedes angemeldete Konto — ohne Pro.**
+Pro entscheidet nur darüber, ob der gemeinsame Firmenkontext (die Antworten, die der Firmen-Admin
+gepflegt hat) im Ordner steht: Ohne Pro bekommt der Ordner den Firmennamen und die leeren Fragen,
+mit Pro zusätzlich die Antworten.
 
 **Was dabei entsteht:** ein Firmen-Ordner mit Regeln für Marke, Systeme und Sicherheit, darin
 eine Werkbank zum Arbeiten und ein Beispiel-Projekt zum Ansehen. `werkbank neu` legt nur den
@@ -258,8 +258,8 @@ das Wissen der gewählten Firma **auf seine Platte**, `kontext hoch` schickt sei
 die gewählte Firma** — dort sehen sie alle Kolleginnen und Kollegen. *Eine falsche Wahl ist
 hier keine falsche Anzeige, sondern eine Datei am falschen Ort.*
 
-⚠️ **Beide Befehle brauchen wie `werkbank neu` ein eigenes Pro-Konto** — ohne das kommt
-Rückgabewert `4`, dann **nicht wiederholen**.
+⚠️ **Beide Befehle brauchen Pro — eigenes oder über die Firma** — ohne das
+kommt Rückgabewert `4`, dann **nicht wiederholen**.
 
 `kimal3 kontext hoch --ueberschreiben` erzwingt das Speichern, auch wenn die Firma inzwischen von
 jemand anderem geändert wurde. **Nur auf ausdrücklichen Wunsch einsetzen** — sonst geht die

package/skill/en/SKILL.md

@@ -131,9 +131,10 @@ in its company knowledge**. If you choose yourself, you put a company's knowledg
 disk that they never asked for — and they don't notice, because their screen only says
 “✓ … files created.”
 
-⚠️ **`workbench new` requires a Pro account of their own.** The route checks the plan **per person**
-(`konto_plan`), not via company membership. A colleague without their own Pro gets exit code `4`
-— then do **not** retry and do not guess, but say exactly that: their account has no Pro access.
+📌 **`workbench new` (and `workplace new`) work for every signed-in account — without Pro.**
+Pro only decides whether the shared company context (the answers the company admin has
+maintained) is in the folder: without Pro the folder gets the company name and the empty
+questions, with Pro the answers as well.
 
 **What this creates:** a company folder with rules for brand, systems and security, inside it a
 workbench to work in and an example project to look at. `workbench new` only creates the second
@@ -255,8 +256,8 @@ company's knowledge **onto their disk**, `context upload` sends their texts **in
 company** — where all their colleagues see them. *A wrong choice here is not a wrong display but a
 file in the wrong place.*
 
-⚠️ **Like `workbench new`, both commands require a Pro account of their own** — without it comes
-exit code `4`, then **do not retry**.
+⚠️ **Both commands need Pro — their own or through their company** —
+without it comes exit code `4`, then **do not retry**.
 
 `kimal3 context upload --overwrite` forces the save, even if someone else has changed the company
 context in the meantime. **Only use it when explicitly asked** — otherwise the colleague's change