hmgr 0.0.6 → 0.0.12

package/dist/cli/main.js

@@ -4,19 +4,24 @@ import path from 'node:path';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { Anwendungsfaelle } from "../kern/anwendungsfaelle.js";
-import { AbhaengigkeitFehlt, 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 { Anwendungsfaelle, } from "../kern/anwendungsfaelle.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();
@@ -29,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 };
 }
@@ -59,10 +90,12 @@ const SCHALTER = {
     unlink: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal'] },
     adopt: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal', 'probelauf'] },
     plugin: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: ['local', 'lokal'] },
+    bundle: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: [] },
     mcp: { werte: ['harness', 'ort'], flaggen: [] },
     sync: { werte: [], flaggen: [] },
     update: { werte: [], flaggen: [] },
     status: { werte: [], flaggen: [] },
+    log: { werte: [], flaggen: [] },
     harness: { werte: ['profil'], flaggen: [] },
 };
 /**
@@ -87,6 +120,13 @@ const UNTERKOMMANDOS = {
         remove: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'local', 'lokal'] },
         list: { woerter: 1, schalter: [] },
     },
+    bundle: {
+        add: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'quelle'] },
+        remove: { woerter: 2, schalter: ['harness', 'ort', 'composer'] },
+        // sync nimmt einen Bundle-Namen, aber keinen zwingend: ohne Namen gilt der ganze Bestand.
+        sync: { woerter: 2, schalter: ['harness', 'ort', 'composer'] },
+        list: { woerter: 1, schalter: [] },
+    },
     mcp: {
         add: { woerter: 2, schalter: ['harness', 'ort'] },
         remove: { woerter: 2, schalter: ['harness', 'ort'] },
@@ -156,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')
@@ -164,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 = {
@@ -179,6 +227,11 @@ const UEBERNAHME_GRUND = {
 export async function ausfuehren(argv, umgebung, optionen = {}) {
     const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
     const kommando = argv[0];
+    // Version vor allem anderen (E72): nur die Nummer, damit ein Skript sie ohne Nacharbeit liest.
+    if (kommando === '--version') {
+        console.log(paketVersion());
+        return 0;
+    }
     // Hilfe zuerst: --help ist überall eine Flagge, damit kein Kommando sie als Wert liest.
     if (kommando === undefined) {
         console.log(HILFE);
@@ -203,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);
@@ -377,6 +438,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         if (kommando === 'unlink') {
             const ergebnis = await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
             console.log(`Link ${skill} entfernt.`);
+            // Zerbrochen (E69): die übrigen Links des Bundles bleiben als Einzel-Installationen liegen.
+            for (const bundle of ergebnis.zerbrochen)
+                console.log(`Bundle „${bundle}" ist damit zerbrochen, seine übrigen Links bleiben als einzelne Links liegen.`);
             if (ergebnis.hinweis !== undefined)
                 console.log(ergebnis.hinweis);
             return 0;
@@ -490,6 +554,89 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(`  ${zeile}`);
         return 0;
     }
+    if (kommando === 'bundle') {
+        const schalter = schalterLesen(argv.slice(1), 'bundle');
+        unterkommandoPruefen('bundle', schalter);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
+        if (unterkommando === 'list') {
+            const katalog = await anwendungsfaelle.bundleKatalog();
+            const leer = katalog.every((k) => k.bundles.length === 0 && k.kaputte.length === 0 && k.fehler === undefined);
+            if (leer)
+                console.log('Keine Quelle mit Bundles. hmgr help bundle zeigt das Format von bundles/<name>.yaml.');
+            for (const eintrag of katalog) {
+                if (eintrag.fehler !== undefined) {
+                    console.log(`Quelle ${quelleName(eintrag.quelle)}  (${quelleAlsText(eintrag.quelle)})  nicht lesbar: ${eintrag.fehler}`);
+                    continue;
+                }
+                if (eintrag.bundles.length === 0 && eintrag.kaputte.length === 0)
+                    continue;
+                console.log(`Quelle ${quelleName(eintrag.quelle)}  (${quelleAlsText(eintrag.quelle)})`);
+                for (const bundle of eintrag.bundles) {
+                    console.log(`  ${bundle.name}  ${kappen(bundle.beschreibung)}`);
+                    for (const mitglied of bundle.mitglieder)
+                        console.log(`    ${mitglied.pfad}  aus ${quelleAlsText(mitglied.quelle)}`);
+                }
+                // Eine kaputte Definition verdeckt die übrigen nicht, sie wird eigens genannt (E69).
+                for (const kaputt of eintrag.kaputte)
+                    console.log(`  Fehler  ${kaputt.datei}: ${kaputt.fehler}`);
+            }
+            return 0;
+        }
+        if (unterkommando !== 'add' && unterkommando !== 'remove' && unterkommando !== 'sync')
+            throw new Error(`${unterkommando === undefined ? 'bundle braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für bundle`}: bundle add <name>, bundle remove <name>, bundle sync [name] oder bundle list. hmgr help bundle zeigt Beispiele.`);
+        const name = rest[1];
+        if (name === undefined && unterkommando !== 'sync')
+            throw new Error(`bundle ${unterkommando} braucht einen Bundle-Namen. hmgr bundle list zeigt die Bundles der bekannten Quellen.`);
+        const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
+        if (ziel.ort.art === 'arbeitsverzeichnis') {
+            // Wie bei link: Verzeichnis merken und binden, damit status es wiederfindet (E21).
+            const composer = werte.get('composer');
+            if (composer === undefined)
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
+            else
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+        }
+        if (unterkommando === 'add') {
+            const quelle = werte.get('quelle');
+            const ergebnis = await anwendungsfaelle.bundleInstallieren({
+                bundle: name,
+                ziel,
+                ...(quelle === undefined ? {} : { quelle }),
+            });
+            console.log(`Bundle ${ergebnis.bundle.name} in ${ziel.harness} ${beschreibeOrt(ziel.ort)} installiert (${quelleAlsText(ergebnis.bundle.quelle)}).`);
+            for (const neu of ergebnis.neueQuellen)
+                console.log(`  neue Quelle   ${quelleAlsText(neu)} als „${quelleName(neu)}"`);
+            if (ergebnis.gelegt.length > 0)
+                console.log(`  gelegt        ${ergebnis.gelegt.join(', ')}`);
+            // Übernommen (F67): schon vorhandene Links derselben Quelle gehören jetzt zum Bundle.
+            if (ergebnis.uebernommen.length > 0)
+                console.log(`  übernommen    ${ergebnis.uebernommen.join(', ')}`);
+            if (ergebnis.hinweis !== undefined)
+                for (const zeile of ergebnis.hinweis.split('\n'))
+                    console.log(`  ${zeile}`);
+            return 0;
+        }
+        if (unterkommando === 'remove') {
+            const ergebnis = await anwendungsfaelle.bundleEntfernen({ bundle: name, ziel });
+            console.log(`Bundle ${ergebnis.bundle} aus ${ziel.harness} ${beschreibeOrt(ziel.ort)} entfernt.`);
+            console.log(ergebnis.entfernt.length === 0
+                ? '  Kein Link mehr da, nur der Bundle-Verweis ist weg.'
+                : `  entfernt      ${ergebnis.entfernt.join(', ')}`);
+            return 0;
+        }
+        // sync: ohne Ziel-Schalter der ganze Bestand, mit --ort/--harness nur dieses Ziel.
+        const nurZiel = werte.has('harness') || werte.has('ort');
+        const eintraege = await anwendungsfaelle.bundleAbgleich({
+            ...(name === undefined ? {} : { bundle: name }),
+            ...(nurZiel ? { ziel } : {}),
+        });
+        if (eintraege.length === 0)
+            console.log('Kein Bundle installiert, nichts abzugleichen.');
+        for (const zeile of bundleBericht(eintraege))
+            console.log(zeile);
+        return 0;
+    }
     if (kommando === 'mcp') {
         const schalter = schalterLesen(argv.slice(1), 'mcp');
         unterkommandoPruefen('mcp', schalter);
@@ -568,13 +715,18 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'update') {
         restPruefen(schalterLesen(argv.slice(1), 'update').rest, 0, 'update');
-        const { checkouts: liste, pluginHarnesses, 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 } of liste) {
+        for (const { checkout, aktualisierung, geaenderteSkills } of liste) {
             const kopf = `${quelleAlsText(checkout.quelle)} @ ${checkout.ref}`;
-            if (aktualisierung.ergebnis === 'aktualisiert')
+            if (aktualisierung.ergebnis === 'aktualisiert') {
                 console.log(`  aktualisiert    ${kopf}  ${aktualisierung.von.slice(0, 8)} -> ${aktualisierung.nach.slice(0, 8)}`);
+                // Auf Skill-Ebene berichten (E70): sonst steht da nur, dass die Quelle neue Commits hat.
+                // Ohne Treffer bleibt die Zeile weg — der Commit hat dann nichts in einem Skill geändert.
+                if (geaenderteSkills.length > 0)
+                    console.log(`                  ${zahlwort(geaenderteSkills.length, 'Skill', 'Skills')} geändert: ${geaenderteSkills.join(', ')}`);
+            }
             else if (aktualisierung.ergebnis === 'unveraendert')
                 console.log(`  unverändert     ${kopf}`);
             else if (aktualisierung.ergebnis === 'uebersprungen')
@@ -582,8 +734,9 @@ 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);
         // Zum Schluss die verwaisten Checkouts: was gelöscht wurde und was liegen bleibt.
         for (const verwaist of aufraeumen.verwaiste) {
             const kopf = `${quelleAlsText(verwaist.checkout.quelle)} @ ${verwaist.checkout.ref}`;
@@ -598,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)');
@@ -618,6 +786,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                     console.log(`  ${eintrag.link.name}  ${spanne}${quelleAlsText(eintrag.link.checkout.quelle)} @ ${eintrag.link.checkout.ref} (${eintrag.link.skill.pfad})${beschreibeGrund(zielZustand.gruende.get(eintrag.link.name))}`);
                 }
             }
+            // Bundles des Ziels (E69), unter den Einträgen: welche Links als Einheit zusammengehören.
+            for (const bundle of zielZustand.bundles)
+                console.log(`  Bundle ${bundle.name}  (${quelleAlsText(bundle.quelle)})  ${bundle.skills.join(', ')}`);
             if (zielZustand.plugins !== undefined)
                 console.log(`  Plugins: ${zielZustand.plugins.length === 0 ? 'keine' : zielZustand.plugins.join(', ')}`);
         }
@@ -626,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);
@@ -679,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;
         }
@@ -734,10 +987,69 @@ 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.`);
 }
+/**
+ * Bericht über den Bundle-Abgleich (E69), gleich für `hmgr bundle sync` und `hmgr update`: je
+ * Bundle eine Zeile mit seinem Ausgang, darunter, was sich geändert hat. „fehlgeschlagen" heißt
+ * genau das — der Zusatz sagt, dass das Bundle im Ziel auf dem alten Stand bleibt.
+ */
+function bundleBericht(eintraege) {
+    const zeilen = [];
+    for (const eintrag of eintraege) {
+        const kopf = `Bundle ${eintrag.bundle}  ${eintrag.ziel.harness} ${beschreibeOrt(eintrag.ziel.ort)}`;
+        if (eintrag.ergebnis === 'fehlgeschlagen') {
+            zeilen.push(`  fehlgeschlagen  ${kopf}  bleibt auf dem alten Stand`);
+            for (const zeile of (eintrag.fehler ?? '').split('\n'))
+                zeilen.push(`    ${zeile}`);
+            continue;
+        }
+        zeilen.push(`  ${eintrag.ergebnis === 'aktualisiert' ? 'aktualisiert   ' : 'unverändert    '} ${kopf}`);
+        for (const neu of eintrag.neueQuellen)
+            zeilen.push(`    neue Quelle   ${quelleAlsText(neu)}`);
+        if (eintrag.gelegt.length > 0)
+            zeilen.push(`    gelegt        ${eintrag.gelegt.join(', ')}`);
+        if (eintrag.entfernt.length > 0)
+            zeilen.push(`    entfernt      ${eintrag.entfernt.join(', ')}`);
+    }
+    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')
@@ -752,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}`;
@@ -768,12 +1081,19 @@ function istModellFehler(fehler) {
         fehler instanceof ZeigerMehrdeutig ||
         fehler instanceof ZeigerSchreibenGesperrt ||
         fehler instanceof HarnessNichtVorhanden ||
+        fehler instanceof HarnessInaktiv ||
         fehler instanceof HarnessTypUnbekannt ||
         fehler instanceof KeinPassenderRef ||
         fehler instanceof EinschraenkungOhneZeiger ||
         fehler instanceof PluginMehrdeutig ||
         fehler instanceof PluginUnbekannt ||
         fehler instanceof AbhaengigkeitFehlt ||
+        fehler instanceof BundleUnbekannt ||
+        fehler instanceof BundleMehrdeutig ||
+        fehler instanceof BundleMitgliederFehlen ||
+        fehler instanceof BundleNamenskonflikte ||
+        fehler instanceof BundleNichtInstalliert ||
+        fehler instanceof BundleDateiFehler ||
         fehler instanceof QuelleUnbekannt ||
         fehler instanceof QuelleNameBelegt ||
         fehler instanceof QuelleAufraeumenLokaleAenderungen ||
@@ -789,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
@@ -808,14 +1135,42 @@ function naechsterSchritt(fehler) {
         return 'hmgr plugin list zeigt die Plugins der bekannten Quellen. Fehlt der Marketplace, erst hmgr source add <url>.';
     if (fehler instanceof AbhaengigkeitFehlt)
         return 'Die Abhängigkeit steht in keinem Plugin desselben Marketplace, das kann nur die Quelle beheben.';
+    if (fehler instanceof BundleUnbekannt)
+        return 'hmgr bundle list zeigt die Bundles der bekannten Quellen. Fehlt die Quelle, erst hmgr source add <url|pfad>.';
+    if (fehler instanceof BundleMehrdeutig)
+        return 'Quelle eingrenzen: --quelle <teilstring der URL oder des Pfads>. hmgr bundle list zeigt, wo welches Bundle steht.';
+    if (fehler instanceof BundleMitgliederFehlen)
+        return 'Das Bundle ist nur ganz oder gar nicht zu haben. Wer nur einen Teil braucht, verlinkt die erreichbaren Skills einzeln mit hmgr link.';
+    if (fehler instanceof BundleNamenskonflikte)
+        return 'Die genannten Namen erst freimachen (hmgr unlink <skill> bzw. hmgr adopt <name>), dann bundle add erneut.';
+    if (fehler instanceof BundleNichtInstalliert)
+        return 'hmgr status zeigt je Ziel, welche Bundles dort installiert sind.';
+    if (fehler instanceof BundleDateiFehler)
+        return 'Die Definition liegt in der Quelle und wird dort korrigiert, hmgr schreibt sie nie. hmgr help bundle zeigt das Format.';
     if (fehler instanceof KeinPassenderRef)
         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);
+        }
+    });
+}