hmgr 0.0.7 → 0.0.12

package/dist/cli/main.js

@@ -5,19 +5,23 @@ import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { Anwendungsfaelle, } from "../kern/anwendungsfaelle.js";
-import { AbhaengigkeitFehlt, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
+import { AbhaengigkeitFehlt, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, HeimOhneCliZugriff, HeimUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, WslBrueckeFehlgeschlagen, ZeigerSchreibenGesperrt, heimAdresseAlsText, heimAdresseZerlegen, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
 import { Agents } from "../adapter/agents.js";
-import { ClaudeCode } from "../adapter/claude-code.js";
+import { ClaudeCode, claudeAusfuehrer } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
 import { ComposerZeiger } from "../adapter/composer.js";
-import { DateisystemZiele } from "../adapter/dateisystem.js";
+import { DateisystemZiele, LokalerZugriff } from "../adapter/dateisystem.js";
+import { ZustandHeime } from "../adapter/heime.js";
+import { WslBruecke, WslZugriff, wslAusfuehrer, wslDistros } from "../adapter/wsl.js";
 import { GitQuellen } from "../adapter/git.js";
 import { DateiMcpKatalog } from "../adapter/mcp-katalog.js";
+import { cliUpdateHinweis } from "../adapter/npm-registry.js";
 import { paketVersion } from "../adapter/paket-version.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ProzessUmgebung } from "../adapter/umgebung.js";
 import { ZustandJson } from "../adapter/zustand-json.js";
+import { VerlaufJson } from "../adapter/verlauf-json.js";
 import { HILFE, hilfeText } from "./hilfe.js";
 export function umgebungLesen(env = process.env) {
     const home = env.HOME ?? homedir();
@@ -30,19 +34,45 @@ export function umgebungLesen(env = process.env) {
 }
 export function bauen(umgebung, optionen = {}) {
     const zustand = new ZustandJson(path.join(umgebung.hmgrHome, 'state.json'));
+    const verlauf = new VerlaufJson(umgebung.hmgrHome);
     const wurzel = path.join(umgebung.hmgrHome, 'checkouts');
-    const claude = optionen.claudeAusfuehrer === undefined
-        ? new ClaudeCode(umgebung.home)
-        : new ClaudeCode(umgebung.home, optionen.claudeAusfuehrer);
+    const umgebungPort = optionen.umgebung ?? new ProzessUmgebung();
+    // Homedirs aus dem Zustand (E78): das primäre lässt sich umstellen (F89), dazu kommen
+    // zusätzliche in einer WSL-Distro (F87). `wsl:`-Heime fallen außerhalb von Windows heraus.
+    const heime = new ZustandHeime(zustand, umgebung.home, umgebungPort.plattform());
+    const wslAusfuehren = optionen.wslAusfuehrer ?? wslAusfuehrer;
+    // Je Distro eine Bridge, damit die einmal ermittelte Automount-Wurzel im Lauf erhalten bleibt.
+    const bruecken = new Map();
+    const bruecke = (distro) => {
+        let vorhanden = bruecken.get(distro);
+        if (vorhanden === undefined) {
+            vorhanden = new WslBruecke(distro, wslAusfuehren);
+            bruecken.set(distro, vorhanden);
+        }
+        return vorhanden;
+    };
+    const lokal = new LokalerZugriff();
+    const zugriffFuerOrt = (ort) => {
+        const adresse = ort.art === 'home' ? ort.heim : undefined;
+        const zerlegt = adresse === undefined ? undefined : heimAdresseZerlegen(adresse);
+        return zerlegt === undefined ? lokal : new WslZugriff(bruecke(zerlegt.distro));
+    };
+    const claude = new ClaudeCode(heime, optionen.claudeAusfuehrer ?? claudeAusfuehrer, zugriffFuerOrt);
     const ports = {
-        harnesses: [claude, new Hermes(umgebung.home), new Agents(umgebung.home)],
+        harnesses: [claude, new Hermes(heime), new Agents(heime)],
         quellen: new GitQuellen(wurzel),
-        ziele: new DateisystemZiele(wurzel, zustand, umgebung.xdgStateHome),
+        ziele: new DateisystemZiele(wurzel, zustand, umgebung.xdgStateHome, (ziel) => zugriffFuerOrt(ziel.ort)),
         zeiger: new ComposerZeiger(),
         zustand,
         rueckfrage: optionen.rueckfrage ?? new TerminalRueckfrage(),
         mcpKatalog: new DateiMcpKatalog(path.join(umgebung.hmgrHome, 'mcp.yaml')),
-        umgebung: optionen.umgebung ?? new ProzessUmgebung(),
+        umgebung: umgebungPort,
+        heime,
+        wsl: {
+            distros: async () => await wslDistros(wslAusfuehren),
+            home: async (distro) => await bruecke(distro).home(),
+        },
+        verlauf,
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
@@ -65,6 +95,7 @@ const SCHALTER = {
     sync: { werte: [], flaggen: [] },
     update: { werte: [], flaggen: [] },
     status: { werte: [], flaggen: [] },
+    log: { werte: [], flaggen: [] },
     harness: { werte: ['profil'], flaggen: [] },
 };
 /**
@@ -165,6 +196,11 @@ function unterkommandoPruefen(kommando, schalter) {
                     `hmgr help ${kommando} zeigt die Schalter.`);
     restPruefen(schalter.rest, menge.woerter, kommando, unterkommando);
 }
+/**
+ * `--ort` deuten. Ein zusätzliches Homedir (E78, F87) heißt nach seiner Adresse: `--ort wsl:Ubuntu`,
+ * auch in der ausgeschriebenen Form `--ort home:wsl:Ubuntu`. Beides ergibt denselben Ort, damit
+ * niemand raten muss, ob das `home:` davor gehört.
+ */
 function ortLesen(text) {
     const roh = text ?? 'home';
     if (roh === 'home')
@@ -173,7 +209,10 @@ function ortLesen(text) {
         return { art: 'arbeitsverzeichnis', pfad: path.resolve(roh.slice(4)) };
     if (roh.startsWith('profil:'))
         return { art: 'profil', name: roh.slice(7) };
-    throw new Error(`Unbekannter Ort „${roh}", erwartet home, dir:<pfad> oder profil:<name>`);
+    const heim = heimAdresseZerlegen(roh.startsWith('home:') ? roh.slice(5) : roh);
+    if (heim !== undefined)
+        return { art: 'home', heim: heimAdresseAlsText(heim) };
+    throw new Error(`Unbekannter Ort „${roh}", erwartet home, wsl:<distro>, dir:<pfad> oder profil:<name>`);
 }
 /** Klartext für den Grund, aus dem ein fremder Eintrag liegen bleibt (B12). */
 const UEBERNAHME_GRUND = {
@@ -217,6 +256,14 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         console.log(text);
         return 0;
     }
+    // Versionssprung vermerken (E80): bei jedem echten Kommando, Hilfe und Version sind oben schon
+    // zurückgekehrt. Ein Fehler hier (etwa ein kaputtes verlauf.json) darf kein Kommando kippen.
+    try {
+        await anwendungsfaelle.versionsSprungVermerken('cli', paketVersion(), 'cli');
+    }
+    catch {
+        // still, siehe oben.
+    }
     if (kommando === 'source') {
         const schalter = schalterLesen(argv.slice(1), 'source');
         unterkommandoPruefen('source', schalter);
@@ -668,7 +715,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'update') {
         restPruefen(schalterLesen(argv.slice(1), 'update').rest, 0, 'update');
-        const { checkouts: liste, pluginHarnesses, bundles, aufraeumen } = await anwendungsfaelle.aktualisieren();
+        const { checkouts: liste, bundles, aufraeumen } = await anwendungsfaelle.aktualisieren({ ausloeser: 'cli' });
         if (liste.length === 0)
             console.log('Keine Checkouts.');
         for (const { checkout, aktualisierung, geaenderteSkills } of liste) {
@@ -687,8 +734,6 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             else
                 console.log(`  fehlgeschlagen  ${kopf}  ${aktualisierung.fehler}`);
         }
-        for (const name of pluginHarnesses)
-            console.log(`  Plugins         ${name} aktualisiert (E14)`);
         // Bundles im selben Lauf (E69, F64=O1): eine geänderte Definition wird hier nachgezogen.
         for (const zeile of bundleBericht(bundles))
             console.log(zeile);
@@ -706,11 +751,26 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             const geloescht = aufraeumen.verwaiste.filter((v) => v.geloescht).length;
             console.log(`${aufraeumen.verwaiste.length} verwaist, ${geloescht} gelöscht, ${aufraeumen.verwaiste.length - geloescht} liegen geblieben.`);
         }
+        // Zuletzt hmgr selbst (E77): wer schon aktualisiert, will auch wissen, dass sein hmgr alt ist.
+        // Verglichen wird die eigene Version (E72) gegen npm, gemeldet wird nur — installiert wird
+        // nichts. Offline oder Registry unerreichbar heißt keine Zeile, still: der Lauf selbst ist
+        // fertig und gelungen, ein fehlgeschlagener Nebenblick darf ihn nicht kommentieren.
+        const selbst = await cliUpdateHinweis(paketVersion());
+        if (selbst !== null) {
+            console.log(selbst.text);
+            await anwendungsfaelle.hmgrEreignisVermerken({ art: 'cli-verfuegbar', version: selbst.neu }, 'cli');
+        }
         return 0;
     }
     if (kommando === 'status') {
         restPruefen(schalterLesen(argv.slice(1), 'status').rest, 0, 'status');
-        for (const zielZustand of await anwendungsfaelle.istZustand()) {
+        // Ziele inaktiver Harnesses bleiben aus der Liste (E74), auch wenn dort noch Links oder fremde
+        // Einträge liegen: was hmgr nicht managed, zeigt es nicht. Gefiltert wird hier, nicht in
+        // istZustand — der Kern bleibt ungefiltert (E19), sonst hielte kein Link in einem inaktiven
+        // Harness seinen Checkout mehr vor dem Aufräumen.
+        const aktiveStatus = new Set(await anwendungsfaelle.aktiveHarnesses());
+        const sichtbareZiele = (await anwendungsfaelle.istZustand()).filter((z) => aktiveStatus.has(z.ziel.harness));
+        for (const zielZustand of sichtbareZiele) {
             console.log(`Ziel ${zielZustand.ziel.harness} ${beschreibeOrt(zielZustand.ziel.ort)} (${zielZustand.verzeichnis})`);
             if (zielZustand.eintraege.length === 0)
                 console.log('  (leer)');
@@ -737,6 +797,18 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             console.log(`Nicht vorhanden: ${fehlend.join(', ')}`);
         return 0;
     }
+    if (kommando === 'log') {
+        restPruefen(schalterLesen(argv.slice(1), 'log').rest, 0, 'log');
+        const eintraege = await anwendungsfaelle.verlauf();
+        if (eintraege.length === 0)
+            console.log('Noch keine Ereignisse.');
+        for (const eintrag of eintraege) {
+            console.log(verlaufZeitpunkt(eintrag.zeit));
+            for (const ereignis of eintrag.ereignisse)
+                console.log(`  ${verlaufEreignisZeile(ereignis)}`);
+        }
+        return 0;
+    }
     if (kommando === 'harness') {
         const schalter = schalterLesen(argv.slice(1), 'harness');
         unterkommandoPruefen('harness', schalter);
@@ -790,13 +862,83 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 'harness skills-dir <name> add <pfad> oder harness skills-dir <name> remove. ' +
                 'hmgr help harness zeigt Beispiele.');
         }
+        // Homedirs eines Harness (E78): zeigen, das primäre umstellen (F89), zusätzliche in einer
+        // WSL-Distro hinzufügen und entfernen (F87).
+        if (unterkommando === 'home') {
+            const harnessName = rest[1];
+            if (harnessName === undefined)
+                throw new Error('harness home braucht einen Harness-Namen, etwa hmgr harness home claude-code. ' +
+                    'hmgr harness list zeigt die bekannten Namen.');
+            const unter = rest[2];
+            if (unter === undefined) {
+                restPruefen(rest, 2, 'harness', 'home');
+                const ansicht = (await anwendungsfaelle.harnessHeime()).find((h) => h.harness === harnessName);
+                if (ansicht === undefined)
+                    throw new HarnessTypUnbekannt(harnessName);
+                for (const heim of ansicht.heime) {
+                    const wie = heim.adresse ?? (heim.eingestellt ? 'home (eingestellt)' : 'home');
+                    console.log(`${harnessName}  ${wie}  ${heim.pfad}`);
+                }
+                if (ansicht.kannZusaetzliche)
+                    console.log(`  Weiteres Homedir: hmgr harness home ${harnessName} add wsl:<distro>.`);
+                return 0;
+            }
+            if (unter === 'set') {
+                restPruefen(rest, 4, 'harness', 'home');
+                const pfad = rest[3];
+                if (pfad === undefined)
+                    throw new Error('harness home <name> set braucht einen Pfad, etwa hmgr harness home claude-code set D:\\Profile\\tim.');
+                const gesetzt = await anwendungsfaelle.harnessHeimSetzen(harnessName, pfad);
+                console.log(`${harnessName} liest sein Homedir jetzt unter ${gesetzt}.`);
+                console.log('  Was am alten Ort liegt, bleibt dort liegen. hmgr zeigt es nicht mehr.');
+                return 0;
+            }
+            if (unter === 'reset') {
+                restPruefen(rest, 3, 'harness', 'home');
+                await anwendungsfaelle.harnessHeimZuruecksetzen(harnessName);
+                const ansicht = (await anwendungsfaelle.harnessHeime()).find((h) => h.harness === harnessName);
+                console.log(`${harnessName} liest sein Homedir wieder unter ${ansicht?.heime[0]?.pfad ?? '?'}.`);
+                return 0;
+            }
+            if (unter === 'add') {
+                restPruefen(rest, 4, 'harness', 'home');
+                const adresse = rest[3];
+                if (adresse === undefined) {
+                    const distros = await anwendungsfaelle.wslDistros();
+                    const beispiel = distros[0] ?? 'Ubuntu';
+                    throw new Error(`harness home <name> add braucht eine Adresse, etwa hmgr harness home ${harnessName} add wsl:${beispiel}.` +
+                        (distros.length > 0 ? ` Installierte Distros: ${distros.join(', ')}.` : ''));
+                }
+                const heim = await anwendungsfaelle.harnessHeimHinzufuegen(harnessName, adresse);
+                console.log(`${harnessName} ${heim.adresse}: Homedir ${heim.pfad}.`);
+                console.log(`  Verlinken dorthin mit --harness ${harnessName} --ort ${heim.adresse}.`);
+                return 0;
+            }
+            if (unter === 'remove') {
+                restPruefen(rest, 4, 'harness', 'home');
+                const adresse = rest[3];
+                if (adresse === undefined)
+                    throw new Error(`harness home <name> remove braucht eine Adresse, etwa hmgr harness home ${harnessName} remove wsl:Ubuntu.`);
+                await anwendungsfaelle.harnessHeimEntfernen(harnessName, adresse);
+                console.log(`${harnessName} ${adresse}: Homedir vergessen. Die Links dort bleiben liegen.`);
+                return 0;
+            }
+            throw new Error(`Unbekanntes Unterkommando „${unter}" für harness home: harness home <name>, ` +
+                'harness home <name> set <pfad>, harness home <name> reset, harness home <name> add wsl:<distro> ' +
+                'oder harness home <name> remove wsl:<distro>. hmgr help harness zeigt Beispiele.');
+        }
         if (unterkommando === 'list') {
             const aktive = new Set(await anwendungsfaelle.aktiveHarnesses());
             const fehlend = new Set(await anwendungsfaelle.nichtVorhandeneHarnesses());
+            const heime = await anwendungsfaelle.harnessHeime();
             for (const name of anwendungsfaelle.harnessTypen()) {
                 const aktivText = aktive.has(name) ? 'aktiv' : 'inaktiv';
                 const vorhandenText = fehlend.has(name) ? 'nicht vorhanden' : 'vorhanden';
-                console.log(`${name}  ${aktivText}, ${vorhandenText}`);
+                // Zusätzliche Homedirs (E78) gehören in die Übersicht: sonst sähe niemand, dass ein
+                // zweites Ziel je Harness existiert, ohne extra danach zu fragen.
+                const zusatz = (heime.find((h) => h.harness === name)?.heime ?? []).filter((h) => h.adresse !== undefined);
+                const heimText = zusatz.length === 0 ? '' : `, ${zusatz.map((h) => h.adresse).join(', ')}`;
+                console.log(`${name}  ${aktivText}, ${vorhandenText}${heimText}`);
             }
             return 0;
         }
@@ -845,7 +987,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             }
             return 0;
         }
-        throw new Error(`${unterkommando === undefined ? 'harness braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für harness`}: harness list, harness enable <name> oder harness disable <name>. hmgr help harness zeigt Beispiele.`);
+        throw new Error(`${unterkommando === undefined ? 'harness braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für harness`}: harness list, harness enable <name>, harness disable <name> oder harness home <name>. hmgr help harness zeigt Beispiele.`);
     }
     throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
 }
@@ -874,6 +1016,40 @@ function bundleBericht(eintraege) {
     }
     return zeilen;
 }
+/** Kopfzeile eines Verlaufseintrags (E80): lokale Zeit, damit sie zum Rechner des Lesers passt. */
+function verlaufZeitpunkt(iso) {
+    const datum = new Date(iso);
+    const zwei = (n) => String(n).padStart(2, '0');
+    return (`${zwei(datum.getDate())}.${zwei(datum.getMonth() + 1)}.${datum.getFullYear()} ` +
+        `${zwei(datum.getHours())}:${zwei(datum.getMinutes())}`);
+}
+/** Eine Ereigniszeile im Verlauf (E80), eingerückt unter der Kopfzeile ihres Laufs. */
+function verlaufEreignisZeile(ereignis) {
+    if (ereignis.art === 'checkout') {
+        const stand = `${ereignis.von.slice(0, 7)} → ${ereignis.nach.slice(0, 7)}`;
+        const skills = ereignis.skills.length > 0 ? `, Skills: ${ereignis.skills.join(', ')}` : '';
+        return `${ereignis.quelle} @ ${ereignis.ref}: ${stand}${skills}`;
+    }
+    if (ereignis.art === 'bundle') {
+        const teile = [
+            ereignis.gelegt.length > 0 ? `gelegt ${ereignis.gelegt.join(', ')}` : undefined,
+            ereignis.entfernt.length > 0 ? `entfernt ${ereignis.entfernt.join(', ')}` : undefined,
+        ].filter((t) => t !== undefined);
+        // Formatierung wie in bundleBericht (Harness + beschreibeOrt); ein String-Ziel (vor E80-Nachtrag
+        // geschrieben) bleibt unverändert stehen.
+        const ziel = typeof ereignis.ziel === 'string' ? ereignis.ziel : `${ereignis.ziel.harness} ${beschreibeOrt(ereignis.ziel.ort)}`;
+        return `Bundle ${ereignis.bundle} → ${ziel}: ${teile.join('; ')}`;
+    }
+    if (ereignis.art === 'aufgeraeumt')
+        return `Checkout ${ereignis.checkout} aufgeräumt`;
+    if (ereignis.art === 'fehler')
+        return `Fehler ${ereignis.betrifft}: ${ereignis.fehler}`;
+    if (ereignis.art === 'hmgr-installiert')
+        return ereignis.paket === 'gui' ? `hmgr-GUI ${ereignis.version} installiert` : `hmgr ${ereignis.version} installiert`;
+    if (ereignis.art === 'gui-update-geladen')
+        return `GUI-Update ${ereignis.version} geladen`;
+    return `CLI ${ereignis.version} verfügbar`;
+}
 /** Grund eines Links als Suffix (E37). „manuell" bleibt stumm, damit die Ausgabe ruhig bleibt. */
 function beschreibeGrund(grund) {
     if (grund === undefined || grund.art === 'manuell')
@@ -888,9 +1064,10 @@ function zahlwort(n, ein, viele) {
 function kappen(text, laenge = 80) {
     return text.length <= laenge ? text : `${text.slice(0, laenge - 1)}…`;
 }
+/** Ort als Text, so geschrieben, wie `--ort` ihn wieder annimmt. */
 function beschreibeOrt(ort) {
     if (ort.art === 'home')
-        return 'home';
+        return ort.heim === undefined ? 'home' : ort.heim;
     if (ort.art === 'profil')
         return `profil:${ort.name}`;
     return `dir:${ort.pfad}`;
@@ -904,6 +1081,7 @@ function istModellFehler(fehler) {
         fehler instanceof ZeigerMehrdeutig ||
         fehler instanceof ZeigerSchreibenGesperrt ||
         fehler instanceof HarnessNichtVorhanden ||
+        fehler instanceof HarnessInaktiv ||
         fehler instanceof HarnessTypUnbekannt ||
         fehler instanceof KeinPassenderRef ||
         fehler instanceof EinschraenkungOhneZeiger ||
@@ -931,7 +1109,14 @@ function istModellFehler(fehler) {
         fehler instanceof McpNurGeteilterFundort ||
         fehler instanceof McpUebernahmeNichtMoeglich ||
         fehler instanceof McpNichtInGeteilterDatei ||
-        fehler instanceof McpUebernahmeUnvollstaendig);
+        fehler instanceof McpUebernahmeUnvollstaendig ||
+        fehler instanceof HeimAdresseUngueltig ||
+        fehler instanceof HeimBereitsVorhanden ||
+        fehler instanceof HeimFaehigkeitFehlt ||
+        fehler instanceof HeimNurUnterWindows ||
+        fehler instanceof HeimOhneCliZugriff ||
+        fehler instanceof HeimUnbekannt ||
+        fehler instanceof WslBrueckeFehlgeschlagen);
 }
 /**
  * Der nächste Schritt zu einem Fehler aus dem Kern. Die Fehlertexte selbst bleiben, wie das Modell
@@ -966,10 +1151,26 @@ function naechsterSchritt(fehler) {
         return 'Die Tags der Quelle sind frisch geholt, keiner passt. Sonst einen vorhandenen Tag- oder Branchnamen als --version nennen.';
     if (fehler instanceof HarnessNichtVorhanden)
         return 'Der Harness legt sein Verzeichnis beim ersten Start an. hmgr status zeigt, welche Harnesses hier liegen.';
+    if (fehler instanceof HarnessInaktiv)
+        return `Erst aktivieren: hmgr harness enable ${fehler.harness}. Bestehende Links dort bleiben unberührt.`;
     if (fehler instanceof OrtNichtUnterstuetzt)
         return 'profil:<name> kennt nur hermes, claude-code und agents kennen home und dir:<pfad>.';
     if (fehler instanceof HarnessTypUnbekannt)
         return 'Bekannt sind claude-code, hermes und agents. hmgr harness list zeigt sie mit ihrem Stand.';
+    if (fehler instanceof HeimAdresseUngueltig)
+        return 'Ein zusätzliches Homedir wird als wsl:<distro> angegeben. Ein abweichender normaler Pfad gehört an hmgr harness home <name> set <pfad>.';
+    if (fehler instanceof HeimFaehigkeitFehlt)
+        return 'Zusätzliche Homedirs kennt bisher nur claude-code. Für einen abweichenden Pfad: hmgr harness home <name> set <pfad>.';
+    if (fehler instanceof HeimNurUnterWindows)
+        return 'Auf diesem Rechner gibt es kein WSL. Das Homedir wird auf dem Windows-Rechner eingetragen, auf dem die Distro läuft.';
+    if (fehler instanceof HeimBereitsVorhanden)
+        return `hmgr harness home ${fehler.harness} zeigt die eingetragenen Homedirs.`;
+    if (fehler instanceof HeimUnbekannt)
+        return `hmgr harness home ${fehler.harness} zeigt die eingetragenen Homedirs, add trägt eines ein.`;
+    if (fehler instanceof HeimOhneCliZugriff)
+        return 'Skill-Links dort legt hmgr selbst: hmgr link <skill> --harness claude-code --ort <adresse>.';
+    if (fehler instanceof WslBrueckeFehlgeschlagen)
+        return 'wsl -l -q zeigt die installierten Distros. Startet die Distro nicht, hilft wsl --shutdown und ein erneuter Versuch.';
     if (fehler instanceof QuelleUnbekannt)
         return 'hmgr source list zeigt die bekannten Quellen.';
     if (fehler instanceof QuelleNameBelegt)

package/dist/gui/hmgr-cli.js

@@ -0,0 +1,44 @@
+// Die installierte hmgr-CLI aus Sicht der GUI (E77). Die GUI trägt ihre eigene Version in sich
+// (`paketVersion()`, E72) — die CLI daneben ist ein zweites, unabhängig installiertes Paket, ihre
+// Version steht nur über ihren eigenen Aufruf fest.
+import spawn from 'cross-spawn';
+import { versionLesen } from "../kern/version.js";
+/**
+ * `hmgr --version` (E72: nur die Nummer, Exit 0). Null heißt „nichts zu melden": keine CLI im PATH,
+ * Fehlercode, Timeout, oder eine Ausgabe, die keine Version ist. Kein Fehler dringt nach außen —
+ * eine fehlende CLI ist der Normalfall bei einer reinen GUI-Installation, keine Störung.
+ *
+ * `spawn` von cross-spawn wie im claude-Adapter (E65/B7): unter Windows ist die npm-installierte
+ * `hmgr` ein `.cmd`-Shim, das Node seit dem Fix zu CVE-2024-27980 ohne Umweg über cmd.exe nicht
+ * mehr startet. stdin zu und ein Timeout, damit nichts hängen bleibt.
+ */
+export function hmgrCliVersion() {
+    return new Promise((aufloesen) => {
+        let fertig = false;
+        const melden = (wert) => {
+            if (fertig)
+                return;
+            fertig = true;
+            aufloesen(wert);
+        };
+        try {
+            const kind = spawn('hmgr', ['--version'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 10_000,
+                killSignal: 'SIGKILL',
+            });
+            let stdout = '';
+            kind.stdout.on('data', (stueck) => (stdout += stueck));
+            kind.on('error', () => melden(null));
+            kind.on('close', (code) => {
+                if (code !== 0)
+                    return melden(null);
+                const text = stdout.trim().split('\n')[0]?.trim() ?? '';
+                melden(versionLesen(text) === null ? null : text);
+            });
+        }
+        catch {
+            melden(null);
+        }
+    });
+}